@orval/core 6.19.1 → 6.21.0

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import SwaggerParser from '@apidevtools/swagger-parser';
 import * as openapi3_ts from 'openapi3-ts';
-import { InfoObject, OperationObject, OpenAPIObject, ResponsesObject, ReferenceObject, RequestBodyObject, ParameterObject, SchemaObject, ComponentsObject, SchemasObject, PathItemObject, ResponseObject } from 'openapi3-ts';
+import { InfoObject, OperationObject, OpenAPIObject, ResponsesObject, ReferenceObject, RequestBodyObject, ParameterObject, SchemaObject, ComponentsObject, SchemasObject, PathItemObject, ResponseObject, ExampleObject } from 'openapi3-ts';
 import swagger2openapi from 'swagger2openapi';
+import { allLocales } from '@faker-js/faker';
 import { CompareOperator } from 'compare-versions';
 import debug from 'debug';
 
@@ -10,14 +11,14 @@ interface Options {
     input?: string | InputOptions;
     hooks?: Partial<HooksOptions>;
 }
-declare type OptionsFn = () => Options | Promise<Options>;
-declare type OptionsExport = Options | Promise<Options> | OptionsFn;
-declare type Config = {
+type OptionsFn = () => Options | Promise<Options>;
+type OptionsExport = Options | Promise<Options> | OptionsFn;
+type Config = {
     [project: string]: OptionsExport;
 };
-declare type ConfigFn = () => Config | Promise<Config>;
-declare type ConfigExternal = Config | Promise<Config> | ConfigFn;
-declare type NormizaledConfig = {
+type ConfigFn = () => Config | Promise<Config>;
+type ConfigExternal = Config | Promise<Config> | ConfigFn;
+type NormalizedConfig = {
     [project: string]: NormalizedOptions;
 };
 interface NormalizedOptions {
@@ -25,12 +26,12 @@ interface NormalizedOptions {
     input: NormalizedInputOptions;
     hooks: NormalizedHookOptions;
 }
-declare type NormalizedOutputOptions = {
+type NormalizedOutputOptions = {
     workspace?: string;
     target?: string;
     schemas?: string;
     mode: OutputMode;
-    mock: boolean | ClientMSWBuilder;
+    mock?: GlobalMockOptions | ClientMockBuilder;
     override: NormalizedOverrideOutput;
     client: OutputClient | OutputClientFunc;
     clean: boolean | string[];
@@ -42,7 +43,10 @@ declare type NormalizedOutputOptions = {
     indexFiles: boolean;
     baseUrl?: string;
 };
-declare type NormalizedOverrideOutput = {
+type NormalizedParamsSerializerOptions = {
+    qs?: Record<string, any>;
+};
+type NormalizedOverrideOutput = {
     title?: (title: string) => string;
     transformer?: OutputTransformer;
     mutator?: NormalizedMutator;
@@ -52,21 +56,13 @@ declare type NormalizedOverrideOutput = {
     tags: {
         [key: string]: NormalizedOperationOptions;
     };
-    mock?: {
-        arrayMin?: number;
-        arrayMax?: number;
-        properties?: MockProperties;
-        format?: {
-            [key: string]: unknown;
-        };
-        required?: boolean;
-        baseUrl?: string;
-        delay?: number | (() => number);
-    };
+    mock?: OverrideMockOptions;
     contentType?: OverrideOutputContentType;
     header: false | ((info: InfoObject) => string[] | string);
     formData: boolean | NormalizedMutator;
     formUrlEncoded: boolean | NormalizedMutator;
+    paramsSerializer?: NormalizedMutator;
+    paramsSerializerOptions?: NormalizedParamsSerializerOptions;
     components: {
         schemas: {
             suffix: string;
@@ -89,18 +85,20 @@ declare type NormalizedOverrideOutput = {
     operationName?: (operation: OperationObject, route: string, verb: Verbs) => string;
     requestOptions: Record<string, any> | boolean;
     useDates?: boolean;
+    coerceTypes?: boolean;
     useTypeOverInterfaces?: boolean;
     useDeprecatedOperations?: boolean;
     useBigInt?: boolean;
     useNamedParameters?: boolean;
+    useNativeEnums?: boolean;
 };
-declare type NormalizedMutator = {
+type NormalizedMutator = {
     path: string;
     name?: string;
     default: boolean;
     alias?: Record<string, string>;
 };
-declare type NormalizedOperationOptions = {
+type NormalizedOperationOptions = {
     transformer?: OutputTransformer;
     mutator?: NormalizedMutator;
     mock?: {
@@ -116,9 +114,10 @@ declare type NormalizedOperationOptions = {
     operationName?: (operation: OperationObject, route: string, verb: Verbs) => string;
     formData?: boolean | NormalizedMutator;
     formUrlEncoded?: boolean | NormalizedMutator;
+    paramsSerializer?: NormalizedMutator;
     requestOptions?: object | boolean;
 };
-declare type NormalizedInputOptions = {
+type NormalizedInputOptions = {
     target: string | Record<string, unknown> | OpenAPIObject;
     validation: boolean;
     override: OverrideInput;
@@ -128,13 +127,13 @@ declare type NormalizedInputOptions = {
         tags?: (string | RegExp)[];
     };
 };
-declare type OutputClientFunc = (clients: GeneratorClients) => ClientGeneratorsBuilder;
-declare type OutputOptions = {
+type OutputClientFunc = (clients: GeneratorClients) => ClientGeneratorsBuilder;
+type OutputOptions = {
     workspace?: string;
     target?: string;
     schemas?: string;
     mode?: OutputMode;
-    mock?: boolean | ClientMSWBuilder;
+    mock?: boolean | GlobalMockOptions | ClientMockBuilder;
     override?: OverrideOutput;
     client?: OutputClient | OutputClientFunc;
     clean?: boolean | string[];
@@ -146,10 +145,10 @@ declare type OutputOptions = {
     indexFiles?: boolean;
     baseUrl?: string;
 };
-declare type SwaggerParserOptions = Omit<SwaggerParser.Options, 'validate'> & {
+type SwaggerParserOptions = Omit<SwaggerParser.Options, 'validate'> & {
     validate?: boolean;
 };
-declare type InputOptions = {
+type InputOptions = {
     target: string | Record<string, unknown> | OpenAPIObject;
     validation?: boolean;
     override?: OverrideInput;
@@ -159,50 +158,67 @@ declare type InputOptions = {
         tags?: string[];
     };
 };
-declare type OutputClient = 'axios' | 'axios-functions' | 'angular' | 'react-query' | 'svelte-query' | 'vue-query' | 'swr' | 'zod';
 declare const OutputClient: {
-    ANGULAR: OutputClient;
-    AXIOS: OutputClient;
-    AXIOS_FUNCTIONS: OutputClient;
-    REACT_QUERY: OutputClient;
-    SVELTE_QUERY: OutputClient;
-    VUE_QUERY: OutputClient;
+    readonly ANGULAR: "angular";
+    readonly AXIOS: "axios";
+    readonly AXIOS_FUNCTIONS: "axios-functions";
+    readonly REACT_QUERY: "react-query";
+    readonly SVELTE_QUERY: "svelte-query";
+    readonly VUE_QUERY: "vue-query";
 };
-declare type OutputMode = 'single' | 'split' | 'tags' | 'tags-split';
+type OutputClient = typeof OutputClient[keyof typeof OutputClient];
 declare const OutputMode: {
-    SINGLE: OutputMode;
-    SPLIT: OutputMode;
-    TAGS: OutputMode;
-    TAGS_SPLIT: OutputMode;
+    readonly SINGLE: "single";
+    readonly SPLIT: "split";
+    readonly TAGS: "tags";
+    readonly TAGS_SPLIT: "tags-split";
+};
+type OutputMode = typeof OutputMode[keyof typeof OutputMode];
+declare const OutputMockType: {
+    readonly MSW: "msw";
+};
+type OutputMockType = typeof OutputMockType[keyof typeof OutputMockType];
+type GlobalMockOptions = {
+    type: OutputMockType;
+    useExamples?: boolean;
+    delay?: number | (() => number);
+    baseUrl?: string;
+    locale?: keyof typeof allLocales;
 };
-declare type MockOptions = {
+type OverrideMockOptions = Partial<GlobalMockOptions> & {
     arrayMin?: number;
     arrayMax?: number;
     required?: boolean;
-    properties?: Record<string, string>;
+    properties?: MockProperties;
+    format?: Record<string, unknown>;
+};
+type MockOptions = Omit<OverrideMockOptions, 'properties'> & {
+    properties?: Record<string, unknown>;
     operations?: Record<string, {
-        properties: Record<string, string>;
+        properties: Record<string, unknown>;
     }>;
-    format?: Record<string, string>;
     tags?: Record<string, {
-        properties: Record<string, string>;
+        properties: Record<string, unknown>;
     }>;
 };
-declare type MockProperties = {
+type MockProperties = {
     [key: string]: unknown;
 } | ((specs: OpenAPIObject) => {
     [key: string]: unknown;
 });
-declare type OutputTransformerFn = (verb: GeneratorVerbOptions) => GeneratorVerbOptions;
-declare type OutputTransformer = string | OutputTransformerFn;
-declare type MutatorObject = {
+type OutputTransformerFn = (verb: GeneratorVerbOptions) => GeneratorVerbOptions;
+type OutputTransformer = string | OutputTransformerFn;
+type MutatorObject = {
     path: string;
     name?: string;
     default?: boolean;
     alias?: Record<string, string>;
 };
-declare type Mutator = string | MutatorObject;
-declare type OverrideOutput = {
+type Mutator = string | MutatorObject;
+type ParamsSerializerOptions = {
+    qs?: Record<string, any>;
+};
+type OverrideOutput = {
     title?: (title: string) => string;
     transformer?: OutputTransformer;
     mutator?: Mutator;
@@ -212,21 +228,13 @@ declare type OverrideOutput = {
     tags?: {
         [key: string]: OperationOptions;
     };
-    mock?: {
-        arrayMin?: number;
-        arrayMax?: number;
-        properties?: MockProperties;
-        format?: {
-            [key: string]: unknown;
-        };
-        required?: boolean;
-        baseUrl?: string;
-        delay?: number;
-    };
+    mock?: OverrideMockOptions;
     contentType?: OverrideOutputContentType;
     header?: boolean | ((info: InfoObject) => string[] | string);
     formData?: boolean | Mutator;
     formUrlEncoded?: boolean | Mutator;
+    paramsSerializer?: Mutator;
+    paramsSerializerOptions?: ParamsSerializerOptions;
     components?: {
         schemas?: {
             suffix?: string;
@@ -253,18 +261,20 @@ declare type OverrideOutput = {
     useDeprecatedOperations?: boolean;
     useBigInt?: boolean;
     useNamedParameters?: boolean;
+    useNativeEnums?: boolean;
 };
-declare type OverrideOutputContentType = {
+type OverrideOutputContentType = {
     include?: string[];
     exclude?: string[];
 };
-declare type NormalizedQueryOptions = {
+type NormalizedQueryOptions = {
     useQuery?: boolean;
     useSuspenseQuery?: boolean;
     useMutation?: boolean;
     useInfinite?: boolean;
     useSuspenseInfiniteQuery?: boolean;
     useInfiniteQueryParam?: string;
+    usePrefetch?: boolean;
     options?: any;
     queryKey?: NormalizedMutator;
     queryOptions?: NormalizedMutator;
@@ -272,13 +282,14 @@ declare type NormalizedQueryOptions = {
     signal?: boolean;
     version?: 3 | 4 | 5;
 };
-declare type QueryOptions = {
+type QueryOptions = {
     useQuery?: boolean;
     useSuspenseQuery?: boolean;
     useMutation?: boolean;
     useInfinite?: boolean;
     useSuspenseInfiniteQuery?: boolean;
     useInfiniteQueryParam?: string;
+    usePrefetch?: boolean;
     options?: any;
     queryKey?: Mutator;
     queryOptions?: Mutator;
@@ -286,15 +297,15 @@ declare type QueryOptions = {
     signal?: boolean;
     version?: 3 | 4 | 5;
 };
-declare type AngularOptions = {
+type AngularOptions = {
     provideIn?: 'root' | 'any' | boolean;
 };
-declare type InputTransformerFn = (spec: OpenAPIObject) => OpenAPIObject;
-declare type InputTransformer = string | InputTransformerFn;
-declare type OverrideInput = {
+type InputTransformerFn = (spec: OpenAPIObject) => OpenAPIObject;
+type InputTransformer = string | InputTransformerFn;
+type OverrideInput = {
     transformer?: InputTransformer;
 };
-declare type OperationOptions = {
+type OperationOptions = {
     transformer?: OutputTransformer;
     mutator?: Mutator;
     mock?: {
@@ -309,15 +320,16 @@ declare type OperationOptions = {
     operationName?: (operation: OperationObject, route: string, verb: Verbs) => string;
     formData?: boolean | Mutator;
     formUrlEncoded?: boolean | Mutator;
+    paramsSerializer?: Mutator;
     requestOptions?: object | boolean;
 };
-declare type Hook = 'afterAllFilesWrite';
-declare type HookFunction = (...args: any[]) => void | Promise<void>;
-declare type HookCommand = string | HookFunction | (string | HookFunction)[];
-declare type NormalizedHookCommand = HookCommand[];
-declare type HooksOptions<T = HookCommand | NormalizedHookCommand> = Partial<Record<Hook, T>>;
-declare type NormalizedHookOptions = HooksOptions<NormalizedHookCommand>;
-declare type Verbs = 'post' | 'put' | 'get' | 'patch' | 'delete' | 'head';
+type Hook = 'afterAllFilesWrite';
+type HookFunction = (...args: any[]) => void | Promise<void>;
+type HookCommand = string | HookFunction | (string | HookFunction)[];
+type NormalizedHookCommand = HookCommand[];
+type HooksOptions<T = HookCommand | NormalizedHookCommand> = Partial<Record<Hook, T>>;
+type NormalizedHookOptions = HooksOptions<NormalizedHookCommand>;
+type Verbs = 'post' | 'put' | 'get' | 'patch' | 'delete' | 'head';
 declare const Verbs: {
     POST: Verbs;
     PUT: Verbs;
@@ -326,7 +338,7 @@ declare const Verbs: {
     DELETE: Verbs;
     HEAD: Verbs;
 };
-declare type ImportOpenApi = {
+type ImportOpenApi = {
     data: Record<string, unknown | OpenAPIObject>;
     input: InputOptions;
     output: NormalizedOutputOptions;
@@ -350,7 +362,7 @@ interface GlobalOptions {
     clean?: boolean | string[];
     prettier?: boolean;
     tslint?: boolean;
-    mock?: boolean;
+    mock?: boolean | GlobalMockOptions;
     client?: OutputClient;
     mode?: OutputMode;
     tsconfig?: string | Tsconfig;
@@ -368,17 +380,17 @@ interface Tsconfig {
         target?: TsConfigTarget;
     };
 }
-declare type TsConfigTarget = 'es3' | 'es5' | 'es6' | 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'esnext';
+type TsConfigTarget = 'es3' | 'es5' | 'es6' | 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'esnext';
 interface PackageJson {
     dependencies?: Record<string, string>;
     devDependencies?: Record<string, string>;
 }
-declare type GeneratorSchema = {
+type GeneratorSchema = {
     name: string;
     model: string;
     imports: GeneratorImport[];
 };
-declare type GeneratorImport = {
+type GeneratorImport = {
     name: string;
     schemaName?: string;
     alias?: string;
@@ -387,59 +399,62 @@ declare type GeneratorImport = {
     values?: boolean;
     syntheticDefaultImport?: boolean;
 };
-declare type GeneratorDependency = {
+type GeneratorDependency = {
     exports: GeneratorImport[];
     dependency: string;
 };
-declare type GeneratorApiResponse = {
+type GeneratorApiResponse = {
     operations: GeneratorOperations;
     schemas: GeneratorSchema[];
 };
-declare type GeneratorOperations = {
+type GeneratorOperations = {
     [operationId: string]: GeneratorOperation;
 };
-declare type GeneratorTarget = {
+type GeneratorTarget = {
     imports: GeneratorImport[];
     implementation: string;
-    implementationMSW: string;
-    importsMSW: GeneratorImport[];
+    implementationMock: string;
+    importsMock: GeneratorImport[];
     mutators?: GeneratorMutator[];
     clientMutators?: GeneratorMutator[];
     formData?: GeneratorMutator[];
     formUrlEncoded?: GeneratorMutator[];
+    paramsSerializer?: GeneratorMutator[];
 };
-declare type GeneratorTargetFull = {
+type GeneratorTargetFull = {
     imports: GeneratorImport[];
     implementation: string;
-    implementationMSW: {
+    implementationMock: {
         function: string;
         handler: string;
     };
-    importsMSW: GeneratorImport[];
+    importsMock: GeneratorImport[];
     mutators?: GeneratorMutator[];
     clientMutators?: GeneratorMutator[];
     formData?: GeneratorMutator[];
     formUrlEncoded?: GeneratorMutator[];
+    paramsSerializer?: GeneratorMutator[];
 };
-declare type GeneratorOperation = {
+type GeneratorOperation = {
     imports: GeneratorImport[];
     implementation: string;
-    implementationMSW: {
+    implementationMock: {
         function: string;
         handler: string;
     };
-    importsMSW: GeneratorImport[];
+    importsMock: GeneratorImport[];
     tags: string[];
     mutator?: GeneratorMutator;
     clientMutators?: GeneratorMutator[];
     formData?: GeneratorMutator;
     formUrlEncoded?: GeneratorMutator;
+    paramsSerializer?: GeneratorMutator;
     operationName: string;
     types?: {
         result: (title?: string) => string;
     };
 };
-declare type GeneratorVerbOptions = {
+type GeneratorVerbOptions = {
     verb: Verbs;
     summary?: string;
     doc: string;
@@ -455,29 +470,30 @@ declare type GeneratorVerbOptions = {
     mutator?: GeneratorMutator;
     formData?: GeneratorMutator;
     formUrlEncoded?: GeneratorMutator;
+    paramsSerializer?: GeneratorMutator;
     override: NormalizedOverrideOutput;
     deprecated?: boolean;
     originalOperation: OperationObject;
 };
-declare type GeneratorVerbsOptions = GeneratorVerbOptions[];
-declare type GeneratorOptions = {
+type GeneratorVerbsOptions = GeneratorVerbOptions[];
+type GeneratorOptions = {
     route: string;
     pathRoute: string;
     override: NormalizedOverrideOutput;
     context: ContextSpecs;
-    mock: boolean;
+    mock?: GlobalMockOptions | ClientMockBuilder;
     output: string;
 };
-declare type GeneratorClient = {
+type GeneratorClient = {
     implementation: string;
     imports: GeneratorImport[];
     mutators?: GeneratorMutator[];
 };
-declare type GeneratorMutatorParsingInfo = {
+type GeneratorMutatorParsingInfo = {
     numberOfParams: number;
     returnNumberOfParams?: number;
 };
-declare type GeneratorMutator = {
+type GeneratorMutator = {
     name: string;
     path: string;
     default: boolean;
@@ -488,8 +504,8 @@ declare type GeneratorMutator = {
     isHook: boolean;
     bodyTypeName?: string;
 };
-declare type ClientBuilder = (verbOptions: GeneratorVerbOptions, options: GeneratorOptions, outputClient: OutputClient | OutputClientFunc) => GeneratorClient | Promise<GeneratorClient>;
-declare type ClientHeaderBuilder = (params: {
+type ClientBuilder = (verbOptions: GeneratorVerbOptions, options: GeneratorOptions, outputClient: OutputClient | OutputClientFunc) => GeneratorClient | Promise<GeneratorClient>;
+type ClientHeaderBuilder = (params: {
     title: string;
     isRequestOptions: boolean;
     isMutator: boolean;
@@ -498,16 +514,16 @@ declare type ClientHeaderBuilder = (params: {
     provideIn: boolean | 'root' | 'any';
     hasAwaitedType: boolean;
 }) => string;
-declare type ClientFooterBuilder = (params: {
+type ClientFooterBuilder = (params: {
     noFunction?: boolean | undefined;
     operationNames: string[];
     title?: string;
     hasAwaitedType: boolean;
     hasMutator: boolean;
 }) => string;
-declare type ClientTitleBuilder = (title: string) => string;
-declare type ClientDependenciesBuilder = (hasGlobalMutator: boolean, packageJson?: PackageJson) => GeneratorDependency[];
-declare type ClientMSWBuilder = (verbOptions: GeneratorVerbOptions, generatorOptions: GeneratorOptions) => {
+type ClientTitleBuilder = (title: string) => string;
+type ClientDependenciesBuilder = (hasGlobalMutator: boolean, hasParamsSerializerOptions: boolean, packageJson?: PackageJson) => GeneratorDependency[];
+type ClientMockBuilder = (verbOptions: GeneratorVerbOptions, generatorOptions: GeneratorOptions) => {
     imports: string[];
     implementation: string;
 };
@@ -518,8 +534,8 @@ interface ClientGeneratorsBuilder {
     footer?: ClientFooterBuilder;
     title?: ClientTitleBuilder;
 }
-declare type GeneratorClients = Record<OutputClient, ClientGeneratorsBuilder>;
-declare type GetterResponse = {
+type GeneratorClients = Record<OutputClient, ClientGeneratorsBuilder>;
+type GetterResponse = {
     imports: GeneratorImport[];
     definition: {
         success: string;
@@ -534,7 +550,7 @@ declare type GetterResponse = {
     schemas: GeneratorSchema[];
     originalSchema?: ResponsesObject;
 };
-declare type GetterBody = {
+type GetterBody = {
     originalSchema: ReferenceObject | RequestBodyObject;
     imports: GeneratorImport[];
     definition: string;
@@ -544,7 +560,7 @@ declare type GetterBody = {
     formUrlEncoded?: string;
     contentType: string;
 };
-declare type GetterParameters = {
+type GetterParameters = {
     query: {
         parameter: ParameterObject;
         imports: GeneratorImport[];
@@ -558,7 +574,7 @@ declare type GetterParameters = {
         imports: GeneratorImport[];
     }[];
 };
-declare type GetterParam = {
+type GetterParam = {
     name: string;
     definition: string;
     implementation: string;
@@ -566,14 +582,14 @@ declare type GetterParam = {
     required: boolean;
     imports: GeneratorImport[];
 };
-declare type GetterParams = GetterParam[];
-declare type GetterQueryParam = {
+type GetterParams = GetterParam[];
+type GetterQueryParam = {
     schema: GeneratorSchema;
     deps: GeneratorSchema[];
     isOptional: boolean;
     originalSchema?: SchemaObject;
 };
-declare type GetterPropType = 'param' | 'body' | 'queryParam' | 'header' | 'namedPathParams';
+type GetterPropType = 'param' | 'body' | 'queryParam' | 'header' | 'namedPathParams';
 declare const GetterPropType: {
     readonly PARAM: "param";
     readonly NAMED_PATH_PARAMS: "namedPathParams";
@@ -581,22 +597,22 @@ declare const GetterPropType: {
     readonly QUERY_PARAM: "queryParam";
     readonly HEADER: "header";
 };
-declare type GetterPropBase = {
+type GetterPropBase = {
     name: string;
     definition: string;
     implementation: string;
     default: boolean;
     required: boolean;
 };
-declare type GetterProp = GetterPropBase & ({
+type GetterProp = GetterPropBase & ({
     type: 'namedPathParams';
     destructured: string;
     schema: GeneratorSchema;
 } | {
     type: Exclude<GetterPropType, 'namedPathParams'>;
 });
-declare type GetterProps = GetterProp[];
-declare type SchemaType = 'integer' | 'number' | 'string' | 'boolean' | 'object' | 'null' | 'array' | 'enum' | 'unknown';
+type GetterProps = GetterProp[];
+type SchemaType = 'integer' | 'number' | 'string' | 'boolean' | 'object' | 'null' | 'array' | 'enum' | 'unknown';
 declare const SchemaType: {
     integer: string;
     number: string;
@@ -608,7 +624,7 @@ declare const SchemaType: {
     enum: string;
     unknown: string;
 };
-declare type ScalarValue = {
+type ScalarValue = {
     value: string;
     isEnum: boolean;
     hasReadonlyProps: boolean;
@@ -616,11 +632,13 @@ declare type ScalarValue = {
     imports: GeneratorImport[];
     schemas: GeneratorSchema[];
     isRef: boolean;
+    example?: any;
+    examples?: Record<string, any>;
 };
-declare type ResolverValue = ScalarValue & {
+type ResolverValue = ScalarValue & {
     originalSchema: SchemaObject;
 };
-declare type ResReqTypesValue = ScalarValue & {
+type ResReqTypesValue = ScalarValue & {
     formData?: string;
     formUrlEncoded?: string;
     isRef?: boolean;
@@ -629,7 +647,7 @@ declare type ResReqTypesValue = ScalarValue & {
     contentType: string;
     originalSchema?: SchemaObject;
 };
-declare type WriteSpecsBuilder = {
+type WriteSpecsBuilder = {
     operations: GeneratorOperations;
     schemas: Record<string, GeneratorSchema[]>;
     title: GeneratorClientTitle;
@@ -640,7 +658,7 @@ declare type WriteSpecsBuilder = {
     info: InfoObject;
     target: string;
 };
-declare type WriteModeProps = {
+type WriteModeProps = {
     builder: WriteSpecsBuilder;
     output: NormalizedOutputOptions;
     workspace: string;
@@ -648,20 +666,20 @@ declare type WriteModeProps = {
     header: string;
     needSchema: boolean;
 };
-declare type GeneratorApiOperations = {
+type GeneratorApiOperations = {
     operations: GeneratorOperations;
     schemas: GeneratorSchema[];
 };
-declare type GeneratorClientExtra = {
+type GeneratorClientExtra = {
     implementation: string;
-    implementationMSW: string;
+    implementationMock: string;
 };
-declare type GeneratorClientTitle = (data: {
+type GeneratorClientTitle = (data: {
     outputClient?: OutputClient | OutputClientFunc;
     title: string;
     customTitleFunc?: (title: string) => string;
 }) => GeneratorClientExtra;
-declare type GeneratorClientHeader = (data: {
+type GeneratorClientHeader = (data: {
     outputClient?: OutputClient | OutputClientFunc;
     isRequestOptions: boolean;
     isMutator: boolean;
@@ -670,14 +688,14 @@ declare type GeneratorClientHeader = (data: {
     hasAwaitedType: boolean;
     titles: GeneratorClientExtra;
 }) => GeneratorClientExtra;
-declare type GeneratorClientFooter = (data: {
+type GeneratorClientFooter = (data: {
     outputClient: OutputClient | OutputClientFunc;
     operationNames: string[];
     hasMutator: boolean;
     hasAwaitedType: boolean;
     titles: GeneratorClientExtra;
 }) => GeneratorClientExtra;
-declare type GeneratorClientImports = (data: {
+type GeneratorClientImports = (data: {
     client: OutputClient | OutputClientFunc;
     implementation: string;
     imports: {
@@ -688,9 +706,10 @@ declare type GeneratorClientImports = (data: {
     hasSchemaDir: boolean;
     isAllowSyntheticDefaultImports: boolean;
     hasGlobalMutator: boolean;
+    hasParamsSerializerOptions: boolean;
     packageJson?: PackageJson;
 }) => string;
-declare type GenerateMockImports = (data: {
+type GenerateMockImports = (data: {
     implementation: string;
     imports: {
         exports: GeneratorImport[];
@@ -699,8 +718,9 @@ declare type GenerateMockImports = (data: {
     specsName: Record<string, string>;
     hasSchemaDir: boolean;
     isAllowSyntheticDefaultImports: boolean;
+    options?: GlobalMockOptions;
 }) => string;
-declare type GeneratorApiBuilder = GeneratorApiOperations & {
+type GeneratorApiBuilder = GeneratorApiOperations & {
     title: GeneratorClientTitle;
     header: GeneratorClientHeader;
     footer: GeneratorClientFooter;
@@ -754,15 +774,17 @@ declare const generateMutator: ({ output, mutator, name, workspace, tsconfig, }:
 }) => Promise<GeneratorMutator | undefined>;
 
 declare const generateBodyOptions: (body: GetterBody, isFormData: boolean, isFormUrlEncoded: boolean) => string;
-declare const generateAxiosOptions: ({ response, isExactOptionalPropertyTypes, queryParams, headers, requestOptions, hasSignal, }: {
+declare const generateAxiosOptions: ({ response, isExactOptionalPropertyTypes, queryParams, headers, requestOptions, hasSignal, paramsSerializer, paramsSerializerOptions, }: {
     response: GetterResponse;
     isExactOptionalPropertyTypes: boolean;
     queryParams?: GeneratorSchema | undefined;
     headers?: GeneratorSchema | undefined;
     requestOptions?: boolean | object | undefined;
     hasSignal: boolean;
+    paramsSerializer?: GeneratorMutator | undefined;
+    paramsSerializerOptions?: ParamsSerializerOptions | undefined;
 }) => string;
-declare const generateOptions: ({ route, body, headers, queryParams, response, verb, requestOptions, isFormData, isFormUrlEncoded, isAngular, isExactOptionalPropertyTypes, hasSignal, }: {
+declare const generateOptions: ({ route, body, headers, queryParams, response, verb, requestOptions, isFormData, isFormUrlEncoded, isAngular, isExactOptionalPropertyTypes, hasSignal, paramsSerializer, paramsSerializerOptions, }: {
     route: string;
     body: GetterBody;
     headers?: GetterQueryParam | undefined;
@@ -775,6 +797,8 @@ declare const generateOptions: ({ route, body, headers, queryParams, response, v
     isAngular?: boolean | undefined;
     isExactOptionalPropertyTypes: boolean;
     hasSignal: boolean;
+    paramsSerializer?: GeneratorMutator | undefined;
+    paramsSerializerOptions?: ParamsSerializerOptions | undefined;
 }) => string;
 declare const generateBodyMutatorConfig: (body: GetterBody, isFormData: boolean, isFormUrlEncoded: boolean) => string;
 declare const generateQueryParamsAxiosConfig: (response: GetterResponse, queryParams?: GetterQueryParam) => string;
@@ -836,7 +860,7 @@ declare const getBody: ({ requestBody, operationName, context, contentType, }: {
     contentType?: OverrideOutputContentType | undefined;
 }) => GetterBody;
 
-declare type Separator = 'allOf' | 'anyOf' | 'oneOf';
+type Separator = 'allOf' | 'anyOf' | 'oneOf';
 declare const combineSchemas: ({ name, schema, separator, context, nullable, }: {
     name?: string | undefined;
     schema: SchemaObject;
@@ -847,7 +871,7 @@ declare const combineSchemas: ({ name, schema, separator, context, nullable, }:
 
 declare const resolveDiscriminators: (schemas: SchemasObject, context: ContextSpecs) => SchemasObject;
 
-declare const getEnum: (value: string, enumName: string, names?: string[]) => string;
+declare const getEnum: (value: string, enumName: string, names?: string[], useNativeEnums?: boolean) => string;
 declare const getEnumImplementation: (value: string, names?: string[]) => string;
 
 declare const getKey: (key: string) => string;
@@ -908,7 +932,7 @@ declare const getQueryParams: ({ queryParams, operationName, context, suffix, }:
     suffix?: string | undefined;
 }) => GetterQueryParam | undefined;
 
-declare type RefComponent = 'schemas' | 'responses' | 'parameters' | 'requestBodies';
+type RefComponent = 'schemas' | 'responses' | 'parameters' | 'requestBodies';
 declare const RefComponent: {
     schemas: RefComponent;
     responses: RefComponent;
@@ -963,11 +987,14 @@ declare const resolveObject: ({ schema, propName, combined, context, }: {
     context: ContextSpecs;
 }) => ResolverValue;
 
-declare type ComponentObject = SchemaObject | ResponseObject | ParameterObject | RequestBodyObject | ReferenceObject;
+type ComponentObject = SchemaObject | ResponseObject | ParameterObject | RequestBodyObject | ReferenceObject;
 declare const resolveRef: <Schema extends ComponentObject = ComponentObject>(schema: ComponentObject, context: ContextSpecs, imports?: GeneratorImport[]) => {
     schema: Schema;
     imports: GeneratorImport[];
 };
+type Example = ExampleObject | ReferenceObject;
+type Examples = Example[] | Record<string, Example> | undefined;
+declare const resolveExampleRefs: (examples: Examples, context: ContextSpecs) => Examples;
 
 declare const resolveValue: ({ schema, name, context, }: {
     schema: SchemaObject | ReferenceObject;
@@ -1041,8 +1068,8 @@ declare const ibmOpenapiValidatorErrors: (errors: {
     path: string;
     message: string;
 }[]) => void;
-declare type LogType = 'error' | 'warn' | 'info';
-declare type LogLevel = LogType | 'silent';
+type LogType = 'error' | 'warn' | 'info';
+type LogLevel = LogType | 'silent';
 interface Logger {
     info(msg: string, options?: LogOptions): void;
     warn(msg: string, options?: LogOptions): void;
@@ -1089,6 +1116,8 @@ declare function loadFile<File = any>(filePath?: string, options?: {
 }>;
 declare function removeFiles(patterns: string[], dir: string): Promise<void>;
 
+declare const getMockFileExtensionByTypeName: (mock: GlobalMockOptions | ClientMockBuilder) => string;
+
 declare function mergeDeep<T extends Record<string, any>>(source: T, target: T): T;
 
 declare const count: (str: string | undefined, key: string) => number;
@@ -1099,7 +1128,7 @@ declare let join: (...paths: string[]) => string;
 declare let resolve: (...paths: string[]) => string;
 declare let extname: (path: string) => string;
 declare let dirname: (path: string) => string;
-declare let basename: (path: string, ext?: string | undefined) => string;
+declare let basename: (path: string, suffix?: string | undefined) => string;
 declare let isAbsolute: (path: string) => boolean;
 
 /**
@@ -1112,33 +1141,20 @@ declare const separator = "/";
 declare const normalizeSafe: (value: string) => string;
 declare const joinSafe: (...values: string[]) => string;
 
-declare const path_join: typeof join;
-declare const path_resolve: typeof resolve;
-declare const path_extname: typeof extname;
-declare const path_dirname: typeof dirname;
 declare const path_basename: typeof basename;
+declare const path_dirname: typeof dirname;
+declare const path_extname: typeof extname;
+declare const path_getSchemaFileName: typeof getSchemaFileName;
+declare const path_getSpecName: typeof getSpecName;
 declare const path_isAbsolute: typeof isAbsolute;
+declare const path_join: typeof join;
+declare const path_joinSafe: typeof joinSafe;
+declare const path_normalizeSafe: typeof normalizeSafe;
 declare const path_relativeSafe: typeof relativeSafe;
-declare const path_getSpecName: typeof getSpecName;
-declare const path_getSchemaFileName: typeof getSchemaFileName;
+declare const path_resolve: typeof resolve;
 declare const path_separator: typeof separator;
-declare const path_normalizeSafe: typeof normalizeSafe;
-declare const path_joinSafe: typeof joinSafe;
 declare namespace path {
-  export {
-    path_join as join,
-    path_resolve as resolve,
-    path_extname as extname,
-    path_dirname as dirname,
-    path_basename as basename,
-    path_isAbsolute as isAbsolute,
-    path_relativeSafe as relativeSafe,
-    path_getSpecName as getSpecName,
-    path_getSchemaFileName as getSchemaFileName,
-    path_separator as separator,
-    path_normalizeSafe as normalizeSafe,
-    path_joinSafe as joinSafe,
-  };
+  export { path_basename as basename, path_dirname as dirname, path_extname as extname, path_getSchemaFileName as getSchemaFileName, path_getSpecName as getSpecName, path_isAbsolute as isAbsolute, path_join as join, path_joinSafe as joinSafe, path_normalizeSafe as normalizeSafe, path_relativeSafe as relativeSafe, path_resolve as resolve, path_separator as separator };
 }
 
 declare const sortByPriority: <T>(arr: (T & {
@@ -1220,4 +1236,4 @@ declare const generateTarget: (builder: WriteSpecsBuilder, options: NormalizedOu
 
 declare const generateTargetForTags: (builder: WriteSpecsBuilder, options: NormalizedOutputOptions) => Record<string, GeneratorTarget>;
 
-export { AngularOptions, BODY_TYPE_NAME, ClientBuilder, ClientDependenciesBuilder, ClientFooterBuilder, ClientGeneratorsBuilder, ClientHeaderBuilder, ClientMSWBuilder, ClientTitleBuilder, Config, ConfigExternal, ConfigFn, ContextSpecs, 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, GlobalOptions, Hook, HookCommand, HookFunction, HooksOptions, ImportOpenApi, InputOptions, InputTransformerFn, LogLevel, LogLevels, LogOptions, LogType, Logger, LoggerOptions, MockOptions, MockProperties, Mutator, MutatorObject, NormalizedHookCommand, NormalizedHookOptions, NormalizedInputOptions, NormalizedMutator, NormalizedOperationOptions, NormalizedOptions, NormalizedOutputOptions, NormalizedOverrideOutput, NormalizedQueryOptions, NormizaledConfig, OperationOptions, Options, OptionsExport, OptionsFn, OutputClient, OutputClientFunc, OutputMode, OutputOptions, OverrideInput, OverrideOutput, OverrideOutputContentType, PackageJson, QueryOptions, RefComponentSuffix, RefInfo, ResReqTypesValue, ResolverValue, ScalarValue, SchemaType, SwaggerParserOptions, TsConfigTarget, Tsconfig, URL_REGEX, VERBS_WITH_BODY, Verbs, WriteModeProps, WriteSpecsBuilder, _filteredVerbs, addDependency, asyncReduce, camel, combineSchemas, compareVersions, count, createDebugger, createLogger, createSuccessMessage, dynamicImport, errorMessage, 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, getEnumImplementation, getExtension, getFileInfo, getKey, getNumberWord, getObject, getOperationId, getOrvalGeneratedTypes, getParameters, getParams, getParamsInPath, getProps, getQueryParams, getRefInfo, getResReqTypes, getResponse, getRoute, getRouteAsArray, getScalar, ibmOpenapiValidator, ibmOpenapiValidatorErrors, ibmOpenapiValidatorWarnings, isBoolean, isDirectory, isFunction, isModule, isNull, isNumber, isNumeric, isObject, isReference, isRootKey, isSchema, isString, isSyntheticDefaultImportsAllow, isUndefined, isUrl, isVerb, jsDoc, jsStringEscape, kebab, loadFile, log, mergeDeep, mismatchArgsMessage, openApiConverter, pascal, removeFiles, resolveDiscriminators, resolveObject, resolveRef, resolveValue, sanitize, snake, sortByPriority, startMessage, stringify, toObjectString, path as upath, upper, writeModelInline, writeModelsInline, writeSchema, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };
+export { type AngularOptions, BODY_TYPE_NAME, type ClientBuilder, type ClientDependenciesBuilder, type ClientFooterBuilder, type ClientGeneratorsBuilder, type ClientHeaderBuilder, type ClientMockBuilder, type ClientTitleBuilder, type Config, type ConfigExternal, type ConfigFn, type ContextSpecs, type GenerateMockImports, type GeneratorApiBuilder, type GeneratorApiOperations, type GeneratorApiResponse, type GeneratorClient, type GeneratorClientExtra, type GeneratorClientFooter, type GeneratorClientHeader, type GeneratorClientImports, type GeneratorClientTitle, type GeneratorClients, type GeneratorDependency, type GeneratorImport, type GeneratorMutator, type GeneratorMutatorParsingInfo, type GeneratorOperation, type GeneratorOperations, type GeneratorOptions, type GeneratorSchema, type GeneratorTarget, type GeneratorTargetFull, type GeneratorVerbOptions, type GeneratorVerbsOptions, type GetterBody, type GetterParam, type GetterParameters, type GetterParams, type GetterProp, GetterPropType, type GetterProps, type GetterQueryParam, type GetterResponse, type GlobalMockOptions, type GlobalOptions, type Hook, type HookCommand, type HookFunction, type HooksOptions, type ImportOpenApi, type InputOptions, type InputTransformerFn, type LogLevel, LogLevels, type LogOptions, type LogType, type Logger, type LoggerOptions, type MockOptions, type MockProperties, type Mutator, type MutatorObject, type NormalizedConfig, type NormalizedHookCommand, type NormalizedHookOptions, type NormalizedInputOptions, type NormalizedMutator, type NormalizedOperationOptions, type NormalizedOptions, type NormalizedOutputOptions, type NormalizedOverrideOutput, type NormalizedParamsSerializerOptions, type NormalizedQueryOptions, type OperationOptions, type Options, type OptionsExport, type OptionsFn, OutputClient, type OutputClientFunc, OutputMockType, OutputMode, type OutputOptions, type OverrideInput, type OverrideMockOptions, type OverrideOutput, type OverrideOutputContentType, type PackageJson, type ParamsSerializerOptions, type QueryOptions, RefComponentSuffix, type RefInfo, type ResReqTypesValue, type ResolverValue, type ScalarValue, SchemaType, type SwaggerParserOptions, type TsConfigTarget, type Tsconfig, URL_REGEX, VERBS_WITH_BODY, Verbs, type WriteModeProps, type WriteSpecsBuilder, _filteredVerbs, addDependency, asyncReduce, camel, combineSchemas, compareVersions, count, createDebugger, createLogger, createSuccessMessage, dynamicImport, errorMessage, 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, getEnumImplementation, getExtension, getFileInfo, getKey, getMockFileExtensionByTypeName, getNumberWord, getObject, getOperationId, getOrvalGeneratedTypes, getParameters, getParams, getParamsInPath, getProps, getQueryParams, getRefInfo, getResReqTypes, getResponse, getRoute, getRouteAsArray, getScalar, ibmOpenapiValidator, ibmOpenapiValidatorErrors, ibmOpenapiValidatorWarnings, isBoolean, isDirectory, isFunction, isModule, isNull, isNumber, isNumeric, isObject, isReference, isRootKey, isSchema, isString, isSyntheticDefaultImportsAllow, isUndefined, isUrl, isVerb, jsDoc, jsStringEscape, kebab, loadFile, log, mergeDeep, mismatchArgsMessage, openApiConverter, pascal, removeFiles, resolveDiscriminators, resolveExampleRefs, resolveObject, resolveRef, resolveValue, sanitize, snake, sortByPriority, startMessage, stringify, toObjectString, path as upath, upper, writeModelInline, writeModelsInline, writeSchema, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };