Output

target

Type: String.

Valid values: path to the file containing the generated code.

1module.exports = {
2  petstore: {
3    output: {
4      target: 'src/petstore.ts',
5    },
6  },
7};

client

Type: String | Function.

Valid values: angular, axios, axios-functions, react-query, svelte-query, vue-query, swr, zod, fetch.

Default Value: axios-functions.

1module.exports = {
2  petstore: {
3    output: {
4      client: 'react-query',
5    },
6  },
7};

The valid values specify the default client generators provided by Orval. It is possible to provide a function to extend or create a custom client generator. The function should accept a GeneratorClients argument, and should return a ClientGeneratorsBuilder.

httpClient

Type: String.

Valid values: fetch, axios.

Default Value: axios.

1module.exports = {
2  petstore: {
3    output: {
4      client: 'swr',
5      httpClient: 'fetch',
6    },
7  },
8};

Specifying fetch as the httpClient option will use the Fetch API as the HTTP client instead of Axios. This property is only valid when swr, react-query, vue-query, and svelte-query are specified as the client option.

schemas

Type: String.

Valid values: path to the folder where the generated models are written.

Default Value: same as the target.

1module.exports = {
2  petstore: {
3    output: {
4      schemas: './api/model',
5    },
6  },
7};

fileExtension

Type: String.

Default Value: .ts.

Specify the file extension for files generated automatically. Modes such as tags, tags-split, and split do not alter schema files; they only pertain to client files.

1module.exports = {
2  petstore: {
3    output: {
4      mode: 'split',
5      target: './gen/endpoints',
6      schemas: './gen/model',
7      fileExtension: '.gen.ts',
8    },
9  },
10};

1src/gen/
2├── endpoints
3│   └── swaggerPetstore.gen.ts
4└── model
5    ├── listPetsParams.ts
6    └── pets.ts

namingConvention

Type: String.

Valid values: camelCase, PascalCase, snake_case, kebab-case.

Default Value: camelCase.

Specify the naming convention for the generated files.

If you're looking for property keys naming convention, see namingConvention.

1module.exports = {
2  petstore: {
3    output: {
4      namingConvention: 'PascalCase',
5      mode: 'split',
6      target: './gen/endpoints',
7      schemas: './gen/model',
8      fileExtension: '.gen.ts',
9    },
10  },
11};

1src/gen/
2├── endpoints
3│   └── SwaggerPetstore.gen.ts
4└── model
5    ├── ListPetsParams.ts
6    └── Pets.ts

workspace

Type: String.

Valid values: path to the folder which will contains all the generated files. This value will be use as a base for all the other paths used in the Orval config.

If this option is provided, an index.ts file will also be created with all the available exports

1module.exports = {
2  petstore: {
3    output: {
4      workspace: 'src/'
5      target: './petstore.ts',
6    },
7  },
8};

mode

Type: String.

Valid values: single, split, tags, tags-split.

Default Value: single.

1module.exports = {
2  petstore: {
3    output: {
4      mode: 'tags-split',
5    },
6  },
7};

Value: single

Generates everything into a single file.

For example:

1module.exports = {
2  petstore: {
3    output: {
4      target: 'src/petstore.ts',
5      mock: true,
6    },
7  },
8};

1my-app
2└── src
3    └── petstore.ts

Here a single file petstore will be created in the src-folder with the specification implementation.

Value: split

Splits implementation, schemas and mocks into different files

1module.exports = {
2  petstore: {
3    output: {
4      target: 'src/petstore.ts',
5      mock: true,
6      mode: 'split',
7    },
8  },
9};

1my-app
2└── src
3    ├── petstore.schemas.ts
4    ├── petstore.msw.ts
5    └── petstore.ts

Depending on the configuration, there will be multiple files created in src named petstore with a suffix to differentiate them.

petstore.schemas.ts
petstore.ts
petstore.msw.ts

For Angular:

petstore.ts is petstore.service.ts

Value: tags

Use this mode to generate one file per tag. A tag is equivalent to an OpenAPI specification tag. Given a pets tag for all pet calls, Orval will generate a file named pets.ts in the target folder

1module.exports = {
2  petstore: {
3    output: {
4      target: 'src/petstore.ts',
5      mock: true,
6      mode: 'tags',
7    },
8  },
9};

1my-app
2└── src
3    ├── pets.ts
4    └── petstore.schemas.ts

For Angular:

petstore.ts is petstore.service.ts

If the schemas property is not set, only one file per tag will be created, containing the model as well.

Value: tags-split

A combination of the tags and split mode. Orval will generate a folder for every tag in the target folder, and split the files into multiple files in those folders.

1module.exports = {
2  petstore: {
3    output: {
4      target: 'src/petstore.ts',
5      mock: true,
6      mode: 'tags-split',
7    },
8  },
9};

1my-app
2└── src
3    ├── petstore.schemas.ts
4    └── pets
5        ├── petstore.msw.ts
6        └── petstore.ts

Equivalent to the tags mode, if the schemas property is not set, only one file per tag will be created, containing the model as well.

indexFiles

Type: Boolean

Valid values: true or false

Default value: true

Specifies whether an index.ts file is generated during schemas generation.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      schemas: 'src/gen/model',
5      indexFiles: false,
6    },
7  },
8};

title

Type: String | Function.

Valid values: path or implementation of the function.

1module.exports = {
2  output: {
3    override: {
4      title: (title) => `${title}Api`,
5    },
6  },
7};

baseUrl

Type: String | Object.

Default Value: ''.

Allows you to set the baesUrl used for all API calls. This can either be a constant string or be configured to read from the servers field in the specification.

Example using constant:

1module.exports = {
2  petstore: {
3    output: {
4      baseUrl: 'https://api.example.com', // prepend https://api.example.com to all api calls
5    },
6  },
7};

getBaseUrlFromSpecification

Type: boolean

Valid values: true or false

Default value: true

When set to true, Orval reads the URL from the servers fields in the specification. If a path has defined a servers field, that URL will be used, otherwise the URL from the specification's root servers field will be used. If set to false, a constant baseUrl must be set.

Example:

1servers:
2  - url: https://api.example.com
3paths:
4  /pets:
5    servers:
6      - url: https://pets.example.com

1module.exports = {
2  petstore: {
3    output: {
4      baseUrl: {
5        getBaseUrlFromSpecification: true,
6        // prepend url defined in specification, in this example: 'https://api.example.com'
7        // for all calls, except for calls to /pets, which will instead use 'https://pets.example.com' as base url.
8      },
9    },
10  },
11};

variables

Type: Dictionary.

Only valid when getBaseUrlFromSpecification is true. Used to substitute variables in urls. If the variable in the specification is an enum, and the provided value in the configuration is not one of the allowed values, an error will occur when generating. If a variable that is substituted is not configured, the default value defined in the specification will be used.

Example:

1servers:
2  - url: https://{environment}.example.com/v1
3    variables:
4      environment:
5        default: api
6        enum:
7          - api
8          - api.dev
9          - api.staging

1module.exports = {
2  petstore: {
3    output: {
4      baseUrl: {
5        getBaseUrlFromSpecification: true,
6        variables: {
7          environment: 'api.dev',
8        },
9      },
10    },
11  },
12};

index

Type: Number.

Only valid when getBaseUrlFromSpecification is true. Since the servers field allows for multiple URL to be defined, this options specifies which index of the URL array to pick. If this is not defined, the first URL will be used. If the defined index is out of range of the array, the last URL in the array will be selected.

Example:

1servers:
2  - url: https://api.example.com/v1
3  - url: https://api.dev.example.com/v1

1module.exports = {
2  petstore: {
3    output: {
4      baseUrl: {
5        getBaseUrlFromSpecification: true,
6        index: 1,
7      },
8    },
9  },
10};

baseUrl

Type: String.

Only valid when getBaseUrlFromSpecification is false. Behaves the same way as setting the baseUrl as a string directly.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      baseUrl: {
5        getBaseUrlFromSpecification: false,
6        baseUrl: 'https://api.example.com', // The same as setting petstore.output.baseUrl: 'https://api.example.com'
7      },
8    },
9  },
10};

Gives the same result as:

1module.exports = {
2  petstore: {
3    output: {
4      baseUrl: 'https://api.example.com',
5    },
6  },
7};

mock

Type: Boolean | Object | Function.

Default Value: false.

If the value is set to true, Orval will generate mocks using Faker and MSW by default.

1module.exports = {
2  petstore: {
3    output: {
4      mock: true,
5    },
6  },
7};

The mock options also accepts a configuration object customizing the generation. If the property is set to true, the default options will be used. The default options are:

1module.exports = {
2  petstore: {
3    output: {
4      mock: {
5        type: 'msw',
6        delay: 1000,
7        useExamples: false,
8      },
9    },
10  },
11};

By providing a function, it is possible to extend or create a custom mock generator. See the expected type here.

type

Type: String.

Default Value: msw.

Valid values: msw, cypress (coming soon).

Specifies the type of mocks to be generate.

delay

Type: Number | Function | false.

Default Value: 1000.

Specifies the delay time for the mock. It can either be a fixed number, false or a function that returns a number. Setting delay to false removes the delay call completely.

delayFunctionLazyExecute

Type: boolean.

When set to true, functions that are passed to delay will be executed at runtime rather than when the mocks are generated.

useExamples

Type: Boolean.

When set to true, uses the example/examples fields from the OpenAPI specification as mock values.

generateEachHttpStatus

Type: Boolean.

When set to true, generates mocks for all the HTTP statuses in the responses fields in the OpenAPI specification. By default only the 200 OK response is generated.

baseUrl

Type: String.

Sets the base URL of the mock handlers.

locale

Type: String.

Default Value: en.

Sets the locale for the mock generation. It is used by Faker. See the list of available options here. It should also be strongly typed using defineConfig.

indexMockFiles

Type: Boolean

Default Value: false.

When true, adds an index.msw.ts file which exports arrays with all mock functions.

This is only valid when mode is tags-split.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      mode: 'tags-split',
5      mock: {
6        indexMockFiles: true,
7      },
8    },
9  },
10};

1// index.msw.ts
2export { getPetsMock } from './pets/pets.msw';
3export { getStoresMock } from './stores/stores.msw';
4// etc...

docs

Type: Boolean | Object.

Default Value: false.

Will generate API docs using TypeDoc. By default the docs will be in Markdown format.

TypeDoc can be configured by passing the options to the docs object or by creating a config file e.g. typedoc.config.mjs in the project root (see the config docs for a full list of supported file names) or by passing a config filename to the configPath option below.

See the TypeDoc configuration documentation for more details.

The docs option can take some properties to customize the generation if you set it to an object. If set to true, the default options will be used.

When no output directory destination is specified in config, the file will be output to the docs directory by default.

For example configuration, see this sample.

configPath

Type: String.

Specifies the TypeDoc config filename. This can be useful if your project already has a TypeDoc config for other docs.

clean

Type: Boolean | String[].

Default Value: false.

Can be used to clean generated files. Provide an array of glob to customize what is deleted.

This will clean all output target and schemas folders.

prettier

Type: Boolean.

Default Value: false.

Can be used to run prettier on the generated files. This requires prettier to be installed globally.

biome

Type: Boolean.

Default Value: false.

When set to true, will apply lint and format of biome to the generated file. The project must have @biomejs/biome in its dependencies.

The automatically generated source code does not comply with some lint rules included in the default ruleset for biome, so please control them in the the project's biome configuration file.

headers

Type: Boolean.

When set to true, enables the generation of the headers

tsconfig

Type: String | Tsconfig.

Should be automatically found. To use a different configuration, specify the path to the project's tsconfig or directly define the config in this property.

packageJson

Type: String.

Should be automatically found. Can be used to specify the path to your package.json.

override

Type: Object.

Allows overriding the output to specify mock generation or transforming the API implementation to your project's needs.

transformer

Type: String or Function.

Valid values: path or implementation of the transformer function.

This function is executed for each call when you generate and take in argument a GeneratorVerbOptions and should return a GeneratorVerbOptions

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        transformer: 'src/yourfunction.js',
6      },
7    },
8  },
9};

mutator

Type: String | Object.

Valid values: path of the mutator function or object with a path and name.

If an object is provided, it is also possible to add a default property to use the default exported function.

This function is executed for each call's execution. It takes all the options passed to the verb as an argument, and should return a Promise with the custom implementation or preferred HTTP client.

Possible arguments:

The first argument will be an object with the following type.

1// based on AxiosRequestConfig
2interface RequestConfig {
3  method: 'get' | 'put' | 'patch' | 'post' | 'delete';
4  url: string;
5  params?: any;
6  data?: any;
7  responseType?: string;
8}

The second argument is only provided for the Angular client and provides an instance of HttpClient

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mutator: {
6          path: './api/mutator/custom-instance.ts',
7          name: 'customInstance',
8          // default: true
9        },
10      },
11    },
12  },
13};

1// custom-instance.ts
2
3import Axios, { AxiosRequestConfig } from 'axios';
4
5export const AXIOS_INSTANCE = Axios.create({ baseURL: '' });
6
7export const customInstance = <T>(config: AxiosRequestConfig): Promise<T> => {
8  const source = Axios.CancelToken.source();
9  const promise = AXIOS_INSTANCE({ ...config, cancelToken: source.token }).then(
10    ({ data }) => data,
11  );
12
13  // @ts-ignore
14  promise.cancel = () => {
15    source.cancel('Query was cancelled by React Query');
16  };
17
18  return promise;
19};
20
21// In some case with react-query and swr you want to be able to override the return error type so you can also do it here like this
22export type ErrorType<Error> = AxiosError<Error>;

If the file has some alias you will also need to define them in the mutator object.

Example:

1// custom-instance.ts
2
3import Axios, { AxiosRequestConfig } from 'axios';
4import config from '@config';
5
6export const AXIOS_INSTANCE = Axios.create({ baseURL: '', ...config });
7
8export const customInstance = <T>(config: AxiosRequestConfig): Promise<T> => {
9  const source = Axios.CancelToken.source();
10  const promise = AXIOS_INSTANCE({ ...config, cancelToken: source.token }).then(
11    ({ data }) => data,
12  );
13
14  // @ts-ignore
15  promise.cancel = () => {
16    source.cancel('Query was cancelled by React Query');
17  };
18
19  return promise;
20};
21
22export type ErrorType<Error> = AxiosError<Error>;

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mutator: {
6          path: './api/mutator/custom-instance.ts',
7          name: 'customInstance',
8          alias: {
9            '@config': path.resolve(_dirname, './src/config'),
10          },
11        },
12      },
13    },
14  },
15};

When using the react-query, vue-query or svelte-query client, it is possible to provide a hook.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mutator: {
6          path: './api/mutator/use-custom-instance.ts',
7          name: 'useCustomInstance',
8          // default: true
9        },
10      },
11    },
12  },
13};

1// use-custom-instance.ts
2
3import Axios, { AxiosRequestConfig } from 'axios';
4import { useQueryClient } from 'react-query';
5
6export const AXIOS_INSTANCE = Axios.create({ baseURL: '' });
7
8export const useCustomInstance = <T>(): ((
9  config: AxiosRequestConfig,
10) => Promise<T>) => {
11  const token = useToken(); // Do what you want
12
13  return (config: AxiosRequestConfig) => {
14    const source = Axios.CancelToken.source();
15    const promise = AXIOS_INSTANCE({
16      ...config,
17      headers: {
18        Authorization: `Bearer ${token}`
19      }
20      cancelToken: source.token,
21    }).then(({ data }) => data);
22
23    // @ts-ignore
24    promise.cancel = () => {
25      source.cancel('Query was cancelled by React Query');
26    };
27
28    return promise;
29  };
30};
31
32export default useCustomInstance;
33
34export type ErrorType<Error> = AxiosError<Error>;

If you use ES modules ("type": "module"), you can also provide a hook like this

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mutator: {
6          path: './api/mutator/use-custom-instance.ts',
7          name: 'useCustomInstance',
8          extension: '.js',
9        },
10      },
11    },
12  },
13};

The generated file will import the mutator with a .js extension.

Type: Boolean | Function.

Default Value: true.

Use this property to disable the automatic generation of the file header.

You can provide a function to customize the file header is generated. The function should take an argument of type InfoObject, and should return a string[].

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        header: (info: InfoObject): string[] => [
6          `Generated by Orval 🍺`,
7          `Do not edit manually.`,
8          ...(info.title ? [info.title] : []),
9          ...(info.description ? [info.description] : []),
10          ...(info.version ? [`OpenAPI spec version: ${info.version}`] : []),
11        ],
12      },
13    },
14  },
15};

namingConvention (property keys)

Type: Object.

Change output naming convention generated for property keys.

By default, preserves keys naming convention as is.

If you're looking for file naming convention, see namingConvention.

1module.exports = {
2  petstore: {
3    output: {
4      ...
5      override: {
6        namingConvention: {
7          enum: 'PascalCase',
8        },
9      },
10    },
11    ...
12  },
13};

enum

Type: String.

Changes naming convention for enum keys. All generated enum types supported.

Valid values: : camelCase, PascalCase, snake_case, kebab-case. same as for file namingConvention.

fetch

Type: Object.

Options related to the generated Fetch client.

1module.exports = {
2  petstore: {
3    output: {
4      ...
5      override: {
6        fetch: {
7          includeHttpResponseReturnType: false,
8        },
9      },
10    },
11    ...
12  },
13};

includeHttpResponseReturnType

Type: Boolean. Default: true

When using fetch for client or httpClient, the Fetch response type includes HTTP status for easier processing by the application. To return a defined return type instead of an automatically generated return type, set this value to false.

explode

Type: Boolean. Default: true

By default, the Fetch client follows the OpenAPI specification for query parameter explode behavior. This means that query parameters will be exploded unless explicitly set to false in the OpenAPI schema.

To maintain backward compatibility with the previous behavior (where only parameters with explode: true are exploded), set this value to false.

jsonReviver

Type: String | Object

Accepts a reviver function passed to the parse function in the Fetch client. It is recommended to use this to revive dates when setting useDates to true

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        fetch: {
6          jsonReviver: {
7            path: './api/mutator/custom-reviver.ts',
8            name: 'customReviver',
9            // default: true
10          },
11        },
12      },
13    },
14  },
15};

1// custom-reviver.ts
2const isoDateFormat =
3  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d*)?(?:[-+]\d{2}:?\d{2}|Z)?$/;
4
5export function customReviver(key: string, value: unknown) {
6  if (value && typeof value === 'string' && isoDateFormat.test(value)) {
7    return new Date(value);
8  }
9  return value;
10}

query

Type: Object.

Overrides the generated query

1module.exports = {
2  petstore: {
3    output: {
4      ...
5      override: {
6        query: {
7          useQuery: true,
8          useInfinite: true,
9          useInfiniteQueryParam: 'nextId',
10          options: {
11            staleTime: 10000,
12          },
13          signal: true
14        },
15      },
16    },
17    ...
18  },
19};

useQuery

Type: Boolean.

Use to generate useQuery hooks. If the query key isn't provided that's the default hook generated.

useMutation

Type: Boolean.

Use to generate useMutation hooks. The hook will only be generated if the operation is not a GET operation, and not configured to generate a query.

The operations override will take precedence if both are configured.

useInfinite

Type: Boolean.

Use to generate useInfiniteQuery hooks.

usePrefetch

Type: Boolean.

Use to generate prefetching functions. This may be useful for NextJS SSR or similar prefetching use cases.

Example generated function:

1export const prefetchGetCategories = async <
2  TData = Awaited<ReturnType<typeof getCategories>>,
3  TError = ErrorType<unknown>,
4>(
5  queryClient: QueryClient,
6  options?: {
7    query?: UseQueryOptions<
8      Awaited<ReturnType<typeof getCategories>>,
9      TError,
10      TData,
11    >,
12    request?: SecondParameter<typeof customAxiosInstance>,
13  },
14): Promise<QueryClient> => {
15  const queryOptions = getGetCategoriesQueryOptions(options);
16
17  await queryClient.prefetchQuery(queryOptions);
18
19  return queryClient;
20};

useInfiniteQueryParam

Type: String.

Use to automatically add to the request the query param provided by the useInfiniteQuery when you use getFetchMore function.

options (deprecated use queryOptions instead)

Type: Object.

Use to override the query config. Check available options here

queryKey

Type: String | Object.

Valid values: path of the queryKey function or object with a path and name.

If an object is provided, it is also possible to add a default property to use the default exported function.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        query: {
6          queryKey: {
7            path: './api/query/custom-query-key.ts',
8            name: 'customQueryKeyFn',
9            // default: true
10          },
11        },
12      },
13    },
14  },
15};

queryOptions

Type: String | Object.

Valid values: path of the queryOptions function or object with a path and name.

If an object is provided, it is also possible to add a default property to use the default exported function.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        query: {
6          queryOptions: {
7            path: './api/query/custom-query-options.ts',
8            name: 'customQueryOptionsFn',
9            // default: true
10          },
11        },
12      },
13    },
14  },
15};

mutationOptions

Type: String | Object.

Valid values: path of the mutationOptions function or object with a path and name.

If an object is provided, it is also possible to add a default property to use the default exported function.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        query: {
6          mutationOptions: {
7            path: './api/mutator/custom-mutator-options.ts',
8            name: 'useCustomMutatorOptions',
9            // default: true
10          },
11        },
12      },
13    },
14  },
15};

1// custom-mutator-options.ts
2
3// custom-mutator-options.ts
4type OptionsWithMutationFn<
5  TData = unknown,
6  TError = Error,
7  TVariables = void,
8  TContext = unknown,
9> = UseMutationOptions<T, TError, TData, TContext> &
10  Required<Pick<UseMutationOptions<T, TError, TData, TContext>, 'mutationFn'>>;
11
12export const useCustomMutatorOptions = <
13  TData = unknown,
14  TError = Error,
15  TVariables = void,
16  TContext = unknown,
17>(
18  options: OptionsWithMutationFn<T, TError, TData, TContext>,
19): OptionsWithMutationFn<T, TError, TData, TContext> => {
20  const queryClient = useQueryClient();
21  if (options.mutationKey?.[0] === 'petDestroy') {
22    // Note: `options.mutationKey?.[0]` is untyped.
23    options.onSuccess = (_data, variables, _context) => {
24      // Note: `variables` is untyped.
25      options.onSuccess?.(data, variables, context);
26      // Note: `queryKey` is hardcoded, can't use `getGetPetQueryKey()` as it would introduce circular dependencies.
27      queryClient.invalidateQueries({
28        queryKey: ['api', 'v2', 'pet', variables.id],
29      });
30    };
31  }
32  // TODO: add more ifs for each mutation.
33  return options;
34};

signal

Type: Boolean.

Use to remove the generation of the abort signal provided by query

shouldExportMutatorHooks

Type: Boolean.

Default Value: true.

Use to stop the export of mutator hooks. Useful if you want to rely solely on useQuery, useSuspenseQuery, etc.

shouldExportQueryKey

Type: Boolean.

Default Value: true.

Use to stop the export of query keys.

shouldSplitQueryKey

Type: Boolean.

Default Value: false.

Use to make Orval generate query keys as arrays instead of strings.

version

Type: number.

Default Value: Detect from package json.

Use to specify a version for the generated hooks. This is useful if you want to force a version for the hooks.

angular

Type: Object.

Allows specifying options for the Angular client

1module.exports = {
2  petstore: {
3    output: {
4      ...
5      override: {
6        angular: {
7          provideIn: 'any',
8        },
9      },
10    },
11    ...
12  },
13};

provideIn

Type: Boolean | String.

Valid values: true, false, 'root', 'any', ''.

Default Value: 'root'.

Can be used to set the value of providedIn on the generated Angular services. If false, no providedIn will be set. If true or not specified, it will fall back to the default value: root.

swr

Type: Object.

Options for generating the swr client. It is also possible to extend the generated functions.

1module.exports = {
2  petstore: {
3    output: {
4      ...
5      override: {
6        swr: {
7          useInfinite: true,
8        },
9      },
10    },
11    ...
12  },
13};

useInfinite

Type: Boolean.

Use to generate a useSWRInfinite custom hook.

useSWRMutationForGet

Type: Boolean.

Use to generate a useSWRMutation custom hook for get request.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        swr: {
6          swrOptions: {
7            useSWRMutationForGet: true,
8          },
9        },
10      },
11    },
12  },
13};

swrOptions

Type: Object.

Use to override the useSwr options. See available options here

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        swr: {
6          swrOptions: {
7            dedupingInterval: 10000,
8          },
9        },
10      },
11    },
12  },
13};

swrMutationOptions

Type: Object.

Use to override the useSWRMutation options. See available options here

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        swr: {
6          swrMutationOptions: {
7            revalidate: true,
8          },
9        },
10      },
11    },
12  },
13};

swrInfiniteOptions

Type: Object.

Use to override the useSWRInfinite options. See available options here

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        swr: {
6          swrInfiniteOptions: {
7            initialSize: 10,
8          },
9        },
10      },
11    },
12  },
13};

zod

Type: Object.

Options for generating the Zod client

1module.exports = {
2  petstore: {
3    output: {
4      ...
5      override: {
6        zod: {
7          strict: {
8            response: true,
9            query: true,
10            param: true,
11            header: true,
12            body: true
13          },
14          coerce: {
15            response: true,
16              query: true,
17              param: true,
18              header: true,
19              body: true
20          },
21        },
22      },
23    },
24    ...
25  },
26};

strict

Type: Object.

Default Value: false.

Use to set the strict mode for the Zod schema. If set to true, the schema will be generated with strict mode.

generate

Type: Object.

Use to define the Zod schemas to be generated.

example:

1module.exports = {
2  petstore: {
3    output: {
4      ...
5      override: {
6        zod: {
7          generate: {
8            param: true,
9            body: true,
10            response: false,
11            query: true,
12            header: true,
13          }
14        },
15      },
16    },
17    ...
18  },
19};

In the above example, response body validations are not generated

coerce

Type: Object.

Use to configure coercion for the Zod schema. If set to true, the schema will be generated with the coerce on all possible types.

If an array of coerce types are provided, coercion is only generated for the specified types.

example:

1module.exports = {
2  petstore: {
3    output: {
4      ...
5      override: {
6        zod: {
7          coerce: {
8            response: [ 'boolean'],
9            query: ['string', 'number', 'boolean', 'bigint', 'date'],
10          }
11        },
12      },
13    },
14    ...
15  },
16};

preprocess

Type: Object.

Use to add a preprocess function to a Zod schema. Provide a custom mutator to preprocess the data before it is validated.

example:

1module.exports = {
2  petstore: {
3    output: {
4      ...
5      override: {
6        zod: {
7          preprocess: {
8            response: {
9              name: 'stripNill',
10              path: './src/mutators.ts',
11            },
12          },
13        },
14      },
15    },
16    ...
17  },
18};

generateEachHttpStatus

Type: Boolean.

Allows generating mocks for all the HTTP statuses in the responses fields of the provided OpenAPI specification. By default only the 200 OK response is generated.

1module.exports = {
2  petstore: {
3    output: {
4      ...
5      override: {
6        zod: {
7          generateEachHttpStatus: true,
8        },
9      },
10    },
11    ...
12  },
13};

dateTimeOptions

Type: Object.

Default Value: {}.

Use to set options for Zod datetime fields. These options are passed directly to zod datetime validation.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        zod: {
6          dateTimeOptions: {
7            local: true,
8            offset: true,
9            precision: 3,
10          },
11        },
12      },
13    },
14  },
15};

Read more about datetimes in the Zod documentation.

timeOptions

Type: Object.

Default Value: {}.

Use to set options for Zod time fields. These options are passed directly to Zod time validation.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        zod: {
6          timeOptions: {
7            precision: -1,
8          },
9        },
10      },
11    },
12  },
13};

Read more about times in the Zod documentation.

mock

Type: Object.

Allows overriding the generated mock.

properties

Type: Object | Function.

Use this to override the generated mock per property. Properties can either be a function that receives the specification as an argument and returns an object, or it can be a static object.

Each key of this object can be a regex or the path of the property to override. The value can either be a function returning a value, or a static value. If a function is provided, it will be executed at runtime.

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mock: {
6          properties: {
7            '/tag|name/': 'jon', // Matches every property named 'tag' or 'name', including nested ones
8            '/.*.user.id/': faker.string.uuid(), // Matches every property named 'id', inside an object named 'user', including nested ones
9            email: () => faker.internet.email(), // Matches only the property 'email'
10            'user.id': () => faker.string.uuid(), // Matches only the full path 'user.id'
11          },
12        },
13      },
14    },
15  },
16};

format

Type: Object.

Allows providing values for format in the OpenAPI specification. For example, if format: email is on a property in the OpenAPI specification, Orval will automatically generate a random email. See the default available format here.

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mock: {
6          format: {
7            email: () => faker.internet.email(),
8            iban: () => faker.finance.iban(),
9          },
10        },
11      },
12    },
13  },
14};

required

Type: Boolean.

Sets every property to be required.

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mock: {
6          required: true,
7        },
8      },
9    },
10  },
11};

delay

Type: Number | Function | false.

Sets the delay time for the mock. It can either be a fixed number, false or a function that returns a number. Setting delay to false removes the delay call completely.

Default Value: 1000

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mock: {
6          delay: 0,
7        },
8      },
9    },
10  },
11};

delayFunctionLazyExecute

Type: boolean.

When set to true, the function passed to delay will be executed at runtime rather than when the mocks are generated.

generateEachHttpStatus

Type: Boolean.

When set to true, Orval will generate mocks for all the HTTP statuses in the responses fields of the provided OpenAPI specification.

arrayMin

Type: Number.

Sets the default minimum length of generated arrays for properties that specify multiple items. Used if minItems is not defined for the property. (Default is 1)

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mock: {
6          arrayMin: 5,
7        },
8      },
9    },
10  },
11};

arrayMax

Type: Number.

Sets the default maximum length of generated arrays for properties that specify multiple items. Used if maxItems is not defined for the property. (Default is 10)

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mock: {
6          arrayMax: 15,
7        },
8      },
9    },
10  },
11};

stringMin

Type: Number.

Sets the default minimum length of generated strings. Used if minLength is not defined for the property. (Default is 10)

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mock: {
6          stringMin: 5,
7        },
8      },
9    },
10  },
11};

stringMax

Type: Number.

Sets the default maximum length of generated strings. Used if maxLength is not defined for the property. (Default is 20)

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mock: {
6          stringMax: 15,
7        },
8      },
9    },
10  },
11};

numberMin

Type: Number.

Sets the default minimum value of generated numbers. Used if minimum is not defined for the property.

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mock: {
6          numberMin: 5,
7        },
8      },
9    },
10  },
11};

numberMax

Type: Number.

Sets the default maximum value of generated numbers. Used if maximum is not defined for the property.

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mock: {
6          numberMax: 15,
7        },
8      },
9    },
10  },
11};

fractionDigits

Type: Number.

Sets number of decimals displayed in floating-point numbers. (Default is 2)

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mock: {
6          fractionDigits: 1,
7        },
8      },
9    },
10  },
11};

useExamples

An extension of the global mock option. If set to true, the mock generator will use the example property of the specification to generate the mock. If the example property is not set, the mock generator will fall back to the default behavior. Will override the global option.

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        mock: {
6          useExamples: true,
7        },
8      },
9    },
10  },
11};

baseUrl

Type: String.

Sets the base URL in the mock handlers. Will override the global option.

hono

Type: Object

Overrides the generated hono files

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        hono: {
6          handlers: 'src/handlers',
7          validatorOutputPath: 'src/validator.ts',
8          compositeRoute: 'src/routes.ts',
9        },
10      },
11    },
12  },
13};

handlers

Type: String.

Changes the output path for the hono handlers.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        hono: {
6          handlers: 'src/handlers',
7        },
8      },
9    },
10  },
11};

The files will be generated as below:

1src/
2├── handlers
3│   ├── createPets.ts
4│   ├── listPets.ts
5│   ├── showPetById.ts
6│   └── updatePets.ts
7├── index.ts
8├── mutators.ts
9├── petstore.context.ts
10├── petstore.schemas.ts
11├── petstore.ts
12├── petstore.validator.ts
13└── petstore.zod.ts

validatorOutputPath

Type: String.

Changes the validator output path

compositeRoute

Type: String.

When a string is provided, Orval will generate a single composite route file, containing all routes to the provided path.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        hono: {
6          compositeRoute: 'src/routes.ts',
7        },
8      },
9    },
10  },
11};

The files will be generated as below:

1src/
2├── endpoints
3│   ├── pets
4│   │   ├── pets.context.ts
5│   │   ├── pets.handlers.ts
6│   │   └── pets.zod.ts
7│   └── validator.ts
8├── routes.ts
9└── schemas
10    ├── pet.ts
11    └── pets.ts

components

Type: Object.

Allows overriding the generated model names by adding a suffix to each name.

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        components: {
6          schemas: {
7            suffix: 'DTO',
8          },
9          responses: {
10            suffix: 'Response',
11          },
12          parameters: {
13            suffix: 'Params',
14          },
15          requestBodies: {
16            suffix: 'Bodies',
17          },
18        },
19      },
20    },
21  },
22};

operations

Type: Object.

Allows overriding the generated mocks by operationId.

Each key of the operations object should be an operationId from the schema, and take as value an object.

The value object can take the same properties as the override property (mutator,query,transformer,mock).

The mock object allows an additional property; the data property. This property can take a function or the value directly. The function will be executed at runtime.

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        operations: {
6          listPets: {
7            transformer: 'src/yourfunction.js',
8            mutator: 'src/response-type.js',
9            mock: {
10              properties: () => {
11                return {
12                  id: () => faker.number.int({ min: 1, max: 99999 }),
13                };
14              },
15            },
16          },
17          showPetById: {
18            mock: {
19              data: () => ({
20                id: faker.number.int({ min: 1, max: 99 }),
21                name: faker.person.firstName(),
22                tag: faker.helpers.arrayElement([
23                  faker.word.sample(),
24                  undefined,
25                ]),
26              }),
27            },
28          },
29        },
30      },
31    },
32  },
33};

operationName

Type: Function.

Type signature:

(operation: OperationObject, route: string, verb: Verbs) => string;

Function to override the generated operation names.

requestOptions

Type: Object | Boolean.

Use this property to provide a config to the HTTP client or completely remove the request options property from the generated files.

formData

Type: Boolean | String | Object.

Valid values: path of the formData function or object with a path and name.

This allows defining how the names of form entries are handled regarding arrays.

Use this property to disable the auto generation of form data when using multipart

If an object is provided, it is also possible to add a default property to use the default exported function.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        formData: {
6          path: './api/mutator/custom-form-data-fn.ts',
7          name: 'customFormDataFn',
8          // default: true
9        },
10      },
11    },
12  },
13};

1// type signature
2export const customFormDataFn = <Body>(body: Body): FormData => {
3  // do your implementation to transform it to FormData
4
5  return FormData;
6};

mutator

Type: String | Object

Equivalent to providing the mutator directly to the formData property, while also allowing the use of the arrayHandling property.

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        formData: {
6          mutator: {
7            path: './api/mutator/custom-form-data-fn.ts',
8            name: 'customFormDataFn',
9          },
10        },
11      },
12    },
13  },
14};

arrayHandling

Type: serialize | serialize-with-brackets | explode

Default Value: serialize

Specifies how FormData generation handles arrays.

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        formData: {
6          mutator: {
7            path: './api/mutator/custom-form-data-fn.ts',
8            name: 'customFormDataFn',
9          },
10          arrayHandling: 'serialize-with-brackets',
11        },
12      },
13    },
14  },
15};

For all of the following examples, this specification is used:

1components:
2  schemas:
3    Pet:
4      type: object
5      properties:
6        name:
7          type: string
8        age:
9          type: number
10        relatives:
11          type: array
12          items:
13            type: object
14            properties:
15              name:
16                type: string
17              colors:
18                type: array
19                items:
20                  type: string
21                  enum:
22                    - white
23                    - black
24                    - green

Setting the value to serialize results in the following generated code:

1const formData = new FormData();
2if (pet.name !== undefined) {
3  formData.append(`name`, pet.name);
4}
5if (pet.age !== undefined) {
6  formData.append(`age`, pet.age.toString());
7}
8if (pet.relatives !== undefined) {
9  pet.relatives.forEach((value) =>
10    formData.append(`relatives`, JSON.stringify(value)),
11  );
12}

Setting the value to serialize-with-brackets results in the following generated code:

1const formData = new FormData();
2if (pet.name !== undefined) {
3  formData.append(`name`, pet.name);
4}
5if (pet.age !== undefined) {
6  formData.append(`age`, pet.age.toString());
7}
8if (pet.relatives !== undefined) {
9  pet.relatives.forEach((value) =>
10    formData.append(`relatives[]`, JSON.stringify(value)),
11  );
12}

Setting the value to explode results in the following generated code:

1const formData = new FormData();
2if (pet.name !== undefined) {
3  formData.append(`name`, pet.name);
4}
5if (pet.age !== undefined) {
6  formData.append(`age`, pet.age.toString());
7}
8if (pet.relatives !== undefined) {
9  pet.relatives.forEach((value, index) => {
10    if (value.name !== undefined) {
11      formData.append(`relatives[${index}].name`, value.name);
12    }
13    if (value.colors !== undefined) {
14      value.colors.forEach((value, index1) =>
15        formData.append(`relatives[${index}].colors[${index1}]`, value),
16      );
17    }
18  });
19}

formUrlEncoded

Type: Boolean | String | Object.

Valid values: path of the formUrlEncoded function or object with a path and name.

Use this property to disable the auto generation of form url encoded

If an object is provided, it is also possible to add a default property to use the default exported function.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        formUrlEncoded: {
6          path: './api/mutator/custom-form-url-encoded-fn.ts',
7          name: 'customFormUrlEncodedFn',
8          // default: true
9        },
10      },
11    },
12  },
13};

1// type signature
2export const customFormUrlEncodedFn = <Body>(body: Body): URLSearchParams => {
3  // do your implementation to transform it to FormData
4
5  return URLSearchParams;
6};

paramsSerializer

Type: String | Object.

IMPORTANT: This is only valid when using Axios or Angular.

Valid values: path of the paramsSerializer function or object with a path and name.

Use this property to add a custom parameter serializer to all requests that use query parameters.

If an object is provided, it is also possible to add a default property to use the default exported function.

If this is not specified, params are serialized as per Axios default.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        paramsSerializer: {
6          path: './api/mutator/custom-params-serializer-fn.ts',
7          name: 'customParamsSerializerFn',
8          // default: true
9        },
10      },
11    },
12  },
13};

1// type signature
2export const customParamsSerializerFn = (
3  params: Record<string, any>,
4): string => {
5  // do your implementation to transform the params
6
7  return params;
8};

paramsSerializerOptions

Type: Object

IMPORTANT: This is only valid when using Axios.

Use this property to specify how parameters are serialized. This is only taken into account when paramsSerializer is not defined. Currently, qs is the only available option. Read more about qs and its settings here.

If this is not specified, parameters are serialized as per Axios default.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        paramsSerializerOptions: {
6          qs: {
7            arrayFormat: 'repeat',
8          },
9        },
10      },
11    },
12  },
13};

useDates

Type: Boolean

Valid values: true or false. Defaults to false.

Use this property to convert OpenAPI date or datetime to JavaScript Date objects instead of string.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        useDates: true,
6      },
7    },
8  },
9};

Note: You must provide an Axios converter to convert the serialised date strings to Date objects. This option only affects the TypeScript definition. If using fetch as your client, you can provide a jsonReviver override function.

You can choose to use any Date library you want like Moment, Luxon, or native JS Dates.

1// type signature
2const client = axios.create({
3  baseURL: '',
4});
5
6client.interceptors.response.use((originalResponse) => {
7  handleDates(originalResponse.data);
8  return originalResponse;
9});
10
11export default client;
12
13const isoDateFormat =
14  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d*)?(?:[-+]\d{2}:?\d{2}|Z)?$/;
15
16function isIsoDateString(value: any): boolean {
17  return value && typeof value === 'string' && isoDateFormat.test(value);
18}
19
20export function handleDates(body: any) {
21  if (body === null || body === undefined || typeof body !== 'object')
22    return body;
23
24  for (const key of Object.keys(body)) {
25    const value = body[key];
26    if (isIsoDateString(value)) {
27      body[key] = new Date(value); // default JS conversion
28      // body[key] = parseISO(value); // date-fns conversion
29      // body[key] = luxon.DateTime.fromISO(value); // Luxon conversion
30      // body[key] = moment(value).toDate(); // Moment.js conversion
31    } else if (typeof value === 'object') {
32      handleDates(value);
33    }
34  }
35}

Note: If you are using fetch as your client and useDates is set to true, query parameters of type Date will be stringified using toISOString()

useBigInt

Type: Boolean

Valid values: true or false. Defaults to false.

Use this property to convert OpenAPI int64 and uint64 format to JavaScript BigInt objects instead of number.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        useBigInt: true,
6      },
7    },
8  },
9};

coerceTypes

Type: Boolean

Deprecated: Use zod.coerce instead.

Valid values: true or false. Defaults to false.

Use this property to enable type coercion for Zod schemas (only applies to query parameters schemas).

This is helpful if you want to use the zod schema to coerce (likely string-serialized) query parameters into the correct type before validation.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        coerceTypes: true,
6      },
7    },
8  },
9};

useNamedParameters

Type: Boolean.

Default Value: false.

Generates the operation interfaces with named path parameters instead of individual arguments for each path parameter.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        useNamedParameters: true,
6      },
7    },
8  },
9};

useTypeOverInterfaces

Type: Boolean

Valid values: true or false. Defaults to false.

Use this property to use TypeScript type instead of interface.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        useTypeOverInterfaces: true,
6      },
7    },
8  },
9};

useDeprecatedOperations

Type: Boolean

Valid values: true or false. Defaults to true.

Use this property to include/exclude generating any operation marked "deprecated": true in OpenAPI.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        useDeprecatedOperations: false,
6      },
7    },
8  },
9};

contentType

Type: Object

Use this property to include or exclude content types

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        contentType: {
6          include: ['application/json'],
7          exclude: ['application/xml'],
8        },
9      },
10    },
11  },
12};

useNativeEnums (deprecated, use 'enumGenerationType="enum"' instead)

Type: Boolean

Valid values: true or false. Defaults to false.

Use this property to generate native Typescript enum instead of a combined type and const.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        useNativeEnums: true,
6      },
7    },
8  },
9};

enumGenerationType

Type: const | enum | union

Default Value: const.

This is used to specify how enums are generated. const generates a const object, enum generates a native enum and union generates a simple union type. To change the name of the generated enum keys, you can extend your OpenAPI schema with x-enumNames. Read more here.

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        enumGenerationType: 'const',
6      },
7    },
8  },
9};

Result when enumGenerationType is const:

1export type Example = (typeof Example)[keyof typeof Example];
2
3// eslint-disable-next-line @typescript-eslint/no-redeclare
4export const Example = {
5  foo: 'foo',
6  bar: 'bar',
7  baz: 'baz',
8} as const;

Result when enumGenerationType is enum:

1export enum Example {
2  foo = 'foo',
3  bar = 'bar',
4  baz = 'baz',
5}

Result when enumGenerationType is union:

export const Example = 'foo' | 'bar' | 'baz';

suppressReadonlyModifier

Type: Boolean

Valid Values: true or false.

Default Value: false.

When the readonly field is specified in OpenAPI, specify readonly in the type and interface fields output from the schema.

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        suppressReadonlyModifier: true,
6      },
7    },
8  },
9};

jsDoc

filter

Type: Object.

A configuration object that allows you to customize JSDoc generation by optionally providing a filter function that transforms schema entries into key-value pairs.

Example:

1module.exports = {
2  petstore: {
3    output: {
4      override: {
5        jsDoc: {
6          filter: (schema) => {
7            const allowlist = [
8              'type',
9              'format',
10              'maxLength',
11              'minLength',
12              'description',
13              'minimum',
14              'maximum',
15              'exclusiveMinimum',
16              'exclusiveMaximum',
17              'pattern',
18              'nullable',
19              'enum',
20            ];
21            return Object.entries(schema || {})
22              .filter(([key]) => allowlist.includes(key))
23              .map(([key, value]) => {
24                return {
25                  key,
26                  value,
27                };
28              })
29              .sort((a, b) => {
30                return a.key.length - b.key.length;
31              });
32          },
33        },
34      },
35    },
36  },
37};

Input:

1components:
2  schemas:
3    Pet:
4      type: object
5      required:
6        - id
7        - name
8      oneOf:
9        - $ref: '#/components/schemas/Dog'
10        - $ref: '#/components/schemas/Cat'
11      properties:
12        '@id':
13          type: string
14          format: iri-reference
15        id:
16          type: integer
17          format: int64
18        name:
19          type: string
20        tag:
21          type: string
22        email:
23          type: string
24          format: email
25        callingCode:
26          type: string
27          enum: ['+33', '+420', '+33'] # intentional duplicated value
28        country:
29          type: string
30          enum: ["People's Republic of China", 'Uruguay']

Result:

1export interface Pet {
2  /**
3   * @type integer
4   * @format int64
5   */
6  id: number;
7  /**
8   * @type string
9   * @maxLength 0
10   * @minLength 40
11   * @description Name of pet
12   */
13  name: string;
14  /**
15   * @type integer
16   * @format int32
17   * @minimum 0
18   * @maximum 30
19   * @exclusiveMinimum true
20   * @exclusiveMaximum true
21   */
22  age?: number;
23  /**
24   * @type string
25   * @pattern ^\\d{3}-\\d{2}-\\d{4}$
26   * @nullable true
27   */
28  tag?: string | null;
29  /**
30   * @type string
31   * @format email
32   */
33  email?: string;
34  /**
35   * @type string
36   * @enum +33,+420,+33
37   */
38  callingCode?: PetCallingCode;
39  /**
40   * @type string
41   * @enum People's Republic of China,Uruguay
42   */
43  country?: PetCountry;
44}

allParamsOptional

Type: Boolean

Valid Values: true or false.

Default Value: false.

Applies to all clients, but is usually just relevant for Tanstack Query. Use this property to make all parameters optional except the path parameter. This is useful to take advantage of Orval's auto-enable feature for Tanstack Query, see https://github.com/orval-labs/orval/pull/894

1module.exports = {
2  petstore: {
3    output: {
4      allParamsOptional: true,
5    },
6  },
7};

urlEncodeParameters

Type: Boolean

Valid values: true or false. Defaults to false. Note: this only works for Tanstack Query clients and fetch httpClients for now.

Use this property to enable URL encoding of path/query parameters. This is highly recommended, and will probably become the default behaviour in the future, see https://github.com/orval-labs/orval/pull/895

1module.exports = {
2  petstore: {
3    output: {
4      urlEncodeParameters: true,
5    },
6  },
7};

optionsParamRequired

Type: Boolean

Valid Values: true or false.

Default Value: false. Use this property to make the second options parameter required (such as when using a custom Axios instance)

1module.exports = {
2  petstore: {
3    output: {
4      optionsParamRequired: true,
5    },
6  },
7};

propertySortOrder

Type: Alphabetical | Specification

Default Value: Specification

Specifies how properties in the models are sorted, either alphabetically or in the order they appear in the specification.

1module.exports = {
2  petstore: {
3    output: {
4      propertySortOrder: 'Alphabetical',
5    },
6  },
7};

Edit this page on GitHub

Was this page helpful?