@orval/core 8.0.0-rc.2 → 8.0.0-rc.3

package/dist/index.d.mts

@@ -1,12 +1,8 @@
 import { CompareOperator } from "compare-versions";
 import debug from "debug";
-import { ConvertInputOptions } from "swagger2openapi";
-import SwaggerParser from "@apidevtools/swagger-parser";
 import { allLocales } from "@faker-js/faker";
-import { JSONSchema6, JSONSchema7 } from "json-schema";
-import { ComponentsObject, ExampleObject, InfoObject, OpenAPIObject, OperationObject, ParameterObject, PathItemObject, ReferenceObject, RequestBodyObject, ResponseObject, ResponsesObject, SchemaObject, SchemasObject } from "openapi3-ts/oas30";
+import { OpenAPIV3_1 } from "@scalar/openapi-types";
 import { TypeDocOptions } from "typedoc";
-import { ServerObject } from "openapi3-ts/oas31";
 
 //#region src/types.d.ts
 interface Options {
@@ -62,7 +58,7 @@ type NormalizedOverrideOutput = {
   tags: Record<string, NormalizedOperationOptions | undefined>;
   mock?: OverrideMockOptions;
   contentType?: OverrideOutputContentType;
-  header: false | ((info: InfoObject) => string[] | string);
+  header: false | ((info: OpenApiInfoObject) => string[] | string);
   formData: NormalizedFormDataType<NormalizedMutator>;
   formUrlEncoded: boolean | NormalizedMutator;
   paramsSerializer?: NormalizedMutator;
@@ -91,7 +87,7 @@ type NormalizedOverrideOutput = {
   swr: SwrOptions;
   zod: NormalizedZodOptions;
   fetch: NormalizedFetchOptions;
-  operationName?: (operation: OperationObject, route: string, verb: Verbs) => string;
+  operationName?: (operation: OpenApiOperationObject, route: string, verb: Verbs) => string;
   requestOptions: Record<string, any> | boolean;
   useDates?: boolean;
   useTypeOverInterfaces?: boolean;
@@ -121,7 +117,7 @@ type NormalizedOperationOptions = {
   angular?: Required<AngularOptions>;
   swr?: SwrOptions;
   zod?: NormalizedZodOptions;
-  operationName?: (operation: OperationObject, route: string, verb: Verbs) => string;
+  operationName?: (operation: OpenApiOperationObject, route: string, verb: Verbs) => string;
   fetch?: FetchOptions;
   formData?: NormalizedFormDataType<NormalizedMutator>;
   formUrlEncoded?: boolean | NormalizedMutator;
@@ -129,12 +125,9 @@ type NormalizedOperationOptions = {
   requestOptions?: object | boolean;
 };
 type NormalizedInputOptions = {
-  target: string | Record<string, unknown> | OpenAPIObject;
-  validation: boolean | object;
+  target: string | OpenApiDocument;
   override: OverrideInput;
-  converterOptions: Partial<ConvertInputOptions>;
-  parserOptions: SwaggerParserOptions;
-  filters?: InputFiltersOption;
+  filters?: InputFiltersOptions;
 };
 type OutputClientFunc = (clients: GeneratorClients) => ClientGeneratorsBuilder;
 type BaseUrlFromSpec = {
@@ -193,21 +186,15 @@ type OutputOptions = {
   optionsParamRequired?: boolean;
   propertySortOrder?: PropertySortOrder;
 };
-type SwaggerParserOptions = Omit<SwaggerParser.Options, 'validate'> & {
-  validate?: boolean;
-};
-type InputFiltersOption = {
+type InputFiltersOptions = {
   mode?: 'include' | 'exclude';
   tags?: (string | RegExp)[];
   schemas?: (string | RegExp)[];
 };
 type InputOptions = {
-  target: string | Record<string, unknown> | OpenAPIObject;
-  validation?: boolean | object;
+  target: string | Record<string, unknown> | OpenApiDocument;
   override?: OverrideInput;
-  converterOptions?: Partial<ConvertInputOptions>;
-  parserOptions?: SwaggerParserOptions;
-  filters?: InputFiltersOption;
+  filters?: InputFiltersOptions;
 };
 declare const OutputClient: {
   readonly ANGULAR: "angular";
@@ -274,12 +261,12 @@ type MockOptions = Omit<OverrideMockOptions, 'properties'> & {
   }>;
 };
 type MockPropertiesObject = Record<string, unknown>;
-type MockPropertiesObjectFn = (specs: OpenAPIObject) => MockPropertiesObject;
+type MockPropertiesObjectFn = (specs: OpenApiDocument) => MockPropertiesObject;
 type MockProperties = MockPropertiesObject | MockPropertiesObjectFn;
 type MockDataObject = Record<string, unknown>;
-type MockDataObjectFn = (specs: OpenAPIObject) => MockDataObject;
+type MockDataObjectFn = (specs: OpenApiDocument) => MockDataObject;
 type MockDataArray = unknown[];
-type MockDataArrayFn = (specs: OpenAPIObject) => MockDataArray;
+type MockDataArrayFn = (specs: OpenApiDocument) => MockDataArray;
 type MockData = MockDataObject | MockDataObjectFn | MockDataArray | MockDataArrayFn;
 type OutputTransformerFn = (verb: GeneratorVerbOptions) => GeneratorVerbOptions;
 type OutputTransformer = string | OutputTransformerFn;
@@ -324,7 +311,7 @@ type OverrideOutput = {
   tags?: Record<string, OperationOptions>;
   mock?: OverrideMockOptions;
   contentType?: OverrideOutputContentType;
-  header?: boolean | ((info: InfoObject) => string[] | string);
+  header?: boolean | ((info: OpenApiInfoObject) => string[] | string);
   formData?: boolean | Mutator | FormDataType<Mutator>;
   formUrlEncoded?: boolean | Mutator;
   paramsSerializer?: Mutator;
@@ -352,7 +339,7 @@ type OverrideOutput = {
   swr?: SwrOptions;
   angular?: AngularOptions;
   zod?: ZodOptions;
-  operationName?: (operation: OperationObject, route: string, verb: Verbs) => string;
+  operationName?: (operation: OpenApiOperationObject, route: string, verb: Verbs) => string;
   fetch?: FetchOptions;
   requestOptions?: Record<string, any> | boolean;
   useDates?: boolean;
@@ -529,7 +516,7 @@ type FetchOptions = {
   forceSuccessResponse?: boolean;
   jsonReviver?: Mutator;
 };
-type InputTransformerFn = (spec: OpenAPIObject) => OpenAPIObject;
+type InputTransformerFn = (spec: OpenApiDocument) => OpenApiDocument;
 type InputTransformer = string | InputTransformerFn;
 type OverrideInput = {
   transformer?: InputTransformer;
@@ -545,7 +532,7 @@ type OperationOptions = {
   angular?: Required<AngularOptions>;
   swr?: SwrOptions;
   zod?: ZodOptions;
-  operationName?: (operation: OperationObject, route: string, verb: Verbs) => string;
+  operationName?: (operation: OpenApiOperationObject, route: string, verb: Verbs) => string;
   fetch?: FetchOptions;
   formData?: boolean | Mutator | FormDataType<Mutator>;
   formUrlEncoded?: boolean | Mutator;
@@ -572,17 +559,18 @@ declare const Verbs: {
   HEAD: Verbs;
 };
 type ImportOpenApi = {
-  data: JSONSchema6 | JSONSchema7 | Record<string, unknown | OpenAPIObject>;
+  spec: OpenApiDocument;
   input: NormalizedInputOptions;
   output: NormalizedOutputOptions;
   target: string;
   workspace: string;
+  projectName?: string;
 };
-interface ContextSpecs {
-  specKey: string;
+interface ContextSpec {
+  projectName?: string;
   target: string;
   workspace: string;
-  specs: Record<string, OpenAPIObject>;
+  spec: OpenApiDocument;
   parents?: string[];
   output: NormalizedOutputOptions;
 }
@@ -620,13 +608,13 @@ type GeneratorSchema = {
   name: string;
   model: string;
   imports: GeneratorImport[];
+  dependencies?: string[];
 };
 type GeneratorImport = {
   name: string;
   schemaName?: string;
   isConstant?: boolean;
   alias?: string;
-  specKey?: string;
   default?: boolean;
   values?: boolean;
   syntheticDefaultImport?: boolean;
@@ -712,14 +700,14 @@ type GeneratorVerbOptions = {
   fetchReviver?: GeneratorMutator;
   override: NormalizedOverrideOutput;
   deprecated?: boolean;
-  originalOperation: OperationObject;
+  originalOperation: OpenApiOperationObject;
 };
 type GeneratorVerbsOptions = GeneratorVerbOptions[];
 type GeneratorOptions = {
   route: string;
   pathRoute: string;
   override: NormalizedOverrideOutput;
-  context: ContextSpecs;
+  context: ContextSpec;
   mock?: GlobalMockOptions | ClientMockBuilder;
   output: string;
 };
@@ -748,7 +736,7 @@ type ClientFileBuilder = {
   path: string;
   content: string;
 };
-type ClientExtraFilesBuilder = (verbOptions: Record<string, GeneratorVerbOptions>, output: NormalizedOutputOptions, context: ContextSpecs) => Promise<ClientFileBuilder[]>;
+type ClientExtraFilesBuilder = (verbOptions: Record<string, GeneratorVerbOptions>, output: NormalizedOutputOptions, context: ContextSpec) => Promise<ClientFileBuilder[]>;
 type ClientHeaderBuilder = (params: {
   title: string;
   isRequestOptions: boolean;
@@ -803,10 +791,10 @@ type GetterResponse = {
   };
   contentTypes: string[];
   schemas: GeneratorSchema[];
-  originalSchema?: ResponsesObject;
+  originalSchema?: OpenApiResponsesObject;
 };
 type GetterBody = {
-  originalSchema: ReferenceObject | RequestBodyObject;
+  originalSchema: OpenApiReferenceObject | OpenApiRequestBodyObject;
   imports: GeneratorImport[];
   definition: string;
   implementation: string;
@@ -818,15 +806,15 @@ type GetterBody = {
 };
 type GetterParameters = {
   query: {
-    parameter: ParameterObject;
+    parameter: OpenApiParameterObject;
     imports: GeneratorImport[];
   }[];
   path: {
-    parameter: ParameterObject;
+    parameter: OpenApiParameterObject;
     imports: GeneratorImport[];
   }[];
   header: {
-    parameter: ParameterObject;
+    parameter: OpenApiParameterObject;
     imports: GeneratorImport[];
   }[];
 };
@@ -843,7 +831,7 @@ type GetterQueryParam = {
   schema: GeneratorSchema;
   deps: GeneratorSchema[];
   isOptional: boolean;
-  originalSchema?: SchemaObject;
+  originalSchema?: OpenApiSchemaObject;
 };
 type GetterPropType = 'param' | 'body' | 'queryParam' | 'header' | 'namedPathParams';
 declare const GetterPropType: {
@@ -888,11 +876,12 @@ type ScalarValue = {
   imports: GeneratorImport[];
   schemas: GeneratorSchema[];
   isRef: boolean;
+  dependencies: string[];
   example?: any;
   examples?: Record<string, any>;
 };
 type ResolverValue = ScalarValue & {
-  originalSchema: SchemaObject;
+  originalSchema: OpenApiSchemaObject;
 };
 type ResReqTypesValue = ScalarValue & {
   formData?: string;
@@ -901,26 +890,26 @@ type ResReqTypesValue = ScalarValue & {
   hasReadonlyProps?: boolean;
   key: string;
   contentType: string;
-  originalSchema?: SchemaObject;
+  originalSchema?: OpenApiSchemaObject;
 };
-type WriteSpecsBuilder = {
+type WriteSpecBuilder = {
   operations: GeneratorOperations;
-  schemas: Record<string, GeneratorSchema[]>;
   verbOptions: Record<string, GeneratorVerbOptions>;
+  schemas: GeneratorSchema[];
   title: GeneratorClientTitle;
   header: GeneratorClientHeader;
   footer: GeneratorClientFooter;
   imports: GeneratorClientImports;
   importsMock: GenerateMockImports;
   extraFiles: ClientFileBuilder[];
-  info: InfoObject;
+  info: OpenApiInfoObject;
   target: string;
 };
 type WriteModeProps = {
-  builder: WriteSpecsBuilder;
+  builder: WriteSpecBuilder;
   output: NormalizedOutputOptions;
   workspace: string;
-  specsName: Record<string, string>;
+  projectName?: string;
   header: string;
   needSchema: boolean;
 };
@@ -967,7 +956,7 @@ type GeneratorClientImports = (data: {
     exports: GeneratorImport[];
     dependency: string;
   }[];
-  specsName: Record<string, string>;
+  projectName?: string;
   hasSchemaDir: boolean;
   isAllowSyntheticDefaultImports: boolean;
   hasGlobalMutator: boolean;
@@ -982,7 +971,7 @@ type GenerateMockImports = (data: {
     exports: GeneratorImport[];
     dependency: string;
   }[];
-  specsName: Record<string, string>;
+  projectName?: string;
   hasSchemaDir: boolean;
   isAllowSyntheticDefaultImports: boolean;
   options?: GlobalMockOptions;
@@ -995,13 +984,29 @@ type GeneratorApiBuilder = GeneratorApiOperations & {
   importsMock: GenerateMockImports;
   extraFiles: ClientFileBuilder[];
 };
-interface SchemaWithConst extends SchemaObject {
-  const: string;
-}
 declare class ErrorWithTag extends Error {
   tag: string;
   constructor(message: string, tag: string, options?: ErrorOptions);
 }
+type OpenApiSchemaObjectType = 'string' | 'number' | 'boolean' | 'object' | 'integer' | 'null' | 'array';
+type OpenApiDocument = OpenAPIV3_1.Document;
+type OpenApiSchemaObject = OpenAPIV3_1.SchemaObject;
+type OpenApiSchemasObject = Record<string, OpenApiSchemaObject>;
+type OpenApiReferenceObject = OpenAPIV3_1.ReferenceObject & {
+  $ref?: string;
+};
+type OpenApiComponentsObject = OpenAPIV3_1.ComponentsObject;
+type OpenApiPathsObject = OpenAPIV3_1.PathsObject;
+type OpenApiPathItemObject = OpenAPIV3_1.PathItemObject;
+type OpenApiResponsesObject = OpenAPIV3_1.ResponsesObject;
+type OpenApiResponseObject = OpenAPIV3_1.ResponseObject;
+type OpenApiParameterObject = OpenAPIV3_1.ParameterObject;
+type OpenApiRequestBodyObject = OpenAPIV3_1.RequestBodyObject;
+type OpenApiInfoObject = OpenAPIV3_1.InfoObject;
+type OpenApiExampleObject = OpenAPIV3_1.ExampleObject;
+type OpenApiOperationObject = OpenAPIV3_1.OperationObject;
+type OpenApiMediaTypeObject = OpenAPIV3_1.MediaTypeObject;
+type OpenApiServerObject = OpenAPIV3_1.ServerObject;
 //#endregion
 //#region src/constants.d.ts
 declare const generalJSTypes: string[];
@@ -1011,95 +1016,88 @@ declare const URL_REGEX: RegExp;
 declare const TEMPLATE_TAG_REGEX: RegExp;
 //#endregion
 //#region src/generators/component-definition.d.ts
-declare const generateComponentDefinition: (responses: ComponentsObject["responses"] | ComponentsObject["requestBodies"], context: ContextSpecs, suffix: string) => GeneratorSchema[];
+declare function generateComponentDefinition(responses: OpenApiComponentsObject['responses'] | OpenApiComponentsObject['requestBodies'], context: ContextSpec, suffix: string): GeneratorSchema[];
 //#endregion
 //#region src/generators/imports.d.ts
-declare const generateImports: ({
-  imports,
-  target,
-  isRootKey,
-  specsName,
-  specKey: currentSpecKey,
-  namingConvention
-}: {
+interface GenerateImportsOptions {
   imports: GeneratorImport[];
   target: string;
-  isRootKey: boolean;
-  specsName: Record<string, string>;
-  specKey: string;
   namingConvention?: NamingConvention;
-}) => string;
-declare const generateMutatorImports: ({
-  mutators,
-  implementation,
-  oneMore
-}: {
+}
+declare function generateImports({
+  imports,
+  namingConvention
+}: GenerateImportsOptions): string;
+interface GenerateMutatorImportsOptions {
   mutators: GeneratorMutator[];
   implementation?: string;
   oneMore?: boolean;
-}) => string;
-declare const addDependency: ({
+}
+declare function generateMutatorImports({
+  mutators,
   implementation,
-  exports,
-  dependency,
-  specsName,
-  hasSchemaDir,
-  isAllowSyntheticDefaultImports
-}: {
+  oneMore
+}: GenerateMutatorImportsOptions): string;
+interface AddDependencyOptions {
   implementation: string;
   exports: GeneratorImport[];
   dependency: string;
-  specsName: Record<string, string>;
+  projectName?: string;
   hasSchemaDir: boolean;
   isAllowSyntheticDefaultImports: boolean;
-}) => string | undefined;
-declare const generateDependencyImports: (implementation: string, imports: {
+}
+declare function addDependency({
+  implementation,
+  exports,
+  dependency,
+  projectName,
+  hasSchemaDir,
+  isAllowSyntheticDefaultImports
+}: AddDependencyOptions): string | undefined;
+declare function generateDependencyImports(implementation: string, imports: {
   exports: GeneratorImport[];
   dependency: string;
-}[], specsName: Record<string, string>, hasSchemaDir: boolean, isAllowSyntheticDefaultImports: boolean) => string;
-declare const generateVerbImports: ({
+}[], projectName: string | undefined, hasSchemaDir: boolean, isAllowSyntheticDefaultImports: boolean): string;
+declare function generateVerbImports({
   response,
   body,
   queryParams,
   props,
   headers,
   params
-}: GeneratorVerbOptions) => GeneratorImport[];
+}: GeneratorVerbOptions): GeneratorImport[];
 //#endregion
 //#region src/generators/models-inline.d.ts
-declare const generateModelInline: (acc: string, model: string) => string;
-declare const generateModelsInline: (obj: Record<string, GeneratorSchema[]>) => string;
+declare function generateModelInline(acc: string, model: string): string;
+declare function generateModelsInline(obj: Record<string, GeneratorSchema[]>): string;
 //#endregion
 //#region src/generators/mutator.d.ts
 declare const BODY_TYPE_NAME = "BodyType";
+interface GenerateMutatorOptions {
+  output?: string;
+  mutator?: NormalizedMutator;
+  name: string;
+  workspace: string;
+  tsconfig?: Tsconfig;
+}
 declare function generateMutator({
   output,
   mutator,
   name,
   workspace,
   tsconfig
-}: {
-  output?: string;
-  mutator?: NormalizedMutator;
-  name: string;
-  workspace: string;
-  tsconfig?: Tsconfig;
-}): Promise<GeneratorMutator | undefined>;
+}: GenerateMutatorOptions): Promise<GeneratorMutator | undefined>;
 //#endregion
 //#region src/generators/options.d.ts
-declare const generateBodyOptions: (body: GetterBody, isFormData: boolean, isFormUrlEncoded: boolean) => string;
-declare const generateAxiosOptions: ({
-  response,
-  isExactOptionalPropertyTypes,
-  queryParams,
-  headers,
-  requestOptions,
-  hasSignal,
-  isVue,
-  isAngular,
-  paramsSerializer,
-  paramsSerializerOptions
-}: {
+interface GenerateFormDataAndUrlEncodedFunctionOptions {
+  body: GetterBody;
+  formData?: GeneratorMutator;
+  formUrlEncoded?: GeneratorMutator;
+  isFormData: boolean;
+  isFormUrlEncoded: boolean;
+}
+declare function generateBodyOptions(body: GetterBody, isFormData: boolean, isFormUrlEncoded: boolean): string;
+interface GenerateAxiosOptions {
   response: GetterResponse;
   isExactOptionalPropertyTypes: boolean;
   queryParams?: GeneratorSchema;
@@ -1110,24 +1108,20 @@ declare const generateAxiosOptions: ({
   isAngular: boolean;
   paramsSerializer?: GeneratorMutator;
   paramsSerializerOptions?: ParamsSerializerOptions;
-}) => string;
-declare const generateOptions: ({
-  route,
-  body,
-  headers,
-  queryParams,
+}
+declare function generateAxiosOptions({
   response,
-  verb,
-  requestOptions,
-  isFormData,
-  isFormUrlEncoded,
-  isAngular,
   isExactOptionalPropertyTypes,
+  queryParams,
+  headers,
+  requestOptions,
   hasSignal,
   isVue,
+  isAngular,
   paramsSerializer,
   paramsSerializerOptions
-}: {
+}: GenerateAxiosOptions): string;
+interface GenerateOptionsOptions {
   route: string;
   body: GetterBody;
   headers?: GetterQueryParam;
@@ -1143,22 +1137,27 @@ declare const generateOptions: ({
   isVue?: boolean;
   paramsSerializer?: GeneratorMutator;
   paramsSerializerOptions?: ParamsSerializerOptions;
-}) => string;
-declare const generateBodyMutatorConfig: (body: GetterBody, isFormData: boolean, isFormUrlEncoded: boolean) => string;
-declare const generateQueryParamsAxiosConfig: (response: GetterResponse, isVue: boolean, queryParams?: GetterQueryParam) => string;
-declare const generateMutatorConfig: ({
+}
+declare function generateOptions({
   route,
   body,
   headers,
   queryParams,
   response,
   verb,
+  requestOptions,
   isFormData,
   isFormUrlEncoded,
-  hasSignal,
+  isAngular,
   isExactOptionalPropertyTypes,
-  isVue
-}: {
+  hasSignal,
+  isVue,
+  paramsSerializer,
+  paramsSerializerOptions
+}: GenerateOptionsOptions): string;
+declare function generateBodyMutatorConfig(body: GetterBody, isFormData: boolean, isFormUrlEncoded: boolean): string;
+declare function generateQueryParamsAxiosConfig(response: GetterResponse, isVue: boolean, queryParams?: GetterQueryParam): string;
+interface GenerateMutatorConfigOptions {
   route: string;
   body: GetterBody;
   headers?: GetterQueryParam;
@@ -1170,24 +1169,31 @@ declare const generateMutatorConfig: ({
   hasSignal: boolean;
   isExactOptionalPropertyTypes: boolean;
   isVue?: boolean;
-}) => string;
-declare const generateMutatorRequestOptions: (requestOptions: boolean | object | undefined, hasSecondArgument: boolean) => string;
-declare const generateFormDataAndUrlEncodedFunction: ({
+}
+declare function generateMutatorConfig({
+  route,
+  body,
+  headers,
+  queryParams,
+  response,
+  verb,
+  isFormData,
+  isFormUrlEncoded,
+  hasSignal,
+  isExactOptionalPropertyTypes,
+  isVue
+}: GenerateMutatorConfigOptions): string;
+declare function generateMutatorRequestOptions(requestOptions: boolean | object | undefined, hasSecondArgument: boolean): string;
+declare function generateFormDataAndUrlEncodedFunction({
   body,
   formData,
   formUrlEncoded,
   isFormData,
   isFormUrlEncoded
-}: {
-  body: GetterBody;
-  formData?: GeneratorMutator;
-  formUrlEncoded?: GeneratorMutator;
-  isFormData: boolean;
-  isFormUrlEncoded: boolean;
-}) => string;
+}: GenerateFormDataAndUrlEncodedFunctionOptions): string;
 //#endregion
 //#region src/generators/parameter-definition.d.ts
-declare const generateParameterDefinition: (parameters: ComponentsObject["parameters"], context: ContextSpecs, suffix: string) => GeneratorSchema[];
+declare function generateParameterDefinition(parameters: OpenApiComponentsObject['parameters'], context: ContextSpec, suffix: string): GeneratorSchema[];
 //#endregion
 //#region src/generators/schema-definition.d.ts
 /**
@@ -1195,58 +1201,80 @@ declare const generateParameterDefinition: (parameters: ComponentsObject["parame
  *
  * @param schemas
  */
-declare const generateSchemasDefinition: (schemas: SchemasObject | undefined, context: ContextSpecs, suffix: string, filters?: InputFiltersOption) => GeneratorSchema[];
+declare function generateSchemasDefinition(schemas: OpenApiSchemasObject | undefined, context: ContextSpec, suffix: string, filters?: InputFiltersOptions): GeneratorSchema[];
 //#endregion
 //#region src/generators/verbs-options.d.ts
-declare const generateVerbsOptions: ({
-  verbs,
-  input,
+interface GenerateVerbOptionsParams {
+  verb: Verbs;
+  output: NormalizedOutputOptions;
+  operation: OpenApiOperationObject;
+  route: string;
+  pathRoute: string;
+  verbParameters?: OpenApiPathItemObject['parameters'];
+  components?: OpenApiComponentsObject;
+  context: ContextSpec;
+}
+declare function generateVerbOptions({
+  verb,
   output,
+  operation,
   route,
   pathRoute,
+  verbParameters,
   context
-}: {
-  verbs: PathItemObject;
+}: GenerateVerbOptionsParams): Promise<GeneratorVerbOptions>;
+interface GenerateVerbsOptionsParams {
+  verbs: OpenApiPathItemObject;
   input: NormalizedInputOptions;
   output: NormalizedOutputOptions;
   route: string;
   pathRoute: string;
-  context: ContextSpecs;
-}) => Promise<GeneratorVerbsOptions>;
-declare const _filteredVerbs: (verbs: PathItemObject, filters: NormalizedInputOptions["filters"]) => [string, any][];
+  context: ContextSpec;
+}
+declare function generateVerbsOptions({
+  verbs,
+  input,
+  output,
+  route,
+  pathRoute,
+  context
+}: GenerateVerbsOptionsParams): Promise<GeneratorVerbsOptions>;
+declare function _filteredVerbs(verbs: OpenApiPathItemObject, filters: NormalizedInputOptions['filters']): [string, any][];
 //#endregion
 //#region src/getters/array.d.ts
+interface GetArrayOptions {
+  schema: OpenApiSchemaObject;
+  name?: string;
+  context: ContextSpec;
+}
 /**
  * Return the output type from an array
  *
  * @param item item with type === "array"
  */
-declare const getArray: ({
+declare function getArray({
   schema,
   name,
   context
-}: {
-  schema: SchemaObject;
-  name?: string;
-  context: ContextSpecs;
-}) => ScalarValue;
+}: GetArrayOptions): ScalarValue;
 //#endregion
 //#region src/getters/body.d.ts
-declare const getBody: ({
+interface GetBodyOptions {
+  requestBody: OpenApiReferenceObject | OpenApiRequestBodyObject;
+  operationName: string;
+  context: ContextSpec;
+  contentType?: OverrideOutputContentType;
+}
+declare function getBody({
   requestBody,
   operationName,
   context,
   contentType
-}: {
-  requestBody: ReferenceObject | RequestBodyObject;
-  operationName: string;
-  context: ContextSpecs;
-  contentType?: OverrideOutputContentType;
-}) => GetterBody;
+}: GetBodyOptions): GetterBody;
 //#endregion
 //#region src/getters/combine.d.ts
 type Separator = 'allOf' | 'anyOf' | 'oneOf';
-declare const combineSchemas: ({
+declare function combineSchemas({
   name,
   schema,
   separator,
@@ -1254,53 +1282,55 @@ declare const combineSchemas: ({
   nullable
 }: {
   name?: string;
-  schema: SchemaObject;
+  schema: OpenApiSchemaObject;
   separator: Separator;
-  context: ContextSpecs;
+  context: ContextSpec;
   nullable: string;
-}) => ScalarValue;
+}): ScalarValue;
 //#endregion
 //#region src/getters/discriminators.d.ts
-declare const resolveDiscriminators: (schemas: SchemasObject, context: ContextSpecs) => SchemasObject;
+declare function resolveDiscriminators(schemas: OpenApiSchemasObject, context: ContextSpec): OpenApiSchemasObject;
 //#endregion
 //#region src/getters/enum.d.ts
-declare const getEnumNames: (schemaObject: SchemaObject | undefined) => any;
-declare const getEnumDescriptions: (schemaObject: SchemaObject | undefined) => any;
-declare const getEnum: (value: string, enumName: string, names: string[] | undefined, enumGenerationType: EnumGeneration, descriptions?: string[], enumNamingConvention?: NamingConvention) => string;
-declare const getEnumImplementation: (value: string, names?: string[], descriptions?: string[], enumNamingConvention?: NamingConvention) => string;
+declare function getEnumNames(schemaObject: OpenApiSchemaObject | undefined): any;
+declare function getEnumDescriptions(schemaObject: OpenApiSchemaObject | undefined): any;
+declare function getEnum(value: string, enumName: string, names: string[] | undefined, enumGenerationType: EnumGeneration, descriptions?: string[], enumNamingConvention?: NamingConvention): string;
+declare function getEnumImplementation(value: string, names?: string[], descriptions?: string[], enumNamingConvention?: NamingConvention): string;
 //#endregion
 //#region src/getters/keys.d.ts
-declare const getKey: (key: string) => string;
+declare function getKey(key: string): string;
 //#endregion
 //#region src/getters/object.d.ts
+interface GetObjectOptions {
+  item: OpenApiSchemaObject;
+  name?: string;
+  context: ContextSpec;
+  nullable: string;
+}
 /**
  * Return the output type from an object
  *
  * @param item item with type === "object"
  */
-declare const getObject: ({
+declare function getObject({
   item,
   name,
   context,
   nullable
-}: {
-  item: SchemaObject;
-  name?: string;
-  context: ContextSpecs;
-  nullable: string;
-}) => ScalarValue;
+}: GetObjectOptions): ScalarValue;
 //#endregion
 //#region src/getters/operation.d.ts
-declare const getOperationId: (operation: OperationObject, route: string, verb: Verbs) => string;
+declare function getOperationId(operation: OpenApiOperationObject, route: string, verb: Verbs): string;
 //#endregion
 //#region src/getters/parameters.d.ts
-declare const getParameters: ({
+interface GetParametersOptions {
+  parameters: (OpenApiReferenceObject | OpenApiParameterObject)[];
+  context: ContextSpec;
+}
+declare function getParameters({
   parameters,
   context
-}: {
-  parameters: (ReferenceObject | ParameterObject)[];
-  context: ContextSpecs;
-}) => GetterParameters;
+}: GetParametersOptions): GetterParameters;
 //#endregion
 //#region src/getters/params.d.ts
 /**
@@ -1313,50 +1343,53 @@ declare const getParameters: ({
  * ```
  * @param path
  */
-declare const getParamsInPath: (path: string) => string[];
-declare const getParams: ({
+declare function getParamsInPath(path: string): string[];
+interface GetParamsOptions {
+  route: string;
+  pathParams?: GetterParameters['query'];
+  operationId: string;
+  context: ContextSpec;
+  output: NormalizedOutputOptions;
+}
+declare function getParams({
   route,
   pathParams,
   operationId,
   context,
   output
-}: {
-  route: string;
-  pathParams?: GetterParameters["query"];
-  operationId: string;
-  context: ContextSpecs;
-  output: NormalizedOutputOptions;
-}) => GetterParams;
+}: GetParamsOptions): GetterParams;
 //#endregion
 //#region src/getters/props.d.ts
-declare const getProps: ({
+interface GetPropsOptions {
+  body: GetterBody;
+  queryParams?: GetterQueryParam;
+  params: GetterParams;
+  operationName: string;
+  headers?: GetterQueryParam;
+  context: ContextSpec;
+}
+declare function getProps({
   body,
   queryParams,
   params,
   operationName,
   headers,
   context
-}: {
-  body: GetterBody;
-  queryParams?: GetterQueryParam;
-  params: GetterParams;
-  operationName: string;
-  headers?: GetterQueryParam;
-  context: ContextSpecs;
-}) => GetterProps;
+}: GetPropsOptions): GetterProps;
 //#endregion
 //#region src/getters/query-params.d.ts
-declare const getQueryParams: ({
+interface GetQueryParamsOptions {
+  queryParams: GetterParameters['query'];
+  operationName: string;
+  context: ContextSpec;
+  suffix?: string;
+}
+declare function getQueryParams({
   queryParams,
   operationName,
   context,
   suffix
-}: {
-  queryParams: GetterParameters["query"];
-  operationName: string;
-  context: ContextSpecs;
-  suffix?: string;
-}) => GetterQueryParam | undefined;
+}: GetQueryParamsOptions): GetterQueryParam | undefined;
 //#endregion
 //#region src/getters/ref.d.ts
 type RefComponent = 'schemas' | 'responses' | 'parameters' | 'requestBodies';
@@ -1371,86 +1404,88 @@ interface RefInfo {
   name: string;
   originalName: string;
   refPaths?: string[];
-  specKey?: string;
 }
 /**
  * Return the output type from the $ref
  *
  * @param $ref
  */
-declare const getRefInfo: ($ref: ReferenceObject["$ref"], context: ContextSpecs) => RefInfo;
+declare function getRefInfo($ref: string, context: ContextSpec): RefInfo;
 //#endregion
 //#region src/getters/res-req-types.d.ts
-declare const getResReqTypes: (responsesOrRequests: [string, ResponseObject | ReferenceObject | RequestBodyObject][], name: string, context: ContextSpecs, defaultType?: string, uniqueKey?: (item: ResReqTypesValue, index: number, data: ResReqTypesValue[]) => unknown) => ResReqTypesValue[];
+declare function getResReqTypes(responsesOrRequests: [string, OpenApiReferenceObject | OpenApiResponseObject | OpenApiRequestBodyObject][], name: string, context: ContextSpec, defaultType?: string, uniqueKey?: (item: ResReqTypesValue, index: number, data: ResReqTypesValue[]) => unknown): ResReqTypesValue[];
 //#endregion
 //#region src/getters/response.d.ts
-declare const getResponse: ({
+interface GetResponseOptions {
+  responses: OpenApiResponsesObject;
+  operationName: string;
+  context: ContextSpec;
+  contentType?: OverrideOutputContentType;
+}
+declare function getResponse({
   responses,
   operationName,
   context,
   contentType
-}: {
-  responses: ResponsesObject;
-  operationName: string;
-  context: ContextSpecs;
-  contentType?: OverrideOutputContentType;
-}) => GetterResponse;
+}: GetResponseOptions): GetterResponse;
 //#endregion
 //#region src/getters/route.d.ts
-declare const getRoute: (route: string) => string;
-declare const getFullRoute: (route: string, servers: ServerObject[] | undefined, baseUrl: string | BaseUrlFromConstant | BaseUrlFromSpec | undefined) => string;
-declare const getRouteAsArray: (route: string) => string;
+declare function getRoute(route: string): string;
+declare function getFullRoute(route: string, servers: OpenApiServerObject[] | undefined, baseUrl: string | BaseUrlFromConstant | BaseUrlFromSpec | undefined): string;
+declare function getRouteAsArray(route: string): string;
 //#endregion
 //#region src/getters/scalar.d.ts
+interface GetScalarOptions {
+  item: OpenApiSchemaObject;
+  name?: string;
+  context: ContextSpec;
+}
 /**
  * Return the typescript equivalent of open-api data type
  *
  * @param item
- * @ref https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#data-types
+ * @ref https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#data-types
  */
-declare const getScalar: ({
+declare function getScalar({
   item,
   name,
   context
-}: {
-  item: SchemaObject;
-  name?: string;
-  context: ContextSpecs;
-}) => ScalarValue;
+}: GetScalarOptions): ScalarValue;
 //#endregion
 //#region src/resolvers/object.d.ts
-declare const resolveObject: ({
+interface ResolveOptions {
+  schema: OpenApiSchemaObject | OpenApiReferenceObject;
+  propName?: string;
+  combined?: boolean;
+  context: ContextSpec;
+}
+declare function resolveObject({
   schema,
   propName,
   combined,
   context
-}: {
-  schema: SchemaObject | ReferenceObject;
-  propName?: string;
-  combined?: boolean;
-  context: ContextSpecs;
-}) => ResolverValue;
+}: ResolveOptions): ResolverValue;
 //#endregion
 //#region src/resolvers/ref.d.ts
-type ComponentObject = SchemaObject | ResponseObject | ParameterObject | RequestBodyObject | ReferenceObject;
-declare const resolveRef: <Schema extends ComponentObject = ComponentObject>(schema: ComponentObject, context: ContextSpecs, imports?: GeneratorImport[]) => {
-  schema: Schema;
+declare function resolveRef<TSchema extends OpenApiComponentsObject = OpenApiComponentsObject>(schema: OpenApiComponentsObject, context: ContextSpec, imports?: GeneratorImport[]): {
+  schema: TSchema;
   imports: GeneratorImport[];
 };
-type Example = ExampleObject | ReferenceObject;
+type Example = OpenApiExampleObject | OpenApiReferenceObject;
 type Examples = Example[] | Record<string, Example> | undefined;
-declare const resolveExampleRefs: (examples: Examples, context: ContextSpecs) => Examples;
+declare function resolveExampleRefs(examples: Examples, context: ContextSpec): Examples;
 //#endregion
 //#region src/resolvers/value.d.ts
-declare const resolveValue: ({
+interface ResolveValueOptions {
+  schema: OpenApiSchemaObject | OpenApiReferenceObject;
+  name?: string;
+  context: ContextSpec;
+}
+declare function resolveValue({
   schema,
   name,
   context
-}: {
-  schema: SchemaObject | ReferenceObject;
-  name?: string;
-  context: ContextSpecs;
-}) => ResolverValue;
+}: ResolveValueOptions): ResolverValue;
 //#endregion
 //#region src/utils/assertion.d.ts
 /**
@@ -1458,8 +1493,8 @@ declare const resolveValue: ({
  *
  * @param property
  */
-declare const isReference: (property: any) => property is ReferenceObject;
-declare const isDirectory: (path: string) => boolean;
+declare function isReference(obj: object): obj is OpenApiReferenceObject;
+declare function isDirectory(path: string): boolean;
 declare function isObject(x: any): x is Record<string, unknown>;
 declare function isModule(x: any): x is Record<string, unknown>;
 declare function isString(x: any): x is string;
@@ -1469,24 +1504,23 @@ declare function isBoolean(x: any): x is boolean;
 declare function isFunction(x: any): x is Function;
 declare function isUndefined(x: any): x is undefined;
 declare function isNull(x: any): x is null;
-declare function isSchema(x: any): x is SchemaObject;
-declare const isVerb: (verb: string) => verb is Verbs;
-declare const isRootKey$1: (specKey: string, target: string) => boolean;
-declare const isUrl: (str: string) => boolean;
+declare function isSchema(x: unknown): x is OpenApiSchemaObject;
+declare function isVerb(verb: string): verb is Verbs;
+declare function isUrl(str: string): boolean;
 //#endregion
 //#region src/utils/async-reduce.d.ts
 declare function asyncReduce<IterationItem, AccValue>(array: IterationItem[], reducer: (accumulate: AccValue, current: IterationItem) => AccValue | Promise<AccValue>, initValue: AccValue): Promise<AccValue>;
 //#endregion
 //#region src/utils/case.d.ts
-declare const pascal: (s: string) => string;
-declare const camel: (s: string) => string;
-declare const snake: (s: string) => string;
-declare const kebab: (s: string) => string;
-declare const upper: (s: string, fillWith: string, isDeapostrophe?: boolean) => string;
-declare const conventionName: (name: string, convention: NamingConvention) => string;
+declare function pascal(s: string): string;
+declare function camel(s: string): string;
+declare function snake(s: string): string;
+declare function kebab(s: string): string;
+declare function upper(s: string, fillWith: string, isDeapostrophe?: boolean): string;
+declare function conventionName(name: string, convention: NamingConvention): string;
 //#endregion
 //#region src/utils/compare-version.d.ts
-declare const compareVersions: (firstVersion: string, secondVersions: string, operator?: CompareOperator) => boolean;
+declare function compareVersions(firstVersion: string, secondVersions: string, operator?: CompareOperator): boolean;
 //#endregion
 //#region src/utils/debug.d.ts
 interface DebuggerOptions {
@@ -1506,32 +1540,32 @@ declare function jsDoc(schema: {
   maxLength?: number;
   minimum?: number;
   maximum?: number;
-  exclusiveMinimum?: boolean;
-  exclusiveMaximum?: boolean;
+  exclusiveMinimum?: number;
+  exclusiveMaximum?: number;
   minItems?: number;
   maxItems?: number;
-  nullable?: boolean;
+  type?: string | string[];
   pattern?: string;
-}, tryOneLine?: boolean, context?: ContextSpecs): string;
+}, tryOneLine?: boolean, context?: ContextSpec): string;
 declare function keyValuePairsToJsDoc(keyValues: {
   key: string;
   value: string;
 }[]): string;
 //#endregion
 //#region src/utils/dynamic-import.d.ts
-declare const dynamicImport: <T>(toImport: T | string, from?: string, takeDefault?: boolean) => Promise<T>;
+declare function dynamicImport<T>(toImport: T | string, from?: string, takeDefault?: boolean): Promise<T>;
 //#endregion
 //#region src/utils/extension.d.ts
-declare const getExtension: (path: string) => "yaml" | "json";
+declare function getExtension(path: string): "yaml" | "json";
 //#endregion
 //#region src/utils/file.d.ts
-declare const getFileInfo: (target?: string, {
+declare function getFileInfo(target?: string, {
   backupFilename,
   extension
 }?: {
   backupFilename?: string;
   extension?: string;
-}) => {
+}): {
   path: string;
   pathWithoutExtension: string;
   extension: string;
@@ -1542,7 +1576,7 @@ declare const getFileInfo: (target?: string, {
 declare function removeFilesAndEmptyFolders(patterns: string[], dir: string): Promise<void>;
 //#endregion
 //#region src/utils/file-extensions.d.ts
-declare const getMockFileExtensionByTypeName: (mock: GlobalMockOptions | ClientMockBuilder) => string;
+declare function getMockFileExtensionByTypeName(mock: GlobalMockOptions | ClientMockBuilder): string;
 //#endregion
 //#region src/utils/get-property-safe.d.ts
 /**
@@ -1563,11 +1597,11 @@ declare function getPropertySafe<T extends object, K$1 extends keyof T>(obj: T,
 };
 //#endregion
 //#region src/utils/is-body-verb.d.ts
-declare const getIsBodyVerb: (verb: Verbs) => boolean;
+declare function getIsBodyVerb(verb: Verbs): boolean;
 //#endregion
 //#region src/utils/logger.d.ts
 declare const log: (message?: any, ...optionalParams: any[]) => void;
-declare const startMessage: ({
+declare function startMessage({
   name,
   version,
   description
@@ -1575,18 +1609,10 @@ declare const startMessage: ({
   name: string;
   version: string;
   description: string;
-}) => string;
-declare const logError: (err: unknown, tag?: string) => void;
-declare const mismatchArgsMessage: (mismatchArgs: string[]) => void;
-declare const createSuccessMessage: (backend?: string) => void;
-declare const ibmOpenapiValidatorWarnings: (warnings: {
-  path: string[];
-  message: string;
-}[]) => void;
-declare const ibmOpenapiValidatorErrors: (errors: {
-  path: string[];
-  message: string;
-}[]) => void;
+}): string;
+declare function logError(err: unknown, tag?: string): void;
+declare function mismatchArgsMessage(mismatchArgs: string[]): void;
+declare function createSuccessMessage(backend?: string): void;
 type LogType = 'error' | 'warn' | 'info';
 type LogLevel = LogType | 'silent';
 interface Logger {
@@ -1612,23 +1638,19 @@ declare function createLogger(level?: LogLevel, options?: LoggerOptions): Logger
 declare function mergeDeep<T extends Record<string, any>, U$1 extends Record<string, any>>(source: T, target: U$1): T & U$1;
 //#endregion
 //#region src/utils/occurrence.d.ts
-declare const count: (str: string | undefined, key: string) => number;
-//#endregion
-//#region src/utils/open-api-converter.d.ts
-declare const openApiConverter: (schema: any, options: Partial<ConvertInputOptions> | undefined, specKey: string) => Promise<OpenAPIObject>;
+declare function count(str: string | undefined, key: string): number;
 declare namespace path_d_exports {
-  export { basename, dirname, extname, getSchemaFileName, getSpecName, isAbsolute, join, joinSafe, normalizeSafe, relativeSafe, resolve, separator$1 as separator };
+  export { basename, dirname, extname, getSchemaFileName, isAbsolute, join, joinSafe, normalizeSafe, relativeSafe, resolve, separator$1 as separator };
 }
 declare const join: (...paths: string[]) => string, resolve: (...paths: string[]) => string, extname: (path: string) => string, dirname: (path: string) => string, basename: (path: string, suffix?: string) => string, isAbsolute: (path: string) => boolean;
 /**
  * Behaves exactly like `path.relative(from, to)`, but keeps the first meaningful "./"
  */
-declare const relativeSafe: (from: string, to: string) => string;
-declare const getSpecName: (specKey: string, target: string) => string;
-declare const getSchemaFileName: (path: string) => string;
+declare function relativeSafe(from: string, to: string): string;
+declare function getSchemaFileName(path: string): string;
 declare const separator$1 = "/";
-declare const normalizeSafe: (value: string) => string;
-declare const joinSafe: (...values: string[]) => string;
+declare function normalizeSafe(value: string): string;
+declare function joinSafe(...values: string[]): string;
 //#endregion
 //#region src/utils/sort.d.ts
 declare const sortByPriority: <T>(arr: (T & {
@@ -1640,8 +1662,8 @@ declare const sortByPriority: <T>(arr: (T & {
 })[];
 //#endregion
 //#region src/utils/string.d.ts
-declare const stringify: (data?: string | any[] | Record<string, any>) => string | undefined;
-declare const sanitize: (value: string, options?: {
+declare function stringify(data?: string | any[] | Record<string, any>): string | undefined;
+declare function sanitize(value: string, options?: {
   whitespace?: string | true;
   underscore?: string | true;
   dot?: string | true;
@@ -1649,10 +1671,10 @@ declare const sanitize: (value: string, options?: {
   es5keyword?: boolean;
   es5IdentifierName?: boolean;
   special?: boolean;
-}) => string;
-declare const toObjectString: <T>(props: T[], path?: keyof T) => string;
-declare const getNumberWord: (num: number) => string;
-declare const escape: (str: string | null, char?: string) => string | undefined;
+}): string;
+declare function toObjectString<T>(props: T[], path?: keyof T): string;
+declare function getNumberWord(num: number): string;
+declare function escape(str: string | null, char?: string): string | undefined;
 /**
  * Escape all characters not included in SingleStringCharacters and
  * DoubleStringCharacters on
@@ -1662,112 +1684,94 @@ declare const escape: (str: string | null, char?: string) => string | undefined;
  *
  * @param input String to escape
  */
-declare const jsStringEscape: (input: string) => string;
+declare function jsStringEscape(input: string): string;
 //#endregion
 //#region src/utils/tsconfig.d.ts
-declare const isSyntheticDefaultImportsAllow: (config?: Tsconfig) => boolean;
-//#endregion
-//#region src/utils/validator.d.ts
-/**
- * Validate the spec with ibm-openapi-validator (with a custom pretty logger).
- * More information: https://github.com/IBM/openapi-validator/#configuration
- * @param specs openAPI spec
- */
-declare const ibmOpenapiValidator: (specs: OpenAPIObject, validation: boolean | object) => Promise<void>;
+declare function isSyntheticDefaultImportsAllow(config?: Tsconfig): boolean;
 //#endregion
 //#region src/writers/schemas.d.ts
-declare const writeModelInline: (acc: string, model: string) => string;
-declare const writeModelsInline: (array: GeneratorSchema[]) => string;
-declare const writeSchema: ({
+declare function writeModelInline(acc: string, model: string): string;
+declare function writeModelsInline(array: GeneratorSchema[]): string;
+interface WriteSchemaOptions {
+  path: string;
+  schema: GeneratorSchema;
+  target: string;
+  namingConvention: NamingConvention;
+  fileExtension: string;
+  header: string;
+}
+declare function writeSchema({
   path,
   schema,
   target,
   namingConvention,
   fileExtension,
-  specKey,
-  isRootKey,
-  specsName,
   header
-}: {
-  path: string;
-  schema: GeneratorSchema;
+}: WriteSchemaOptions): Promise<void>;
+interface WriteSchemasOptions {
+  schemaPath: string;
+  schemas: GeneratorSchema[];
   target: string;
   namingConvention: NamingConvention;
   fileExtension: string;
-  specKey: string;
-  isRootKey: boolean;
-  specsName: Record<string, string>;
   header: string;
-}) => Promise<void>;
-declare const writeSchemas: ({
+  indexFiles: boolean;
+}
+declare function writeSchemas({
   schemaPath,
   schemas,
   target,
   namingConvention,
   fileExtension,
-  specKey,
-  isRootKey,
-  specsName,
   header,
   indexFiles
-}: {
-  schemaPath: string;
-  schemas: GeneratorSchema[];
-  target: string;
-  namingConvention: NamingConvention;
-  fileExtension: string;
-  specKey: string;
-  isRootKey: boolean;
-  specsName: Record<string, string>;
-  header: string;
-  indexFiles: boolean;
-}) => Promise<void>;
+}: WriteSchemasOptions): Promise<void>;
 //#endregion
 //#region src/writers/single-mode.d.ts
-declare const writeSingleMode: ({
+declare function writeSingleMode({
   builder,
   output,
-  specsName,
+  projectName,
   header,
   needSchema
-}: WriteModeProps) => Promise<string[]>;
+}: WriteModeProps): Promise<string[]>;
 //#endregion
 //#region src/writers/split-mode.d.ts
-declare const writeSplitMode: ({
+declare function writeSplitMode({
   builder,
   output,
-  specsName,
+  projectName,
   header,
   needSchema
-}: WriteModeProps) => Promise<string[]>;
+}: WriteModeProps): Promise<string[]>;
 //#endregion
 //#region src/writers/split-tags-mode.d.ts
-declare const writeSplitTagsMode: ({
+declare function writeSplitTagsMode({
   builder,
   output,
-  specsName,
+  projectName,
   header,
   needSchema
-}: WriteModeProps) => Promise<string[]>;
+}: WriteModeProps): Promise<string[]>;
 //#endregion
 //#region src/writers/tags-mode.d.ts
-declare const writeTagsMode: ({
+declare function writeTagsMode({
   builder,
   output,
-  specsName,
+  projectName,
   header,
   needSchema
-}: WriteModeProps) => Promise<string[]>;
+}: WriteModeProps): Promise<string[]>;
 //#endregion
 //#region src/writers/target.d.ts
-declare const generateTarget: (builder: WriteSpecsBuilder, options: NormalizedOutputOptions) => GeneratorTarget;
+declare function generateTarget(builder: WriteSpecBuilder, options: NormalizedOutputOptions): GeneratorTarget;
 //#endregion
 //#region src/writers/target-tags.d.ts
-declare const generateTargetForTags: (builder: WriteSpecsBuilder, options: NormalizedOutputOptions) => Record<string, GeneratorTarget>;
+declare function generateTargetForTags(builder: WriteSpecBuilder, options: NormalizedOutputOptions): Record<string, GeneratorTarget>;
 //#endregion
 //#region src/writers/types.d.ts
-declare const getOrvalGeneratedTypes: () => string;
-declare const getTypedResponse: () => string;
+declare function getOrvalGeneratedTypes(): string;
+declare function getTypedResponse(): string;
 //#endregion
-export { AngularOptions, BODY_TYPE_NAME, BaseUrlFromConstant, BaseUrlFromSpec, ClientBuilder, ClientDependenciesBuilder, ClientExtraFilesBuilder, ClientFileBuilder, ClientFooterBuilder, ClientGeneratorsBuilder, ClientHeaderBuilder, ClientMockBuilder, ClientMockGeneratorBuilder, ClientMockGeneratorImplementation, ClientTitleBuilder, Config, ConfigExternal, ConfigFn, ContextSpecs, DeepNonNullable, EnumGeneration, ErrorWithTag, FetchOptions, FormDataArrayHandling, FormDataType, GenerateMockImports, GeneratorApiBuilder, GeneratorApiOperations, GeneratorApiResponse, GeneratorClient, GeneratorClientExtra, GeneratorClientFooter, GeneratorClientHeader, GeneratorClientImports, GeneratorClientTitle, GeneratorClients, GeneratorDependency, GeneratorImport, GeneratorMutator, GeneratorMutatorParsingInfo, GeneratorOperation, GeneratorOperations, GeneratorOptions, GeneratorSchema, GeneratorTarget, GeneratorTargetFull, GeneratorVerbOptions, GeneratorVerbsOptions, GetterBody, GetterParam, GetterParameters, GetterParams, GetterProp, GetterPropType, GetterProps, GetterQueryParam, GetterResponse, GlobalMockOptions, GlobalOptions, HonoOptions, Hook, HookCommand, HookFunction, HookOption, HooksOptions, ImportOpenApi, InputFiltersOption, InputOptions, InputTransformerFn, JsDocOptions, LogLevel, LogLevels, LogOptions, LogType, Logger, LoggerOptions, MockData, MockDataArray, MockDataArrayFn, MockDataObject, MockDataObjectFn, MockOptions, MockProperties, MockPropertiesObject, MockPropertiesObjectFn, Mutator, MutatorObject, NamingConvention, NormalizedConfig, NormalizedFetchOptions, NormalizedFormDataType, NormalizedHonoOptions, NormalizedHookCommand, NormalizedHookOptions, NormalizedInputOptions, NormalizedJsDocOptions, NormalizedMutator, NormalizedOperationOptions, NormalizedOptions, NormalizedOutputOptions, NormalizedOverrideOutput, NormalizedParamsSerializerOptions, NormalizedQueryOptions, NormalizedZodOptions, OperationOptions, Options, OptionsExport, OptionsFn, OutputClient, OutputClientFunc, OutputDocsOptions, OutputHttpClient, OutputMockType, OutputMode, OutputOptions, OverrideInput, OverrideMockOptions, OverrideOutput, OverrideOutputContentType, PackageJson, ParamsSerializerOptions, PropertySortOrder, QueryOptions, RefComponentSuffix, RefInfo, ResReqTypesValue, ResolverValue, ScalarValue, SchemaType, SchemaWithConst, SwaggerParserOptions, SwrOptions, TEMPLATE_TAG_REGEX, TsConfigTarget, Tsconfig, URL_REGEX, VERBS_WITH_BODY, Verbs, WriteModeProps, WriteSpecsBuilder, ZodCoerceType, ZodDateTimeOptions, ZodOptions, ZodTimeOptions, _filteredVerbs, addDependency, asyncReduce, camel, combineSchemas, compareVersions, conventionName, count, createDebugger, createLogger, createSuccessMessage, dynamicImport, escape, generalJSTypes, generalJSTypesWithArray, generateAxiosOptions, generateBodyMutatorConfig, generateBodyOptions, generateComponentDefinition, generateDependencyImports, generateFormDataAndUrlEncodedFunction, generateImports, generateModelInline, generateModelsInline, generateMutator, generateMutatorConfig, generateMutatorImports, generateMutatorRequestOptions, generateOptions, generateParameterDefinition, generateQueryParamsAxiosConfig, generateSchemasDefinition, generateTarget, generateTargetForTags, generateVerbImports, generateVerbsOptions, getArray, getBody, getEnum, getEnumDescriptions, getEnumImplementation, getEnumNames, getExtension, getFileInfo, getFullRoute, getIsBodyVerb, getKey, getMockFileExtensionByTypeName, getNumberWord, getObject, getOperationId, getOrvalGeneratedTypes, getParameters, getParams, getParamsInPath, getPropertySafe, getProps, getQueryParams, getRefInfo, getResReqTypes, getResponse, getRoute, getRouteAsArray, getScalar, getTypedResponse, ibmOpenapiValidator, ibmOpenapiValidatorErrors, ibmOpenapiValidatorWarnings, isBoolean, isDirectory, isFunction, isModule, isNull, isNumber, isNumeric, isObject, isReference, isRootKey$1 as isRootKey, isSchema, isString, isSyntheticDefaultImportsAllow, isUndefined, isUrl, isVerb, jsDoc, jsStringEscape, kebab, keyValuePairsToJsDoc, log, logError, mergeDeep, mismatchArgsMessage, openApiConverter, pascal, removeFilesAndEmptyFolders, resolveDiscriminators, resolveExampleRefs, resolveObject, resolveRef, resolveValue, sanitize, snake, sortByPriority, startMessage, stringify, toObjectString, path_d_exports as upath, upper, writeModelInline, writeModelsInline, writeSchema, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };
+export { AngularOptions, BODY_TYPE_NAME, BaseUrlFromConstant, BaseUrlFromSpec, ClientBuilder, ClientDependenciesBuilder, ClientExtraFilesBuilder, ClientFileBuilder, ClientFooterBuilder, ClientGeneratorsBuilder, ClientHeaderBuilder, ClientMockBuilder, ClientMockGeneratorBuilder, ClientMockGeneratorImplementation, ClientTitleBuilder, Config, ConfigExternal, ConfigFn, ContextSpec, DeepNonNullable, EnumGeneration, ErrorWithTag, FetchOptions, FormDataArrayHandling, FormDataType, GenerateMockImports, GenerateVerbOptionsParams, GenerateVerbsOptionsParams, GeneratorApiBuilder, GeneratorApiOperations, GeneratorApiResponse, GeneratorClient, GeneratorClientExtra, GeneratorClientFooter, GeneratorClientHeader, GeneratorClientImports, GeneratorClientTitle, GeneratorClients, GeneratorDependency, GeneratorImport, GeneratorMutator, GeneratorMutatorParsingInfo, GeneratorOperation, GeneratorOperations, GeneratorOptions, GeneratorSchema, GeneratorTarget, GeneratorTargetFull, GeneratorVerbOptions, GeneratorVerbsOptions, GetterBody, GetterParam, GetterParameters, GetterParams, GetterProp, GetterPropType, GetterProps, GetterQueryParam, GetterResponse, GlobalMockOptions, GlobalOptions, HonoOptions, Hook, HookCommand, HookFunction, HookOption, HooksOptions, ImportOpenApi, InputFiltersOptions, InputOptions, InputTransformerFn, JsDocOptions, LogLevel, LogLevels, LogOptions, LogType, Logger, LoggerOptions, MockData, MockDataArray, MockDataArrayFn, MockDataObject, MockDataObjectFn, MockOptions, MockProperties, MockPropertiesObject, MockPropertiesObjectFn, Mutator, MutatorObject, NamingConvention, NormalizedConfig, NormalizedFetchOptions, NormalizedFormDataType, NormalizedHonoOptions, NormalizedHookCommand, NormalizedHookOptions, NormalizedInputOptions, NormalizedJsDocOptions, NormalizedMutator, NormalizedOperationOptions, NormalizedOptions, NormalizedOutputOptions, NormalizedOverrideOutput, NormalizedParamsSerializerOptions, NormalizedQueryOptions, NormalizedZodOptions, OpenApiComponentsObject, OpenApiDocument, OpenApiExampleObject, OpenApiInfoObject, OpenApiMediaTypeObject, OpenApiOperationObject, OpenApiParameterObject, OpenApiPathItemObject, OpenApiPathsObject, OpenApiReferenceObject, OpenApiRequestBodyObject, OpenApiResponseObject, OpenApiResponsesObject, OpenApiSchemaObject, OpenApiSchemaObjectType, OpenApiSchemasObject, OpenApiServerObject, OperationOptions, Options, OptionsExport, OptionsFn, OutputClient, OutputClientFunc, OutputDocsOptions, OutputHttpClient, OutputMockType, OutputMode, OutputOptions, OverrideInput, OverrideMockOptions, OverrideOutput, OverrideOutputContentType, PackageJson, ParamsSerializerOptions, PropertySortOrder, QueryOptions, RefComponentSuffix, RefInfo, ResReqTypesValue, ResolverValue, ScalarValue, SchemaType, SwrOptions, TEMPLATE_TAG_REGEX, TsConfigTarget, Tsconfig, URL_REGEX, VERBS_WITH_BODY, Verbs, WriteModeProps, WriteSpecBuilder, ZodCoerceType, ZodDateTimeOptions, ZodOptions, ZodTimeOptions, _filteredVerbs, addDependency, asyncReduce, camel, combineSchemas, compareVersions, conventionName, count, createDebugger, createLogger, createSuccessMessage, dynamicImport, escape, generalJSTypes, generalJSTypesWithArray, generateAxiosOptions, generateBodyMutatorConfig, generateBodyOptions, generateComponentDefinition, generateDependencyImports, generateFormDataAndUrlEncodedFunction, generateImports, generateModelInline, generateModelsInline, generateMutator, generateMutatorConfig, generateMutatorImports, generateMutatorRequestOptions, generateOptions, generateParameterDefinition, generateQueryParamsAxiosConfig, generateSchemasDefinition, generateTarget, generateTargetForTags, generateVerbImports, generateVerbOptions, generateVerbsOptions, getArray, getBody, getEnum, getEnumDescriptions, getEnumImplementation, getEnumNames, getExtension, getFileInfo, getFullRoute, getIsBodyVerb, getKey, getMockFileExtensionByTypeName, getNumberWord, getObject, getOperationId, getOrvalGeneratedTypes, getParameters, getParams, getParamsInPath, getPropertySafe, getProps, getQueryParams, getRefInfo, getResReqTypes, getResponse, getRoute, getRouteAsArray, getScalar, getTypedResponse, isBoolean, isDirectory, isFunction, isModule, isNull, isNumber, isNumeric, isObject, isReference, isSchema, isString, isSyntheticDefaultImportsAllow, isUndefined, isUrl, isVerb, jsDoc, jsStringEscape, kebab, keyValuePairsToJsDoc, log, logError, mergeDeep, mismatchArgsMessage, pascal, removeFilesAndEmptyFolders, resolveDiscriminators, resolveExampleRefs, resolveObject, resolveRef, resolveValue, sanitize, snake, sortByPriority, startMessage, stringify, toObjectString, path_d_exports as upath, upper, writeModelInline, writeModelsInline, writeSchema, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };
 //# sourceMappingURL=index.d.mts.map