@hey-api/openapi-ts 0.83.1 → 0.84.1

package/dist/index.d.ts

@@ -1,16 +1,30 @@
-import { C as Comments, P as PluginHandler, a as Plugin, I as ImportExportItemObject, t as tsNodeToString, S as StringCase, U as UserConfig, L as Logger, b as Client$6, c as IR } from './types.d-CRtO-Prt.js';
-export { j as Client, D as DefinePlugin, E as ExpressionTransformer, k as LegacyIR, O as OpenApi, d as OpenApiMetaObject, e as OpenApiOperationObject, f as OpenApiParameterObject, g as OpenApiRequestBodyObject, h as OpenApiResponseObject, i as OpenApiSchemaObject, T as TypeTransformer } from './types.d-CRtO-Prt.js';
+import * as typescript from 'typescript';
+import typescript__default from 'typescript';
+import { C as Comments, P as PluginHandler, a as Plugin, I as ImportExportItemObject, t as tsNodeToString, S as StringCase, U as UserConfig, L as Logger, b as Client$7, c as IR } from './types.d-DOXd97cA.js';
+export { j as Client, D as DefinePlugin, E as ExpressionTransformer, k as LegacyIR, O as OpenApi, d as OpenApiMetaObject, e as OpenApiOperationObject, f as OpenApiParameterObject, g as OpenApiRequestBodyObject, h as OpenApiResponseObject, i as OpenApiSchemaObject, T as TypeTransformer } from './types.d-DOXd97cA.js';
 import { HttpHeaders, HttpClient, HttpRequest, HttpResponse, HttpErrorResponse } from '@angular/common/http';
 import { Injector } from '@angular/core';
 import { CreateAxiosDefaults, AxiosStatic, AxiosInstance, AxiosRequestHeaders, AxiosResponse, AxiosError } from 'axios';
 import { UseFetchOptions, AsyncDataOptions, useAsyncData, useFetch, useLazyAsyncData, useLazyFetch } from 'nuxt/app';
 import { Ref } from 'vue';
-import * as typescript from 'typescript';
-import typescript__default from 'typescript';
+import { FetchOptions as FetchOptions$1, ofetch, ResponseType } from 'ofetch';
 import 'semver';
 import '@hey-api/codegen-core';
 import 'node:fs';
 
+declare module '@hey-api/codegen-core' {
+  interface ProjectRenderMeta {
+    moduleResolution?: typescript__default.ModuleResolutionKind;
+  }
+
+  interface SymbolMeta {
+    /**
+     * Name of the plugin that registered this symbol.
+     */
+    pluginName?: string;
+  }
+}
+
 type AccessLevel = 'private' | 'protected' | 'public';
 type FunctionParameter = {
     accessLevel?: AccessLevel;
@@ -78,7 +92,7 @@ interface QuerySerializerOptions {
 }
 
 type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
-type Client$5<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+type Client$6<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
     /**
      * Returns the final request URL.
      */
@@ -95,7 +109,7 @@ type Client$5<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn
         [K in HttpMethod]: SseFn;
     };
 });
-interface Config$5 {
+interface Config$6 {
     /**
      * Auth token or a function returning auth token. The resolved value will be
      * added to the request payload as defined by its `security` array.
@@ -149,7 +163,7 @@ interface Config$5 {
     responseValidator?: (data: unknown) => Promise<unknown>;
 }
 
-type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$5, 'method' | 'responseTransformer' | 'responseValidator'> & {
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$6, 'method' | 'responseTransformer' | 'responseValidator'> & {
     /**
      * Fetch API implementation. You can use this option to provide a custom
      * fetch instance.
@@ -219,10 +233,10 @@ type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> =
     stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
 };
 
-type ErrInterceptor$2<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
-type ReqInterceptor$2<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
-type ResInterceptor$2<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
-declare class Interceptors$2<Interceptor> {
+type ErrInterceptor$3<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
+type ReqInterceptor$3<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor$3<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors$3<Interceptor> {
     fns: Array<Interceptor | null>;
     clear(): void;
     eject(id: number | Interceptor): void;
@@ -231,14 +245,14 @@ declare class Interceptors$2<Interceptor> {
     update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
     use(fn: Interceptor): number;
 }
-interface Middleware$2<Req, Res, Err, Options> {
-    error: Interceptors$2<ErrInterceptor$2<Err, Res, Req, Options>>;
-    request: Interceptors$2<ReqInterceptor$2<Req, Options>>;
-    response: Interceptors$2<ResInterceptor$2<Res, Req, Options>>;
+interface Middleware$3<Req, Res, Err, Options> {
+    error: Interceptors$3<ErrInterceptor$3<Err, Res, Req, Options>>;
+    request: Interceptors$3<ReqInterceptor$3<Req, Options>>;
+    response: Interceptors$3<ResInterceptor$3<Res, Req, Options>>;
 }
 
-type ResponseStyle$1 = 'data' | 'fields';
-interface Config$4<T extends ClientOptions$4 = ClientOptions$4> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Omit<Config$5, 'headers'> {
+type ResponseStyle$2 = 'data' | 'fields';
+interface Config$5<T extends ClientOptions$5 = ClientOptions$5> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Omit<Config$6, 'headers'> {
     /**
      * Base URL for all requests made by this client.
      */
@@ -259,7 +273,7 @@ interface Config$4<T extends ClientOptions$4 = ClientOptions$4> extends Omit<Req
      *
      * @default 'fields'
      */
-    responseStyle?: ResponseStyle$1;
+    responseStyle?: ResponseStyle$2;
     /**
      * Throw an error instead of returning it in the response?
      *
@@ -267,7 +281,7 @@ interface Config$4<T extends ClientOptions$4 = ClientOptions$4> extends Omit<Req
      */
     throwOnError?: T['throwOnError'];
 }
-interface RequestOptions$4<TData = unknown, TResponseStyle extends ResponseStyle$1 = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$4<{
+interface RequestOptions$5<TData = unknown, TResponseStyle extends ResponseStyle$2 = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$5<{
     responseStyle: TResponseStyle;
     throwOnError: ThrowOnError;
 }>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
@@ -289,10 +303,10 @@ interface RequestOptions$4<TData = unknown, TResponseStyle extends ResponseStyle
     security?: ReadonlyArray<Auth>;
     url: Url;
 }
-interface ResolvedRequestOptions$2<TResponseStyle extends ResponseStyle$1 = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions$4<unknown, TResponseStyle, ThrowOnError, Url> {
+interface ResolvedRequestOptions$3<TResponseStyle extends ResponseStyle$2 = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions$5<unknown, TResponseStyle, ThrowOnError, Url> {
     serializedBody?: string;
 }
-type RequestResult$4<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle$1 = 'fields'> = Promise<ThrowOnError extends true ? TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+type RequestResult$5<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle$2 = 'fields'> = Promise<ThrowOnError extends true ? TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
     data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
     request: HttpRequest<unknown>;
     response: HttpResponse<TData>;
@@ -309,36 +323,36 @@ type RequestResult$4<TData = unknown, TError = unknown, ThrowOnError extends boo
         error: TError[keyof TError] | null;
     };
 }>;
-interface ClientOptions$4 {
+interface ClientOptions$5 {
     baseUrl?: string;
-    responseStyle?: ResponseStyle$1;
+    responseStyle?: ResponseStyle$2;
     throwOnError?: boolean;
 }
-type MethodFn$4 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$1 = 'fields'>(options: Omit<RequestOptions$4<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult$4<TData, TError, ThrowOnError, TResponseStyle>;
-type SseFn$4 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$1 = 'fields'>(options: Omit<RequestOptions$4<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
-type RequestFn$4 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$1 = 'fields'>(options: Omit<RequestOptions$4<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions$4<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult$4<TData, TError, ThrowOnError, TResponseStyle>;
-type RequestOptionsFn = <ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$1 = 'fields'>(options: RequestOptions$4<unknown, TResponseStyle, ThrowOnError>) => HttpRequest<unknown>;
-type BuildUrlFn$4 = <TData extends {
+type MethodFn$5 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$2 = 'fields'>(options: Omit<RequestOptions$5<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult$5<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn$5 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$2 = 'fields'>(options: Omit<RequestOptions$5<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type RequestFn$5 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$2 = 'fields'>(options: Omit<RequestOptions$5<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions$5<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult$5<TData, TError, ThrowOnError, TResponseStyle>;
+type RequestOptionsFn = <ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$2 = 'fields'>(options: RequestOptions$5<unknown, TResponseStyle, ThrowOnError>) => HttpRequest<unknown>;
+type BuildUrlFn$5 = <TData extends {
     body?: unknown;
     path?: Record<string, unknown>;
     query?: Record<string, unknown>;
     url: string;
-}>(options: Pick<TData, 'url'> & Options$4<TData>) => string;
-type Client$4 = Client$5<RequestFn$4, Config$4, MethodFn$4, BuildUrlFn$4, SseFn$4> & {
-    interceptors: Middleware$2<HttpRequest<unknown>, HttpResponse<unknown>, unknown, ResolvedRequestOptions$2>;
+}>(options: Pick<TData, 'url'> & Options$5<TData>) => string;
+type Client$5 = Client$6<RequestFn$5, Config$5, MethodFn$5, BuildUrlFn$5, SseFn$5> & {
+    interceptors: Middleware$3<HttpRequest<unknown>, HttpResponse<unknown>, unknown, ResolvedRequestOptions$3>;
     requestOptions: RequestOptionsFn;
 };
-interface TDataShape$4 {
+interface TDataShape$5 {
     body?: unknown;
     headers?: unknown;
     path?: unknown;
     query?: unknown;
     url: string;
 }
-type OmitKeys$4<T, K> = Pick<T, Exclude<keyof T, K>>;
-type Options$4<TData extends TDataShape$4 = TDataShape$4, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle$1 = 'fields'> = OmitKeys$4<RequestOptions$4<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>;
+type OmitKeys$5<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options$5<TData extends TDataShape$5 = TDataShape$5, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle$2 = 'fields'> = OmitKeys$5<RequestOptions$5<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>;
 
-interface Config$3<T extends ClientOptions$3 = ClientOptions$3> extends Omit<CreateAxiosDefaults, 'auth' | 'baseURL' | 'headers' | 'method'>, Config$5 {
+interface Config$4<T extends ClientOptions$4 = ClientOptions$4> extends Omit<CreateAxiosDefaults, 'auth' | 'baseURL' | 'headers' | 'method'>, Config$6 {
     /**
      * Axios implementation. You can use this option to provide either an
      * `AxiosStatic` or an `AxiosInstance`.
@@ -364,7 +378,7 @@ interface Config$3<T extends ClientOptions$3 = ClientOptions$3> extends Omit<Cre
      */
     throwOnError?: T['throwOnError'];
 }
-interface RequestOptions$3<TData = unknown, ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$3<{
+interface RequestOptions$4<TData = unknown, ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$4<{
     throwOnError: ThrowOnError;
 }>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
     /**
@@ -381,42 +395,42 @@ interface RequestOptions$3<TData = unknown, ThrowOnError extends boolean = boole
     security?: ReadonlyArray<Auth>;
     url: Url;
 }
-interface ClientOptions$3 {
+interface ClientOptions$4 {
     baseURL?: string;
     throwOnError?: boolean;
 }
-type RequestResult$3<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean> = ThrowOnError extends true ? Promise<AxiosResponse<TData extends Record<string, unknown> ? TData[keyof TData] : TData>> : Promise<(AxiosResponse<TData extends Record<string, unknown> ? TData[keyof TData] : TData> & {
+type RequestResult$4<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean> = ThrowOnError extends true ? Promise<AxiosResponse<TData extends Record<string, unknown> ? TData[keyof TData] : TData>> : Promise<(AxiosResponse<TData extends Record<string, unknown> ? TData[keyof TData] : TData> & {
     error: undefined;
 }) | (AxiosError<TError extends Record<string, unknown> ? TError[keyof TError] : TError> & {
     data: undefined;
     error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
 })>;
-type MethodFn$3 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$3<TData, ThrowOnError>, 'method'>) => RequestResult$3<TData, TError, ThrowOnError>;
-type SseFn$3 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$3<TData, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
-type RequestFn$3 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$3<TData, ThrowOnError>, 'method'> & Pick<Required<RequestOptions$3<TData, ThrowOnError>>, 'method'>) => RequestResult$3<TData, TError, ThrowOnError>;
-type BuildUrlFn$3 = <TData extends {
+type MethodFn$4 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$4<TData, ThrowOnError>, 'method'>) => RequestResult$4<TData, TError, ThrowOnError>;
+type SseFn$4 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$4<TData, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type RequestFn$4 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$4<TData, ThrowOnError>, 'method'> & Pick<Required<RequestOptions$4<TData, ThrowOnError>>, 'method'>) => RequestResult$4<TData, TError, ThrowOnError>;
+type BuildUrlFn$4 = <TData extends {
     body?: unknown;
     path?: Record<string, unknown>;
     query?: Record<string, unknown>;
     url: string;
-}>(options: Pick<TData, 'url'> & Omit<Options$3<TData>, 'axios'>) => string;
-type Client$3 = Client$5<RequestFn$3, Config$3, MethodFn$3, BuildUrlFn$3, SseFn$3> & {
+}>(options: Pick<TData, 'url'> & Options$4<TData>) => string;
+type Client$4 = Client$6<RequestFn$4, Config$4, MethodFn$4, BuildUrlFn$4, SseFn$4> & {
     instance: AxiosInstance;
 };
-interface TDataShape$3 {
+interface TDataShape$4 {
     body?: unknown;
     headers?: unknown;
     path?: unknown;
     query?: unknown;
     url: string;
 }
-type OmitKeys$3<T, K> = Pick<T, Exclude<keyof T, K>>;
-type Options$3<TData extends TDataShape$3 = TDataShape$3, ThrowOnError extends boolean = boolean, TResponse = unknown> = OmitKeys$3<RequestOptions$3<TResponse, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>;
+type OmitKeys$4<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options$4<TData extends TDataShape$4 = TDataShape$4, ThrowOnError extends boolean = boolean, TResponse = unknown> = OmitKeys$4<RequestOptions$4<TResponse, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>;
 
-type ErrInterceptor$1<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
-type ReqInterceptor$1<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
-type ResInterceptor$1<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
-declare class Interceptors$1<Interceptor> {
+type ErrInterceptor$2<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
+type ReqInterceptor$2<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor$2<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors$2<Interceptor> {
     fns: Array<Interceptor | null>;
     clear(): void;
     eject(id: number | Interceptor): void;
@@ -425,14 +439,14 @@ declare class Interceptors$1<Interceptor> {
     update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
     use(fn: Interceptor): number;
 }
-interface Middleware$1<Req, Res, Err, Options> {
-    error: Interceptors$1<ErrInterceptor$1<Err, Res, Req, Options>>;
-    request: Interceptors$1<ReqInterceptor$1<Req, Options>>;
-    response: Interceptors$1<ResInterceptor$1<Res, Req, Options>>;
+interface Middleware$2<Req, Res, Err, Options> {
+    error: Interceptors$2<ErrInterceptor$2<Err, Res, Req, Options>>;
+    request: Interceptors$2<ReqInterceptor$2<Req, Options>>;
+    response: Interceptors$2<ResInterceptor$2<Res, Req, Options>>;
 }
 
-type ResponseStyle = 'data' | 'fields';
-interface Config$2<T extends ClientOptions$2 = ClientOptions$2> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$5 {
+type ResponseStyle$1 = 'data' | 'fields';
+interface Config$3<T extends ClientOptions$3 = ClientOptions$3> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$6 {
     /**
      * Base URL for all requests made by this client.
      */
@@ -465,7 +479,7 @@ interface Config$2<T extends ClientOptions$2 = ClientOptions$2> extends Omit<Req
      *
      * @default 'fields'
      */
-    responseStyle?: ResponseStyle;
+    responseStyle?: ResponseStyle$1;
     /**
      * Throw an error instead of returning it in the response?
      *
@@ -473,7 +487,7 @@ interface Config$2<T extends ClientOptions$2 = ClientOptions$2> extends Omit<Req
      */
     throwOnError?: T['throwOnError'];
 }
-interface RequestOptions$2<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$2<{
+interface RequestOptions$3<TData = unknown, TResponseStyle extends ResponseStyle$1 = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$3<{
     responseStyle: TResponseStyle;
     throwOnError: ThrowOnError;
 }>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
@@ -491,10 +505,10 @@ interface RequestOptions$2<TData = unknown, TResponseStyle extends ResponseStyle
     security?: ReadonlyArray<Auth>;
     url: Url;
 }
-interface ResolvedRequestOptions$1<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions$2<unknown, TResponseStyle, ThrowOnError, Url> {
+interface ResolvedRequestOptions$2<TResponseStyle extends ResponseStyle$1 = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions$3<unknown, TResponseStyle, ThrowOnError, Url> {
     serializedBody?: string;
 }
-type RequestResult$2<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+type RequestResult$3<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle$1 = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
     data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
     request: Request;
     response: Response;
@@ -508,37 +522,37 @@ type RequestResult$2<TData = unknown, TError = unknown, ThrowOnError extends boo
     request: Request;
     response: Response;
 }>;
-interface ClientOptions$2 {
+interface ClientOptions$3 {
     baseUrl?: string;
-    responseStyle?: ResponseStyle;
+    responseStyle?: ResponseStyle$1;
     throwOnError?: boolean;
 }
-type MethodFn$2 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions$2<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult$2<TData, TError, ThrowOnError, TResponseStyle>;
-type SseFn$2 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions$2<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
-type RequestFn$2 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions$2<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions$2<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult$2<TData, TError, ThrowOnError, TResponseStyle>;
-type BuildUrlFn$2 = <TData extends {
+type MethodFn$3 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$1 = 'fields'>(options: Omit<RequestOptions$3<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult$3<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn$3 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$1 = 'fields'>(options: Omit<RequestOptions$3<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type RequestFn$3 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle$1 = 'fields'>(options: Omit<RequestOptions$3<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions$3<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult$3<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn$3 = <TData extends {
     body?: unknown;
     path?: Record<string, unknown>;
     query?: Record<string, unknown>;
     url: string;
-}>(options: Pick<TData, 'url'> & Options$2<TData>) => string;
-type Client$2 = Client$5<RequestFn$2, Config$2, MethodFn$2, BuildUrlFn$2, SseFn$2> & {
-    interceptors: Middleware$1<Request, Response, unknown, ResolvedRequestOptions$1>;
+}>(options: Pick<TData, 'url'> & Options$3<TData>) => string;
+type Client$3 = Client$6<RequestFn$3, Config$3, MethodFn$3, BuildUrlFn$3, SseFn$3> & {
+    interceptors: Middleware$2<Request, Response, unknown, ResolvedRequestOptions$2>;
 };
-interface TDataShape$2 {
+interface TDataShape$3 {
     body?: unknown;
     headers?: unknown;
     path?: unknown;
     query?: unknown;
     url: string;
 }
-type OmitKeys$2<T, K> = Pick<T, Exclude<keyof T, K>>;
-type Options$2<TData extends TDataShape$2 = TDataShape$2, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys$2<RequestOptions$2<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>;
+type OmitKeys$3<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options$3<TData extends TDataShape$3 = TDataShape$3, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle$1 = 'fields'> = OmitKeys$3<RequestOptions$3<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>;
 
-type ErrInterceptor<Err, Res, Options> = (error: Err, response: Res, options: Options) => Err | Promise<Err>;
-type ReqInterceptor<Options> = (options: Options) => void | Promise<void>;
-type ResInterceptor<Res, Options> = (response: Res, options: Options) => Res | Promise<Res>;
-declare class Interceptors<Interceptor> {
+type ErrInterceptor$1<Err, Res, Options> = (error: Err, response: Res, options: Options) => Err | Promise<Err>;
+type ReqInterceptor$1<Options> = (options: Options) => void | Promise<void>;
+type ResInterceptor$1<Res, Options> = (response: Res, options: Options) => Res | Promise<Res>;
+declare class Interceptors$1<Interceptor> {
     fns: Array<Interceptor | null>;
     clear(): void;
     eject(id: number | Interceptor): void;
@@ -547,13 +561,13 @@ declare class Interceptors<Interceptor> {
     update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
     use(fn: Interceptor): number;
 }
-interface Middleware<Res, Err, Options> {
-    error: Interceptors<ErrInterceptor<Err, Res, Options>>;
-    request: Interceptors<ReqInterceptor<Options>>;
-    response: Interceptors<ResInterceptor<Res, Options>>;
+interface Middleware$1<Res, Err, Options> {
+    error: Interceptors$1<ErrInterceptor$1<Err, Res, Options>>;
+    request: Interceptors$1<ReqInterceptor$1<Options>>;
+    response: Interceptors$1<ResInterceptor$1<Res, Options>>;
 }
 
-interface Config$1<T extends ClientOptions$1 = ClientOptions$1> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$5 {
+interface Config$2<T extends ClientOptions$2 = ClientOptions$2> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$6 {
     /**
      * Base URL for all requests made by this client.
      */
@@ -581,7 +595,7 @@ interface Config$1<T extends ClientOptions$1 = ClientOptions$1> extends Omit<Req
      */
     throwOnError?: T['throwOnError'];
 }
-interface RequestOptions$1<TData = unknown, ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$1<{
+interface RequestOptions$2<TData = unknown, ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$2<{
     throwOnError: ThrowOnError;
 }>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
     /**
@@ -598,10 +612,10 @@ interface RequestOptions$1<TData = unknown, ThrowOnError extends boolean = boole
     security?: ReadonlyArray<Auth>;
     url: Url;
 }
-interface ResolvedRequestOptions<ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions$1<unknown, ThrowOnError, Url> {
+interface ResolvedRequestOptions$1<ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions$2<unknown, ThrowOnError, Url> {
     serializedBody?: string;
 }
-type RequestResult$1<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean> = ThrowOnError extends true ? Promise<{
+type RequestResult$2<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean> = ThrowOnError extends true ? Promise<{
     data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
     response: Response;
 }> : Promise<({
@@ -613,38 +627,38 @@ type RequestResult$1<TData = unknown, TError = unknown, ThrowOnError extends boo
 }) & {
     response: Response;
 }>;
-interface ClientOptions$1 {
+interface ClientOptions$2 {
     baseUrl?: string;
     throwOnError?: boolean;
 }
-type MethodFn$1 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$1<TData, ThrowOnError>, 'method'>) => RequestResult$1<TData, TError, ThrowOnError>;
-type SseFn$1 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$1<TData, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
-type RequestFn$1 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$1<TData, ThrowOnError>, 'method'> & Pick<Required<RequestOptions$1<TData, ThrowOnError>>, 'method'>) => RequestResult$1<TData, TError, ThrowOnError>;
-type BuildUrlFn$1 = <TData extends {
+type MethodFn$2 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$2<TData, ThrowOnError>, 'method'>) => RequestResult$2<TData, TError, ThrowOnError>;
+type SseFn$2 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$2<TData, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type RequestFn$2 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions$2<TData, ThrowOnError>, 'method'> & Pick<Required<RequestOptions$2<TData, ThrowOnError>>, 'method'>) => RequestResult$2<TData, TError, ThrowOnError>;
+type BuildUrlFn$2 = <TData extends {
     body?: unknown;
     path?: Record<string, unknown>;
     query?: Record<string, unknown>;
     url: string;
-}>(options: Pick<TData, 'url'> & Options$1<TData>) => string;
-type Client$1 = Client$5<RequestFn$1, Config$1, MethodFn$1, BuildUrlFn$1, SseFn$1> & {
-    interceptors: Middleware<Response, unknown, ResolvedRequestOptions>;
+}>(options: Pick<TData, 'url'> & Options$2<TData>) => string;
+type Client$2 = Client$6<RequestFn$2, Config$2, MethodFn$2, BuildUrlFn$2, SseFn$2> & {
+    interceptors: Middleware$1<Response, unknown, ResolvedRequestOptions$1>;
 };
-interface TDataShape$1 {
+interface TDataShape$2 {
     body?: unknown;
     headers?: unknown;
     path?: unknown;
     query?: unknown;
     url: string;
 }
-type OmitKeys$1<T, K> = Pick<T, Exclude<keyof T, K>>;
-type Options$1<TData extends TDataShape$1 = TDataShape$1, ThrowOnError extends boolean = boolean, TResponse = unknown> = OmitKeys$1<RequestOptions$1<TResponse, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>;
+type OmitKeys$2<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options$2<TData extends TDataShape$2 = TDataShape$2, ThrowOnError extends boolean = boolean, TResponse = unknown> = OmitKeys$2<RequestOptions$2<TResponse, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>;
 
-type QuerySerializer = (query: Parameters<Client['buildUrl']>[0]['query']) => string;
+type QuerySerializer = (query: Parameters<Client$1['buildUrl']>[0]['query']) => string;
 type WithRefs<TData> = {
     [K in keyof TData]: NonNullable<TData[K]> extends object ? WithRefs<NonNullable<TData[K]>> | Ref<NonNullable<TData[K]>> : NonNullable<TData[K]> | Ref<NonNullable<TData[K]>>;
 };
 type KeysOf<T> = Array<T extends T ? (keyof T extends string ? keyof T : never) : never>;
-interface Config<T extends ClientOptions = ClientOptions> extends Omit<FetchOptions<unknown>, 'baseURL' | 'body' | 'headers' | 'method' | 'query'>, WithRefs<Pick<FetchOptions<unknown>, 'query'>>, Omit<Config$5, 'querySerializer'> {
+interface Config$1<T extends ClientOptions$1 = ClientOptions$1> extends Omit<FetchOptions<unknown>, 'baseURL' | 'body' | 'headers' | 'method' | 'query'>, WithRefs<Pick<FetchOptions<unknown>, 'query'>>, Omit<Config$6, 'querySerializer'> {
     /**
      * Base URL for all requests made by this client.
      */
@@ -658,7 +672,7 @@ interface Config<T extends ClientOptions = ClientOptions> extends Omit<FetchOpti
      */
     querySerializer?: QuerySerializer | QuerySerializerOptions;
 }
-interface RequestOptions<TComposable extends Composable = '$fetch', ResT = unknown, DefaultT = undefined, Url extends string = string> extends Config, WithRefs<{
+interface RequestOptions$1<TComposable extends Composable = '$fetch', ResT = unknown, DefaultT = undefined, Url extends string = string> extends Config$1, WithRefs<{
     /**
      * Any body that you want to add to your request.
      *
@@ -678,28 +692,210 @@ interface RequestOptions<TComposable extends Composable = '$fetch', ResT = unkno
     security?: ReadonlyArray<Auth>;
     url: Url;
 }
-type RequestResult<TComposable extends Composable, ResT, TError> = TComposable extends '$fetch' ? ReturnType<typeof $fetch<ResT>> : TComposable extends 'useAsyncData' ? ReturnType<typeof useAsyncData<ResT | null, TError>> : TComposable extends 'useFetch' ? ReturnType<typeof useFetch<ResT | null, TError>> : TComposable extends 'useLazyAsyncData' ? ReturnType<typeof useLazyAsyncData<ResT | null, TError>> : TComposable extends 'useLazyFetch' ? ReturnType<typeof useLazyFetch<ResT | null, TError>> : never;
-interface ClientOptions {
+type RequestResult$1<TComposable extends Composable, ResT, TError> = TComposable extends '$fetch' ? ReturnType<typeof $fetch<ResT>> : TComposable extends 'useAsyncData' ? ReturnType<typeof useAsyncData<ResT | null, TError>> : TComposable extends 'useFetch' ? ReturnType<typeof useFetch<ResT | null, TError>> : TComposable extends 'useLazyAsyncData' ? ReturnType<typeof useLazyAsyncData<ResT | null, TError>> : TComposable extends 'useLazyFetch' ? ReturnType<typeof useLazyFetch<ResT | null, TError>> : never;
+interface ClientOptions$1 {
     baseURL?: string;
 }
-type MethodFn = <TComposable extends Composable = '$fetch', ResT = unknown, TError = unknown, DefaultT = undefined>(options: Omit<RequestOptions<TComposable, ResT, DefaultT>, 'method'>) => RequestResult<TComposable, ResT, TError>;
-type SseFn = <TComposable extends Composable = '$fetch', ResT = unknown, TError = unknown, DefaultT = undefined>(options: Omit<RequestOptions<TComposable, ResT, DefaultT>, 'method'>) => Promise<ServerSentEventsResult<RequestResult<TComposable, ResT, TError>>>;
-type RequestFn = <TComposable extends Composable = '$fetch', ResT = unknown, TError = unknown, DefaultT = undefined>(options: Omit<RequestOptions<TComposable, ResT, DefaultT>, 'method'> & Pick<Required<RequestOptions<TComposable, ResT, DefaultT>>, 'method'>) => RequestResult<TComposable, ResT, TError>;
-interface TDataShape {
+type MethodFn$1 = <TComposable extends Composable = '$fetch', ResT = unknown, TError = unknown, DefaultT = undefined>(options: Omit<RequestOptions$1<TComposable, ResT, DefaultT>, 'method'>) => RequestResult$1<TComposable, ResT, TError>;
+type SseFn$1 = <TComposable extends Composable = '$fetch', ResT = unknown, TError = unknown, DefaultT = undefined>(options: Omit<RequestOptions$1<TComposable, ResT, DefaultT>, 'method'>) => Promise<ServerSentEventsResult<RequestResult$1<TComposable, ResT, TError>>>;
+type RequestFn$1 = <TComposable extends Composable = '$fetch', ResT = unknown, TError = unknown, DefaultT = undefined>(options: Omit<RequestOptions$1<TComposable, ResT, DefaultT>, 'method'> & Pick<Required<RequestOptions$1<TComposable, ResT, DefaultT>>, 'method'>) => RequestResult$1<TComposable, ResT, TError>;
+interface TDataShape$1 {
     body?: unknown;
     headers?: unknown;
     path?: FetchOptions<unknown>['query'];
     query?: FetchOptions<unknown>['query'];
     url: string;
 }
-type BuildUrlOptions<TData extends Omit<TDataShape, 'headers'> = Omit<TDataShape, 'headers'>> = Pick<WithRefs<TData>, 'path' | 'query'> & Pick<TData, 'url'> & Pick<Options<'$fetch', TData>, 'baseURL' | 'querySerializer'>;
-type BuildUrlFn = <TData extends Omit<TDataShape, 'headers'>>(options: BuildUrlOptions<TData>) => string;
-type Client = Client$5<RequestFn, Config, MethodFn, BuildUrlFn, SseFn>;
-type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
-type Options<TComposable extends Composable = '$fetch', TData extends TDataShape = TDataShape, ResT = unknown, DefaultT = undefined> = OmitKeys<RequestOptions<TComposable, ResT, DefaultT>, 'body' | 'path' | 'query' | 'url'> & WithRefs<Omit<TData, 'url'>>;
+type BuildUrlOptions<TData extends Omit<TDataShape$1, 'headers'> = Omit<TDataShape$1, 'headers'>> = Pick<WithRefs<TData>, 'path' | 'query'> & Pick<TData, 'url'> & Pick<Options$1<'$fetch', TData>, 'baseURL' | 'querySerializer'>;
+type BuildUrlFn$1 = <TData extends Omit<TDataShape$1, 'headers'>>(options: BuildUrlOptions<TData>) => string;
+type Client$1 = Client$6<RequestFn$1, Config$1, MethodFn$1, BuildUrlFn$1, SseFn$1>;
+type OmitKeys$1<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options$1<TComposable extends Composable = '$fetch', TData extends TDataShape$1 = TDataShape$1, ResT = unknown, DefaultT = undefined> = OmitKeys$1<RequestOptions$1<TComposable, ResT, DefaultT>, 'body' | 'path' | 'query' | 'url'> & WithRefs<Omit<TData, 'url'>>;
 type FetchOptions<TData> = Omit<UseFetchOptions<TData, TData>, keyof AsyncDataOptions<TData>>;
 type Composable = '$fetch' | 'useAsyncData' | 'useFetch' | 'useLazyAsyncData' | 'useLazyFetch';
 
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    fns: Array<Interceptor | null>;
+    clear(): void;
+    eject(id: number | Interceptor): void;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+    use(fn: Interceptor): number;
+}
+interface Middleware<Req, Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+    request: Interceptors<ReqInterceptor<Req, Options>>;
+    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+
+type ResponseStyle = 'data' | 'fields';
+interface Config<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$6 {
+    /**
+     * HTTP(S) agent configuration (Node.js only). Passed through to ofetch.
+     */
+    agent?: FetchOptions$1['agent'];
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T['baseUrl'];
+    /**
+     * Node-only proxy/agent options.
+     */
+    dispatcher?: FetchOptions$1['dispatcher'];
+    /**
+     * Fetch API implementation. Used for SSE streaming. You can use this option
+     * to provide a custom fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Controls the native ofetch behaviour that throws `FetchError` when
+     * `response.ok === false`. We default to suppressing it to match the fetch
+     * client semantics and let `throwOnError` drive the outcome.
+     */
+    ignoreResponseError?: FetchOptions$1['ignoreResponseError'];
+    /**
+     * Please don't use the Fetch client for Next.js applications. The `next`
+     * options won't have any effect.
+     *
+     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+     */
+    next?: never;
+    /**
+     * Custom ofetch instance created via `ofetch.create()`. If provided, it will
+     * be used for requests instead of the default `ofetch` export.
+     */
+    ofetch?: typeof ofetch;
+    /**
+     * ofetch hook called before a request is sent.
+     */
+    onRequest?: FetchOptions$1['onRequest'];
+    /**
+     * ofetch hook called when a request fails before receiving a response
+     * (e.g., network errors or aborted requests).
+     */
+    onRequestError?: FetchOptions$1['onRequestError'];
+    /**
+     * ofetch hook called after a successful response is received and parsed.
+     */
+    onResponse?: FetchOptions$1['onResponse'];
+    /**
+     * ofetch hook called when the response indicates an error (non-ok status)
+     * or when response parsing fails.
+     */
+    onResponseError?: FetchOptions$1['onResponseError'];
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    /** Custom response parser (ofetch). */
+    parseResponse?: FetchOptions$1['parseResponse'];
+    /**
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
+     */
+    responseStyle?: ResponseStyle;
+    /**
+     * ofetch responseType override. If provided, it will be passed directly to
+     * ofetch and take precedence over `parseAs`.
+     */
+    responseType?: ResponseType;
+    /**
+     * Automatically retry failed requests.
+     */
+    retry?: FetchOptions$1['retry'];
+    /**
+     * Delay (in ms) between retry attempts.
+     */
+    retryDelay?: FetchOptions$1['retryDelay'];
+    /**
+     * HTTP status codes that should trigger a retry.
+     */
+    retryStatusCodes?: FetchOptions$1['retryStatusCodes'];
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+    /**
+     * Abort the request after the given milliseconds.
+     */
+    timeout?: number;
+}
+interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    request: Request;
+    response: Response;
+}>;
+interface ClientOptions {
+    baseUrl?: string;
+    responseStyle?: ResponseStyle;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: Pick<TData, 'url'> & Options<TData>) => string;
+type Client = Client$6<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>;
+
 declare const defaultPaginationKeywords: readonly ["after", "before", "cursor", "offset", "page", "start"];
 
 /**
@@ -714,7 +910,6 @@ declare const clientDefaultConfig: {
 };
 declare const clientDefaultMeta: {
     readonly dependencies: readonly ["@hey-api/typescript"];
-    readonly output: "client";
     readonly tags: readonly ["client"];
 };
 
@@ -1366,10 +1561,10 @@ type Configs = UserConfig | (() => UserConfig) | (() => Promise<UserConfig>);
  *
  * @param userConfig User provided {@link UserConfig} configuration.
  */
-declare const createClient: (userConfig?: Configs, logger?: Logger) => Promise<ReadonlyArray<Client$6 | IR.Context>>;
+declare const createClient: (userConfig?: Configs, logger?: Logger) => Promise<ReadonlyArray<Client$7 | IR.Context>>;
 /**
  * Type helper for openapi-ts.config.ts, returns {@link UserConfig} object
  */
 declare const defineConfig: (config: Configs) => Promise<UserConfig>;
 
-export { type Client$4 as AngularClient, type Client$3 as AxiosClient, type Client$2 as FetchClient, IR, Logger, type Client$1 as NextClient, type Client as NuxtClient, Plugin, UserConfig, clientDefaultConfig, clientDefaultMeta, clientPluginHandler, compiler, createClient, defaultPaginationKeywords, defaultPlugins, defineConfig, definePluginConfig, tsc, utils };
+export { type Client$5 as AngularClient, type Client$4 as AxiosClient, type Client$3 as FetchClient, IR, Logger, type Client$2 as NextClient, type Client$1 as NuxtClient, type Client as OfetchClient, Plugin, UserConfig, clientDefaultConfig, clientDefaultMeta, clientPluginHandler, compiler, createClient, defaultPaginationKeywords, defaultPlugins, defineConfig, definePluginConfig, tsc, utils };