@hey-api/openapi-ts 0.86.11 → 0.87.0

package/dist/index.d.cts

@@ -1,13 +1,15 @@
-import { A as AccessLevel, C as PluginHandler, D as Comments, E as MaybeArray, F as types_d_exports, I as __export, M as FunctionTypeParameter, N as ObjectValue, O as ImportExportItemObject, P as SyntaxKindKeyword, S as Client$2, T as LazyOrAsync, _ as OpenApiRequestBodyObject, c as ExpressionTransformer, d as Client$7, f as Operation, g as OpenApiParameterObject, h as OpenApiOperationObject, i as UserConfig, j as FunctionParameter, k as tsNodeToString, l as DefinePlugin, m as OpenApiMetaObject, o as IR, p as OpenApi, s as TypeTransformer, t as LegacyIR, u as Plugin, v as OpenApiResponseObject, w as StringCase, x as Logger, y as OpenApiSchemaObject } from "./types-Bxdq98WE.cjs";
-import * as typescript0 from "typescript";
-import ts from "typescript";
+import { S as MaybeArray, _ as Client$2, a as Plugin, b as IR, c as OpenApiOperationObject, d as OpenApiResponseObject, f as OpenApiSchemaObject, g as ExpressionTransformer, h as TypeTransformer, i as DefinePlugin, l as OpenApiParameterObject, m as Logger, n as UserConfig, o as OpenApi, p as Context, s as OpenApiMetaObject, u as OpenApiRequestBodyObject, v as PluginHandler, x as LazyOrAsync, y as StringCase } from "./config-B2o9ax_a.cjs";
 import { HttpClient, HttpErrorResponse, HttpHeaders, HttpRequest, HttpResponse } from "@angular/common/http";
 import { Injector } from "@angular/core";
 import { AxiosError, AxiosInstance, AxiosRequestHeaders, AxiosResponse, AxiosStatic, CreateAxiosDefaults } from "axios";
 import { AsyncDataOptions, UseFetchOptions, useAsyncData, useFetch, useLazyAsyncData, useLazyFetch } from "nuxt/app";
 import { Ref } from "vue";
 import { FetchOptions, ResponseType, ofetch } from "ofetch";
+import * as typescript0 from "typescript";
+import ts from "typescript";
 
+//#region rolldown:runtime
+//#endregion
 //#region src/plugins/@hey-api/client-core/bundle/auth.d.ts
 type AuthToken = string | undefined;
 interface Auth {
@@ -28,12 +30,12 @@ interface Auth {
 }
 //#endregion
 //#region src/plugins/@hey-api/client-core/bundle/pathSerializer.d.ts
-interface SerializerOptions<T$1> {
+interface SerializerOptions<T> {
   /**
    * @default true
    */
   explode: boolean;
-  style: T$1;
+  style: T;
 }
 type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
 type ObjectStyle = 'form' | 'deepObject';
@@ -56,7 +58,7 @@ type QuerySerializerOptions = QuerySerializerOptionsObject & {
 //#endregion
 //#region src/plugins/@hey-api/client-core/bundle/types.d.ts
 type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
-type Client$8<RequestFn$6 = never, Config$7 = unknown, MethodFn$6 = never, BuildUrlFn$6 = never, SseFn$6 = never> = {
+type Client$7<RequestFn$6 = never, Config$7 = unknown, MethodFn$6 = never, BuildUrlFn$6 = never, SseFn$6 = never> = {
   /**
    * Returns the final request URL.
    */
@@ -124,7 +126,7 @@ interface Config {
 }
 //#endregion
 //#region src/plugins/@hey-api/client-core/bundle/serverSentEvents.d.ts
-type ServerSentEventsOptions<TData$1 = unknown> = Omit<RequestInit, 'method'> & Pick<Config, 'method' | 'responseTransformer' | 'responseValidator'> & {
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config, 'method' | 'responseTransformer' | 'responseValidator'> & {
   /**
    * Fetch API implementation. You can use this option to provide a custom
    * fetch instance.
@@ -152,7 +154,7 @@ type ServerSentEventsOptions<TData$1 = unknown> = Omit<RequestInit, 'method'> &
    * @param event Event streamed from the server.
    * @returns Nothing (void).
    */
-  onSseEvent?: (event: StreamEvent<TData$1>) => void;
+  onSseEvent?: (event: StreamEvent<TData>) => void;
   serializedBody?: RequestInit['body'];
   /**
    * Default retry delay in milliseconds.
@@ -184,20 +186,20 @@ type ServerSentEventsOptions<TData$1 = unknown> = Omit<RequestInit, 'method'> &
   sseSleepFn?: (ms: number) => Promise<void>;
   url: string;
 };
-interface StreamEvent<TData$1 = unknown> {
-  data: TData$1;
+interface StreamEvent<TData = unknown> {
+  data: TData;
   event?: string;
   id?: string;
   retry?: number;
 }
-type ServerSentEventsResult<TData$1 = unknown, TReturn = void, TNext = unknown> = {
-  stream: AsyncGenerator<TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1, TReturn, TNext>;
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+  stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
 };
 //#endregion
 //#region src/plugins/@hey-api/client-angular/bundle/utils.d.ts
-type ErrInterceptor$3<Err$1, Res$1, Req$1, Options$7> = (error: Err$1, response: Res$1, request: Req$1, options: Options$7) => Err$1 | Promise<Err$1>;
-type ReqInterceptor$3<Req$1, Options$7> = (request: Req$1, options: Options$7) => Req$1 | Promise<Req$1>;
-type ResInterceptor$3<Res$1, Req$1, Options$7> = (response: Res$1, request: Req$1, options: Options$7) => Res$1 | Promise<Res$1>;
+type ErrInterceptor$3<Err, Res, Req, Options$6> = (error: Err, response: Res, request: Req, options: Options$6) => Err | Promise<Err>;
+type ReqInterceptor$3<Req, Options$6> = (request: Req, options: Options$6) => Req | Promise<Req>;
+type ResInterceptor$3<Res, Req, Options$6> = (response: Res, request: Req, options: Options$6) => Res | Promise<Res>;
 declare class Interceptors$3<Interceptor> {
   fns: Array<Interceptor | null>;
   clear(): void;
@@ -207,19 +209,19 @@ declare class Interceptors$3<Interceptor> {
   update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
   use(fn: Interceptor): number;
 }
-interface Middleware$3<Req$1, Res$1, Err$1, Options$7> {
-  error: Interceptors$3<ErrInterceptor$3<Err$1, Res$1, Req$1, Options$7>>;
-  request: Interceptors$3<ReqInterceptor$3<Req$1, Options$7>>;
-  response: Interceptors$3<ResInterceptor$3<Res$1, Req$1, Options$7>>;
+interface Middleware$3<Req, Res, Err, Options$6> {
+  error: Interceptors$3<ErrInterceptor$3<Err, Res, Req, Options$6>>;
+  request: Interceptors$3<ReqInterceptor$3<Req, Options$6>>;
+  response: Interceptors$3<ResInterceptor$3<Res, Req, Options$6>>;
 }
 //#endregion
 //#region src/plugins/@hey-api/client-angular/bundle/types.d.ts
 type ResponseStyle$2 = 'data' | 'fields';
-interface Config$6<T$1 extends ClientOptions$5 = ClientOptions$5> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Omit<Config, 'headers'> {
+interface Config$6<T extends ClientOptions$5 = ClientOptions$5> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Omit<Config, 'headers'> {
   /**
    * Base URL for all requests made by this client.
    */
-  baseUrl?: T$1['baseUrl'];
+  baseUrl?: T['baseUrl'];
   /**
    * An object containing any HTTP headers that you want to pre-populate your
    * `HttpHeaders` object with.
@@ -242,12 +244,12 @@ interface Config$6<T$1 extends ClientOptions$5 = ClientOptions$5> extends Omit<R
    *
    * @default false
    */
-  throwOnError?: T$1['throwOnError'];
+  throwOnError?: T['throwOnError'];
 }
-interface RequestOptions$5<TData$1 = unknown, TResponseStyle$1 extends ResponseStyle$2 = 'fields', ThrowOnError$1 extends boolean = boolean, Url extends string = string> extends Config$6<{
-  responseStyle: TResponseStyle$1;
-  throwOnError: ThrowOnError$1;
-}>, Pick<ServerSentEventsOptions<TData$1>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+interface RequestOptions$5<TData = unknown, TResponseStyle extends ResponseStyle$2 = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$6<{
+  responseStyle: TResponseStyle;
+  throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
   /**
    * Any body that you want to add to your request.
    *
@@ -266,24 +268,24 @@ interface RequestOptions$5<TData$1 = unknown, TResponseStyle$1 extends ResponseS
   security?: ReadonlyArray<Auth>;
   url: Url;
 }
-interface ResolvedRequestOptions$3<TResponseStyle$1 extends ResponseStyle$2 = 'fields', ThrowOnError$1 extends boolean = boolean, Url extends string = string> extends RequestOptions$5<unknown, TResponseStyle$1, ThrowOnError$1, 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$5<TData$1 = unknown, TError$1 = unknown, ThrowOnError$1 extends boolean = boolean, TResponseStyle$1 extends ResponseStyle$2 = 'fields'> = Promise<ThrowOnError$1 extends true ? TResponseStyle$1 extends 'data' ? TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1 : {
-  data: TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1;
+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$1>;
-} : TResponseStyle$1 extends 'data' ? (TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1) | undefined : {
-  data: TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1;
+  response: HttpResponse<TData>;
+} : 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;
   request: HttpRequest<unknown>;
-  response: HttpResponse<TData$1>;
+  response: HttpResponse<TData>;
 } | {
   data: undefined;
-  error: TError$1[keyof TError$1];
+  error: TError[keyof TError];
   request: HttpRequest<unknown>;
   response: HttpErrorResponse & {
-    error: TError$1[keyof TError$1] | null;
+    error: TError[keyof TError] | null;
   };
 }>;
 interface ClientOptions$5 {
@@ -300,8 +302,8 @@ type BuildUrlFn$5 = <TData extends {
   path?: Record<string, unknown>;
   query?: Record<string, unknown>;
   url: string;
-}>(options: Pick<TData, 'url'> & Options$6<TData>) => string;
-type Client = Client$8<RequestFn$5, Config$6, MethodFn$5, BuildUrlFn$5, SseFn$5> & {
+}>(options: TData & Options$5<TData>) => string;
+type Client = Client$7<RequestFn$5, Config$6, MethodFn$5, BuildUrlFn$5, SseFn$5> & {
   interceptors: Middleware$3<HttpRequest<unknown>, HttpResponse<unknown>, unknown, ResolvedRequestOptions$3>;
   requestOptions: RequestOptionsFn;
 };
@@ -312,11 +314,11 @@ interface TDataShape$5 {
   query?: unknown;
   url: string;
 }
-type OmitKeys$5<T$1, K$1> = Pick<T$1, Exclude<keyof T$1, K$1>>;
-type Options$6<TData$1 extends TDataShape$5 = TDataShape$5, ThrowOnError$1 extends boolean = boolean, TResponse = unknown, TResponseStyle$1 extends ResponseStyle$2 = 'fields'> = OmitKeys$5<RequestOptions$5<TResponse, TResponseStyle$1, ThrowOnError$1>, 'body' | 'path' | 'query' | 'url'> & Omit<TData$1, 'url'>;
+type OmitKeys$5<T, K$1> = Pick<T, Exclude<keyof T, K$1>>;
+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'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
 //#endregion
 //#region src/plugins/@hey-api/client-axios/bundle/types.d.ts
-interface Config$5<T$1 extends ClientOptions$4 = ClientOptions$4> extends Omit<CreateAxiosDefaults, 'auth' | 'baseURL' | 'headers' | 'method'>, Config {
+interface Config$5<T extends ClientOptions$4 = ClientOptions$4> extends Omit<CreateAxiosDefaults, 'auth' | 'baseURL' | 'headers' | 'method'>, Config {
   /**
    * Axios implementation. You can use this option to provide either an
    * `AxiosStatic` or an `AxiosInstance`.
@@ -327,7 +329,7 @@ interface Config$5<T$1 extends ClientOptions$4 = ClientOptions$4> extends Omit<C
   /**
    * Base URL for all requests made by this client.
    */
-  baseURL?: T$1['baseURL'];
+  baseURL?: T['baseURL'];
   /**
    * An object containing any HTTP headers that you want to pre-populate your
    * `Headers` object with.
@@ -340,11 +342,11 @@ interface Config$5<T$1 extends ClientOptions$4 = ClientOptions$4> extends Omit<C
    *
    * @default false
    */
-  throwOnError?: T$1['throwOnError'];
+  throwOnError?: T['throwOnError'];
 }
-interface RequestOptions$4<TData$1 = unknown, ThrowOnError$1 extends boolean = boolean, Url extends string = string> extends Config$5<{
-  throwOnError: ThrowOnError$1;
-}>, Pick<ServerSentEventsOptions<TData$1>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+interface RequestOptions$4<TData = unknown, ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$5<{
+  throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
   /**
    * Any body that you want to add to your request.
    *
@@ -363,11 +365,11 @@ interface ClientOptions$4 {
   baseURL?: string;
   throwOnError?: boolean;
 }
-type RequestResult$4<TData$1 = unknown, TError$1 = unknown, ThrowOnError$1 extends boolean = boolean> = ThrowOnError$1 extends true ? Promise<AxiosResponse<TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1>> : Promise<(AxiosResponse<TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1> & {
+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$1 extends Record<string, unknown> ? TError$1[keyof TError$1] : TError$1> & {
+}) | (AxiosError<TError extends Record<string, unknown> ? TError[keyof TError] : TError> & {
   data: undefined;
-  error: TError$1 extends Record<string, unknown> ? TError$1[keyof TError$1] : TError$1;
+  error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
 })>;
 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>>;
@@ -377,8 +379,8 @@ type BuildUrlFn$4 = <TData extends {
   path?: Record<string, unknown>;
   query?: Record<string, unknown>;
   url: string;
-}>(options: Pick<TData, 'url'> & Options$5<TData>) => string;
-type Client$1 = Client$8<RequestFn$4, Config$5, MethodFn$4, BuildUrlFn$4, SseFn$4> & {
+}>(options: TData & Options$4<TData>) => string;
+type Client$1 = Client$7<RequestFn$4, Config$5, MethodFn$4, BuildUrlFn$4, SseFn$4> & {
   instance: AxiosInstance;
 };
 interface TDataShape$4 {
@@ -388,13 +390,13 @@ interface TDataShape$4 {
   query?: unknown;
   url: string;
 }
-type OmitKeys$4<T$1, K$1> = Pick<T$1, Exclude<keyof T$1, K$1>>;
-type Options$5<TData$1 extends TDataShape$4 = TDataShape$4, ThrowOnError$1 extends boolean = boolean, TResponse = unknown> = OmitKeys$4<RequestOptions$4<TResponse, ThrowOnError$1>, 'body' | 'path' | 'query' | 'url'> & Omit<TData$1, 'url'>;
+type OmitKeys$4<T, K$1> = Pick<T, Exclude<keyof T, K$1>>;
+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'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
 //#endregion
 //#region src/plugins/@hey-api/client-fetch/bundle/utils.d.ts
-type ErrInterceptor$2<Err$1, Res$1, Req$1, Options$7> = (error: Err$1, response: Res$1, request: Req$1, options: Options$7) => Err$1 | Promise<Err$1>;
-type ReqInterceptor$2<Req$1, Options$7> = (request: Req$1, options: Options$7) => Req$1 | Promise<Req$1>;
-type ResInterceptor$2<Res$1, Req$1, Options$7> = (response: Res$1, request: Req$1, options: Options$7) => Res$1 | Promise<Res$1>;
+type ErrInterceptor$2<Err, Res, Req, Options$6> = (error: Err, response: Res, request: Req, options: Options$6) => Err | Promise<Err>;
+type ReqInterceptor$2<Req, Options$6> = (request: Req, options: Options$6) => Req | Promise<Req>;
+type ResInterceptor$2<Res, Req, Options$6> = (response: Res, request: Req, options: Options$6) => Res | Promise<Res>;
 declare class Interceptors$2<Interceptor> {
   fns: Array<Interceptor | null>;
   clear(): void;
@@ -404,19 +406,19 @@ declare class Interceptors$2<Interceptor> {
   update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
   use(fn: Interceptor): number;
 }
-interface Middleware$2<Req$1, Res$1, Err$1, Options$7> {
-  error: Interceptors$2<ErrInterceptor$2<Err$1, Res$1, Req$1, Options$7>>;
-  request: Interceptors$2<ReqInterceptor$2<Req$1, Options$7>>;
-  response: Interceptors$2<ResInterceptor$2<Res$1, Req$1, Options$7>>;
+interface Middleware$2<Req, Res, Err, Options$6> {
+  error: Interceptors$2<ErrInterceptor$2<Err, Res, Req, Options$6>>;
+  request: Interceptors$2<ReqInterceptor$2<Req, Options$6>>;
+  response: Interceptors$2<ResInterceptor$2<Res, Req, Options$6>>;
 }
 //#endregion
 //#region src/plugins/@hey-api/client-fetch/bundle/types.d.ts
 type ResponseStyle$1 = 'data' | 'fields';
-interface Config$4<T$1 extends ClientOptions$3 = ClientOptions$3> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config {
+interface Config$4<T extends ClientOptions$3 = ClientOptions$3> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config {
   /**
    * Base URL for all requests made by this client.
    */
-  baseUrl?: T$1['baseUrl'];
+  baseUrl?: T['baseUrl'];
   /**
    * Fetch API implementation. You can use this option to provide a custom
    * fetch instance.
@@ -451,12 +453,12 @@ interface Config$4<T$1 extends ClientOptions$3 = ClientOptions$3> extends Omit<R
    *
    * @default false
    */
-  throwOnError?: T$1['throwOnError'];
+  throwOnError?: T['throwOnError'];
 }
-interface RequestOptions$3<TData$1 = unknown, TResponseStyle$1 extends ResponseStyle$1 = 'fields', ThrowOnError$1 extends boolean = boolean, Url extends string = string> extends Config$4<{
-  responseStyle: TResponseStyle$1;
-  throwOnError: ThrowOnError$1;
-}>, Pick<ServerSentEventsOptions<TData$1>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+interface RequestOptions$3<TData = unknown, TResponseStyle extends ResponseStyle$1 = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$4<{
+  responseStyle: TResponseStyle;
+  throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
   /**
    * Any body that you want to add to your request.
    *
@@ -471,19 +473,19 @@ interface RequestOptions$3<TData$1 = unknown, TResponseStyle$1 extends ResponseS
   security?: ReadonlyArray<Auth>;
   url: Url;
 }
-interface ResolvedRequestOptions$2<TResponseStyle$1 extends ResponseStyle$1 = 'fields', ThrowOnError$1 extends boolean = boolean, Url extends string = string> extends RequestOptions$3<unknown, TResponseStyle$1, ThrowOnError$1, 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$3<TData$1 = unknown, TError$1 = unknown, ThrowOnError$1 extends boolean = boolean, TResponseStyle$1 extends ResponseStyle$1 = 'fields'> = ThrowOnError$1 extends true ? Promise<TResponseStyle$1 extends 'data' ? TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1 : {
-  data: TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1;
+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;
-}> : Promise<TResponseStyle$1 extends 'data' ? (TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1) | undefined : ({
-  data: TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1;
+}> : 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$1 extends Record<string, unknown> ? TError$1[keyof TError$1] : TError$1;
+  error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
 }) & {
   request: Request;
   response: Response;
@@ -501,8 +503,8 @@ type BuildUrlFn$3 = <TData extends {
   path?: Record<string, unknown>;
   query?: Record<string, unknown>;
   url: string;
-}>(options: Pick<TData, 'url'> & Options$4<TData>) => string;
-type Client$3 = Client$8<RequestFn$3, Config$4, MethodFn$3, BuildUrlFn$3, SseFn$3> & {
+}>(options: TData & Options$3<TData>) => string;
+type Client$3 = Client$7<RequestFn$3, Config$4, MethodFn$3, BuildUrlFn$3, SseFn$3> & {
   interceptors: Middleware$2<Request, Response, unknown, ResolvedRequestOptions$2>;
 };
 interface TDataShape$3 {
@@ -512,13 +514,13 @@ interface TDataShape$3 {
   query?: unknown;
   url: string;
 }
-type OmitKeys$3<T$1, K$1> = Pick<T$1, Exclude<keyof T$1, K$1>>;
-type Options$4<TData$1 extends TDataShape$3 = TDataShape$3, ThrowOnError$1 extends boolean = boolean, TResponse = unknown, TResponseStyle$1 extends ResponseStyle$1 = 'fields'> = OmitKeys$3<RequestOptions$3<TResponse, TResponseStyle$1, ThrowOnError$1>, 'body' | 'path' | 'query' | 'url'> & Omit<TData$1, 'url'>;
+type OmitKeys$3<T, K$1> = Pick<T, Exclude<keyof T, K$1>>;
+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'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
 //#endregion
 //#region src/plugins/@hey-api/client-next/bundle/utils.d.ts
-type ErrInterceptor$1<Err$1, Res$1, Options$7> = (error: Err$1, response: Res$1, options: Options$7) => Err$1 | Promise<Err$1>;
-type ReqInterceptor$1<Options$7> = (options: Options$7) => void | Promise<void>;
-type ResInterceptor$1<Res$1, Options$7> = (response: Res$1, options: Options$7) => Res$1 | Promise<Res$1>;
+type ErrInterceptor$1<Err, Res, Options$6> = (error: Err, response: Res, options: Options$6) => Err | Promise<Err>;
+type ReqInterceptor$1<Options$6> = (options: Options$6) => void | Promise<void>;
+type ResInterceptor$1<Res, Options$6> = (response: Res, options: Options$6) => Res | Promise<Res>;
 declare class Interceptors$1<Interceptor> {
   fns: Array<Interceptor | null>;
   clear(): void;
@@ -528,18 +530,18 @@ declare class Interceptors$1<Interceptor> {
   update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
   use(fn: Interceptor): number;
 }
-interface Middleware$1<Res$1, Err$1, Options$7> {
-  error: Interceptors$1<ErrInterceptor$1<Err$1, Res$1, Options$7>>;
-  request: Interceptors$1<ReqInterceptor$1<Options$7>>;
-  response: Interceptors$1<ResInterceptor$1<Res$1, Options$7>>;
+interface Middleware$1<Res, Err, Options$6> {
+  error: Interceptors$1<ErrInterceptor$1<Err, Res, Options$6>>;
+  request: Interceptors$1<ReqInterceptor$1<Options$6>>;
+  response: Interceptors$1<ResInterceptor$1<Res, Options$6>>;
 }
 //#endregion
 //#region src/plugins/@hey-api/client-next/bundle/types.d.ts
-interface Config$3<T$1 extends ClientOptions$2 = ClientOptions$2> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config {
+interface Config$3<T extends ClientOptions$2 = ClientOptions$2> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config {
   /**
    * Base URL for all requests made by this client.
    */
-  baseUrl?: T$1['baseUrl'];
+  baseUrl?: T['baseUrl'];
   /**
    * Fetch API implementation. You can use this option to provide a custom
    * fetch instance.
@@ -561,11 +563,11 @@ interface Config$3<T$1 extends ClientOptions$2 = ClientOptions$2> extends Omit<R
    *
    * @default false
    */
-  throwOnError?: T$1['throwOnError'];
+  throwOnError?: T['throwOnError'];
 }
-interface RequestOptions$2<TData$1 = unknown, ThrowOnError$1 extends boolean = boolean, Url extends string = string> extends Config$3<{
-  throwOnError: ThrowOnError$1;
-}>, Pick<ServerSentEventsOptions<TData$1>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+interface RequestOptions$2<TData = unknown, ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$3<{
+  throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
   /**
    * Any body that you want to add to your request.
    *
@@ -580,18 +582,18 @@ interface RequestOptions$2<TData$1 = unknown, ThrowOnError$1 extends boolean = b
   security?: ReadonlyArray<Auth>;
   url: Url;
 }
-interface ResolvedRequestOptions$1<ThrowOnError$1 extends boolean = boolean, Url extends string = string> extends RequestOptions$2<unknown, ThrowOnError$1, Url> {
+interface ResolvedRequestOptions$1<ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions$2<unknown, ThrowOnError, Url> {
   serializedBody?: string;
 }
-type RequestResult$2<TData$1 = unknown, TError$1 = unknown, ThrowOnError$1 extends boolean = boolean> = ThrowOnError$1 extends true ? Promise<{
-  data: TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1;
+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<({
-  data: TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1;
+  data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
   error: undefined;
 } | {
   data: undefined;
-  error: TError$1 extends Record<string, unknown> ? TError$1[keyof TError$1] : TError$1;
+  error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
 }) & {
   response: Response;
 }>;
@@ -607,8 +609,8 @@ type BuildUrlFn$2 = <TData extends {
   path?: Record<string, unknown>;
   query?: Record<string, unknown>;
   url: string;
-}>(options: Pick<TData, 'url'> & Options$3<TData>) => string;
-type Client$4 = Client$8<RequestFn$2, Config$3, MethodFn$2, BuildUrlFn$2, SseFn$2> & {
+}>(options: TData & Options$2<TData>) => string;
+type Client$4 = Client$7<RequestFn$2, Config$3, MethodFn$2, BuildUrlFn$2, SseFn$2> & {
   interceptors: Middleware$1<Response, unknown, ResolvedRequestOptions$1>;
 };
 interface TDataShape$2 {
@@ -618,18 +620,18 @@ interface TDataShape$2 {
   query?: unknown;
   url: string;
 }
-type OmitKeys$2<T$1, K$1> = Pick<T$1, Exclude<keyof T$1, K$1>>;
-type Options$3<TData$1 extends TDataShape$2 = TDataShape$2, ThrowOnError$1 extends boolean = boolean, TResponse = unknown> = OmitKeys$2<RequestOptions$2<TResponse, ThrowOnError$1>, 'body' | 'path' | 'query' | 'url'> & Omit<TData$1, 'url'>;
+type OmitKeys$2<T, K$1> = Pick<T, Exclude<keyof T, K$1>>;
+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'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
 //#endregion
 //#region src/plugins/@hey-api/client-nuxt/bundle/types.d.ts
 type QuerySerializer = (query: Parameters<Client$5['buildUrl']>[0]['query']) => string;
-type WithRefs<TData$1> = { [K in keyof TData$1]: NonNullable<TData$1[K]> extends object ? WithRefs<NonNullable<TData$1[K]>> | Ref<NonNullable<TData$1[K]>> : NonNullable<TData$1[K]> | Ref<NonNullable<TData$1[K]>> };
-type KeysOf<T$1> = Array<T$1 extends T$1 ? (keyof T$1 extends string ? keyof T$1 : never) : never>;
-interface Config$2<T$1 extends ClientOptions$1 = ClientOptions$1> extends Omit<FetchOptions$1<unknown>, 'baseURL' | 'body' | 'headers' | 'method' | 'query'>, WithRefs<Pick<FetchOptions$1<unknown>, 'query'>>, Omit<Config, 'querySerializer'> {
+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$2<T extends ClientOptions$1 = ClientOptions$1> extends Omit<FetchOptions$1<unknown>, 'baseURL' | 'body' | 'headers' | 'method' | 'query'>, WithRefs<Pick<FetchOptions$1<unknown>, 'query'>>, Omit<Config, 'querySerializer'> {
   /**
    * Base URL for all requests made by this client.
    */
-  baseURL?: T$1['baseURL'];
+  baseURL?: T['baseURL'];
   /**
    * A function for serializing request query parameters. By default, arrays
    * will be exploded in form style, objects will be exploded in deepObject
@@ -639,7 +641,7 @@ interface Config$2<T$1 extends ClientOptions$1 = ClientOptions$1> extends Omit<F
    */
   querySerializer?: QuerySerializer | QuerySerializerOptions;
 }
-interface RequestOptions$1<TComposable$1 extends Composable = '$fetch', ResT$1 = unknown, DefaultT$1 = undefined, Url extends string = string> extends Config$2, WithRefs<{
+interface RequestOptions$1<TComposable extends Composable = '$fetch', ResT = unknown, DefaultT = undefined, Url extends string = string> extends Config$2, WithRefs<{
   /**
    * Any body that you want to add to your request.
    *
@@ -649,9 +651,9 @@ interface RequestOptions$1<TComposable$1 extends Composable = '$fetch', ResT$1 =
   path?: FetchOptions$1<unknown>['query'];
   query?: FetchOptions$1<unknown>['query'];
   rawBody?: unknown;
-}>, Pick<ServerSentEventsOptions<ResT$1>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
-  asyncDataOptions?: AsyncDataOptions<ResT$1, ResT$1, KeysOf<ResT$1>, DefaultT$1>;
-  composable?: TComposable$1;
+}>, Pick<ServerSentEventsOptions<ResT>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+  asyncDataOptions?: AsyncDataOptions<ResT, ResT, KeysOf<ResT>, DefaultT>;
+  composable?: TComposable;
   key?: string;
   /**
    * Security mechanism(s) to use for the request.
@@ -659,7 +661,7 @@ interface RequestOptions$1<TComposable$1 extends Composable = '$fetch', ResT$1 =
   security?: ReadonlyArray<Auth>;
   url: Url;
 }
-type RequestResult$1<TComposable$1 extends Composable, ResT$1, TError$1> = TComposable$1 extends '$fetch' ? ReturnType<typeof $fetch<ResT$1>> : TComposable$1 extends 'useAsyncData' ? ReturnType<typeof useAsyncData<ResT$1 | null, TError$1>> : TComposable$1 extends 'useFetch' ? ReturnType<typeof useFetch<ResT$1 | null, TError$1>> : TComposable$1 extends 'useLazyAsyncData' ? ReturnType<typeof useLazyAsyncData<ResT$1 | null, TError$1>> : TComposable$1 extends 'useLazyFetch' ? ReturnType<typeof useLazyFetch<ResT$1 | null, TError$1>> : never;
+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;
 }
@@ -682,18 +684,18 @@ interface TDataShape$1 {
   query?: FetchOptions$1<unknown>['query'];
   url: string;
 }
-type BuildUrlOptions<TData$1 extends Omit<TDataShape$1, 'headers'> = Omit<TDataShape$1, 'headers'>> = Pick<WithRefs<TData$1>, 'path' | 'query'> & Pick<TData$1, 'url'> & Pick<Options$2<'$fetch', TData$1>, 'baseURL' | 'querySerializer'>;
+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$5 = Client$8<RequestFn$1, Config$2, MethodFn$1, BuildUrlFn$1, SseFn$1>;
-type OmitKeys$1<T$1, K$1> = Pick<T$1, Exclude<keyof T$1, K$1>>;
-type Options$2<TComposable$1 extends Composable = '$fetch', TData$1 extends TDataShape$1 = TDataShape$1, ResT$1 = unknown, DefaultT$1 = undefined> = OmitKeys$1<RequestOptions$1<TComposable$1, ResT$1, DefaultT$1>, 'body' | 'path' | 'query' | 'url'> & WithRefs<Omit<TData$1, 'url'>>;
-type FetchOptions$1<TData$1> = Omit<UseFetchOptions<TData$1, TData$1>, keyof AsyncDataOptions<TData$1>>;
+type Client$5 = Client$7<RequestFn$1, Config$2, MethodFn$1, BuildUrlFn$1, SseFn$1>;
+type OmitKeys$1<T, K$1> = Pick<T, Exclude<keyof T, K$1>>;
+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'> & ([TData] extends [never] ? unknown : WithRefs<Omit<TData, 'url'>>);
+type FetchOptions$1<TData> = Omit<UseFetchOptions<TData, TData>, keyof AsyncDataOptions<TData>>;
 type Composable = '$fetch' | 'useAsyncData' | 'useFetch' | 'useLazyAsyncData' | 'useLazyFetch';
 //#endregion
 //#region src/plugins/@hey-api/client-ofetch/bundle/utils.d.ts
-type ErrInterceptor<Err$1, Res$1, Req$1, Options$7> = (error: Err$1, response: Res$1, request: Req$1, options: Options$7) => Err$1 | Promise<Err$1>;
-type ReqInterceptor<Req$1, Options$7> = (request: Req$1, options: Options$7) => Req$1 | Promise<Req$1>;
-type ResInterceptor<Res$1, Req$1, Options$7> = (response: Res$1, request: Req$1, options: Options$7) => Res$1 | Promise<Res$1>;
+type ErrInterceptor<Err, Res, Req, Options$6> = (error: Err, response: Res, request: Req, options: Options$6) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options$6> = (request: Req, options: Options$6) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options$6> = (response: Res, request: Req, options: Options$6) => Res | Promise<Res>;
 declare class Interceptors<Interceptor> {
   fns: Array<Interceptor | null>;
   clear(): void;
@@ -703,15 +705,15 @@ declare class Interceptors<Interceptor> {
   update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
   use(fn: Interceptor): number;
 }
-interface Middleware<Req$1, Res$1, Err$1, Options$7> {
-  error: Interceptors<ErrInterceptor<Err$1, Res$1, Req$1, Options$7>>;
-  request: Interceptors<ReqInterceptor<Req$1, Options$7>>;
-  response: Interceptors<ResInterceptor<Res$1, Req$1, Options$7>>;
+interface Middleware<Req, Res, Err, Options$6> {
+  error: Interceptors<ErrInterceptor<Err, Res, Req, Options$6>>;
+  request: Interceptors<ReqInterceptor<Req, Options$6>>;
+  response: Interceptors<ResInterceptor<Res, Req, Options$6>>;
 }
 //#endregion
 //#region src/plugins/@hey-api/client-ofetch/bundle/types.d.ts
 type ResponseStyle = 'data' | 'fields';
-interface Config$1<T$1 extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config {
+interface Config$1<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config {
   /**
    * HTTP(S) agent configuration (Node.js only). Passed through to ofetch.
    */
@@ -719,7 +721,7 @@ interface Config$1<T$1 extends ClientOptions = ClientOptions> extends Omit<Reque
   /**
    * Base URL for all requests made by this client.
    */
-  baseUrl?: T$1['baseUrl'];
+  baseUrl?: T['baseUrl'];
   /**
    * Node-only proxy/agent options.
    */
@@ -806,16 +808,16 @@ interface Config$1<T$1 extends ClientOptions = ClientOptions> extends Omit<Reque
    *
    * @default false
    */
-  throwOnError?: T$1['throwOnError'];
+  throwOnError?: T['throwOnError'];
   /**
    * Abort the request after the given milliseconds.
    */
   timeout?: number;
 }
-interface RequestOptions<TData$1 = unknown, TResponseStyle$1 extends ResponseStyle = 'fields', ThrowOnError$1 extends boolean = boolean, Url extends string = string> extends Config$1<{
-  responseStyle: TResponseStyle$1;
-  throwOnError: ThrowOnError$1;
-}>, Pick<ServerSentEventsOptions<TData$1>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$1<{
+  responseStyle: TResponseStyle;
+  throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
   /**
    * Any body that you want to add to your request.
    *
@@ -830,19 +832,19 @@ interface RequestOptions<TData$1 = unknown, TResponseStyle$1 extends ResponseSty
   security?: ReadonlyArray<Auth>;
   url: Url;
 }
-interface ResolvedRequestOptions<TResponseStyle$1 extends ResponseStyle = 'fields', ThrowOnError$1 extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle$1, ThrowOnError$1, 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$1 = unknown, TError$1 = unknown, ThrowOnError$1 extends boolean = boolean, TResponseStyle$1 extends ResponseStyle = 'fields'> = ThrowOnError$1 extends true ? Promise<TResponseStyle$1 extends 'data' ? TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1 : {
-  data: TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1;
+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$1 extends 'data' ? (TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1) | undefined : ({
-  data: TData$1 extends Record<string, unknown> ? TData$1[keyof TData$1] : TData$1;
+}> : 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$1 extends Record<string, unknown> ? TError$1[keyof TError$1] : TError$1;
+  error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
 }) & {
   request: Request;
   response: Response;
@@ -860,8 +862,8 @@ type BuildUrlFn = <TData extends {
   path?: Record<string, unknown>;
   query?: Record<string, unknown>;
   url: string;
-}>(options: Pick<TData, 'url'> & Options$1<TData>) => string;
-type Client$6 = Client$8<RequestFn, Config$1, MethodFn, BuildUrlFn, SseFn> & {
+}>(options: TData & Options<TData>) => string;
+type Client$6 = Client$7<RequestFn, Config$1, MethodFn, BuildUrlFn, SseFn> & {
   interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
 };
 interface TDataShape {
@@ -871,8 +873,8 @@ interface TDataShape {
   query?: unknown;
   url: string;
 }
-type OmitKeys<T$1, K$1> = Pick<T$1, Exclude<keyof T$1, K$1>>;
-type Options$1<TData$1 extends TDataShape = TDataShape, ThrowOnError$1 extends boolean = boolean, TResponse = unknown, TResponseStyle$1 extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle$1, ThrowOnError$1>, 'body' | 'path' | 'query' | 'url'> & Omit<TData$1, 'url'>;
+type OmitKeys<T, K$1> = Pick<T, Exclude<keyof T, K$1>>;
+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'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
 //#endregion
 //#region src/generate.d.ts
 /**
@@ -880,7 +882,7 @@ type Options$1<TData$1 extends TDataShape = TDataShape, ThrowOnError$1 extends b
  *
  * @param userConfig User provided {@link UserConfig} configuration(s).
  */
-declare const createClient: (userConfig?: LazyOrAsync<MaybeArray<UserConfig>>, logger?: Logger) => Promise<ReadonlyArray<Client$7 | IR.Context>>;
+declare const createClient: (userConfig?: LazyOrAsync<MaybeArray<UserConfig>>, logger?: Logger) => Promise<ReadonlyArray<Context>>;
 //#endregion
 //#region src/config/parser.d.ts
 declare const defaultPaginationKeywords: readonly ["after", "before", "cursor", "offset", "page", "start"];
@@ -917,6 +919,435 @@ declare const definePluginConfig: <T extends Plugin.Types>(defaultConfig: Plugin
    */
   name: any;
 };
+declare namespace types_d_exports {
+  export { AccessLevel, FunctionParameter, FunctionTypeParameter, ObjectValue, SyntaxKindKeyword, createAnonymousFunction, createArrayLiteralExpression, createArrowFunction, createAsExpression, createAssignment, createAwaitExpression, createBlock, createConditionalExpression, createEnumDeclaration, createForOfStatement, createFunctionTypeNode, createGetAccessorDeclaration, createIndexedAccessTypeNode, createKeywordTypeNode, createLiteralTypeNode, createMappedTypeNode, createNamespaceDeclaration, createNewExpression, createNull, createObjectType, createParameterDeclaration, createPropertyAccessChain, createPropertyAccessExpression, createPropertyAssignment, createRegularExpressionLiteral, createStringLiteral, createTemplateLiteralType, createTypeAliasDeclaration, createTypeNode, createTypeOfExpression, createTypeOperatorNode, createTypeParameterDeclaration, createTypeParenthesizedNode, createTypeReferenceNode, syntaxKindKeyword, toExpression, toParameterDeclarations, toTypeParameters };
+}
+type AccessLevel = 'private' | 'protected' | 'public';
+type FunctionParameter = {
+  accessLevel?: AccessLevel;
+  default?: any;
+  isReadOnly?: boolean;
+  isRequired?: boolean;
+  name: string;
+  type?: any | ts.TypeNode;
+} | {
+  destructure: ReadonlyArray<FunctionParameter>;
+  type?: any | ts.TypeNode;
+};
+interface FunctionTypeParameter {
+  default?: any;
+  extends?: string | ts.TypeNode;
+  name: string | ts.Identifier;
+}
+declare const createTypeNode: (base: any | ts.TypeNode, args?: (any | ts.TypeNode)[]) => ts.TypeNode;
+declare const createPropertyAccessChain: ({
+  expression,
+  name
+}: {
+  expression: ts.Expression;
+  name: string | ts.MemberName;
+}) => ts.PropertyAccessChain;
+declare const createPropertyAccessExpression: ({
+  expression,
+  isOptional,
+  name
+}: {
+  expression: string | ts.Expression;
+  isOptional?: boolean;
+  name: string | number | ts.MemberName;
+}) => ts.PropertyAccessChain | ts.PropertyAccessExpression | ts.ElementAccessExpression;
+declare const createNull: () => ts.NullLiteral;
+/**
+ * Convert an unknown value to an expression.
+ * @param identifiers - list of keys that are treated as identifiers.
+ * @param shorthand - if shorthand syntax is allowed.
+ * @param unescape - if string should be unescaped.
+ * @param value - the unknown value.
+ * @returns ts.Expression
+ */
+declare const toExpression: <T = unknown>({
+  identifiers,
+  isValueAccess,
+  shorthand,
+  unescape,
+  value
+}: {
+  identifiers?: string[];
+  isValueAccess?: boolean;
+  shorthand?: boolean;
+  unescape?: boolean;
+  value: T;
+}) => ts.Expression | undefined;
+/**
+ * Convert parameters to the declaration array expected by TypeScript
+ * Compiler API.
+ * @param parameters - the parameters to convert to declarations
+ * @returns ts.ParameterDeclaration[]
+ */
+declare const toParameterDeclarations: (parameters: ReadonlyArray<FunctionParameter>) => ts.ParameterDeclaration[];
+type SyntaxKindKeyword = 'any' | 'async' | 'boolean' | 'export' | 'never' | 'number' | 'private' | 'protected' | 'public' | 'readonly' | 'static' | 'string' | 'undefined' | 'unknown' | 'void';
+declare const syntaxKindKeyword: <T extends SyntaxKindKeyword>({
+  keyword
+}: {
+  keyword: T;
+}) => T extends "protected" ? ts.SyntaxKind.ProtectedKeyword : T extends "public" ? ts.SyntaxKind.PublicKeyword : T extends "private" ? ts.SyntaxKind.PrivateKeyword : T extends "export" ? ts.SyntaxKind.ExportKeyword : T extends "async" ? ts.SyntaxKind.ExportKeyword : T extends "readonly" ? ts.SyntaxKind.ExportKeyword : T extends "static" ? ts.SyntaxKind.ExportKeyword : ts.SyntaxKind.AnyKeyword | ts.SyntaxKind.BooleanKeyword | ts.SyntaxKind.NeverKeyword | ts.SyntaxKind.NumberKeyword | ts.SyntaxKind.StringKeyword | ts.SyntaxKind.UndefinedKeyword | ts.SyntaxKind.UnknownKeyword | ts.SyntaxKind.VoidKeyword;
+declare const createKeywordTypeNode: ({
+  keyword
+}: {
+  keyword: Extract<SyntaxKindKeyword, "any" | "boolean" | "never" | "number" | "string" | "undefined" | "unknown" | "void">;
+}) => ts.KeywordTypeNode<ts.SyntaxKind.VoidKeyword | ts.SyntaxKind.AnyKeyword | ts.SyntaxKind.BooleanKeyword | ts.SyntaxKind.NeverKeyword | ts.SyntaxKind.NumberKeyword | ts.SyntaxKind.StringKeyword | ts.SyntaxKind.UndefinedKeyword | ts.SyntaxKind.UnknownKeyword>;
+declare const toTypeParameters: (types: (FunctionTypeParameter | ts.TypeParameterDeclaration)[]) => ts.TypeParameterDeclaration[];
+declare const createTypeOperatorNode: ({
+  operator,
+  type
+}: {
+  operator: "keyof" | "readonly" | "unique";
+  type: ts.TypeNode;
+}) => ts.TypeOperatorNode;
+declare const createTypeParameterDeclaration: ({
+  constraint,
+  defaultType,
+  modifiers,
+  name
+}: {
+  constraint?: ts.TypeNode;
+  defaultType?: ts.TypeNode;
+  modifiers?: Array<ts.Modifier>;
+  name: string | ts.Identifier;
+}) => ts.TypeParameterDeclaration;
+declare const createMappedTypeNode: ({
+  members,
+  nameType,
+  questionToken,
+  readonlyToken,
+  type,
+  typeParameter
+}: {
+  members?: ts.NodeArray<ts.TypeElement>;
+  nameType?: ts.TypeNode;
+  questionToken?: ts.QuestionToken | ts.PlusToken | ts.MinusToken;
+  readonlyToken?: ts.ReadonlyKeyword | ts.PlusToken | ts.MinusToken;
+  type?: ts.TypeNode;
+  typeParameter: ts.TypeParameterDeclaration;
+}) => ts.MappedTypeNode;
+declare const createLiteralTypeNode: ({
+  literal
+}: {
+  literal: ts.LiteralTypeNode["literal"];
+}) => ts.LiteralTypeNode;
+/**
+ * Create arrow function type expression.
+ */
+declare const createArrowFunction: ({
+  async,
+  comment,
+  multiLine,
+  parameters,
+  returnType,
+  statements,
+  types
+}: {
+  async?: boolean;
+  comment?: Comments;
+  multiLine?: boolean;
+  parameters?: ReadonlyArray<FunctionParameter>;
+  returnType?: string | ts.TypeNode;
+  statements?: ts.Statement[] | ts.Expression;
+  types?: FunctionTypeParameter[];
+}) => ts.ArrowFunction;
+/**
+ * Create anonymous function type expression.
+ */
+declare const createAnonymousFunction: ({
+  async,
+  comment,
+  multiLine,
+  parameters,
+  returnType,
+  statements,
+  types
+}: {
+  async?: boolean;
+  comment?: Comments;
+  multiLine?: boolean;
+  parameters?: FunctionParameter[];
+  returnType?: string | ts.TypeNode;
+  statements?: ReadonlyArray<ts.Statement>;
+  types?: FunctionTypeParameter[];
+}) => ts.FunctionExpression;
+/**
+ * Create Array type expression.
+ */
+declare const createArrayLiteralExpression: <T>({
+  elements,
+  multiLine
+}: {
+  /**
+   * The array to create.
+   */
+  elements: T[];
+  /**
+   * Should the array be multi line?
+   *
+   * @default false
+   */
+  multiLine?: boolean;
+}) => ts.ArrayLiteralExpression;
+declare const createAwaitExpression: ({
+  expression
+}: {
+  expression: ts.Expression;
+}) => ts.AwaitExpression;
+declare const createFunctionTypeNode: ({
+  parameters,
+  returnType,
+  typeParameters
+}: {
+  parameters?: ts.ParameterDeclaration[];
+  returnType: ts.TypeNode;
+  typeParameters?: ts.TypeParameterDeclaration[];
+}) => ts.FunctionTypeNode;
+type ObjectValue = {
+  assertion?: 'any' | ts.TypeNode;
+  comments?: Comments;
+  spread: string;
+} | {
+  comments?: Comments;
+  isValueAccess?: boolean;
+  key: string;
+  shorthand?: boolean;
+  value: any;
+};
+/**
+ * Create Object type expression.
+ * @param comments - comments to add to each property.
+ * @param identifier - keys that should be treated as identifiers.
+ * @param multiLine - if the object should be multiline.
+ * @param obj - the object to create expression with.
+ * @param shorthand - if shorthand syntax should be used.
+ * @param unescape - if properties strings should be unescaped.
+ * @returns ts.ObjectLiteralExpression
+ */
+declare const createObjectType: <T extends Record<string, any> | Array<ObjectValue>>({
+  comments,
+  identifiers,
+  multiLine,
+  obj,
+  shorthand,
+  unescape
+}: {
+  comments?: Comments;
+  identifiers?: string[];
+  multiLine?: boolean;
+  obj: T;
+  shorthand?: boolean;
+  unescape?: boolean;
+}) => ts.ObjectLiteralExpression;
+/**
+ * Create enum declaration. Example `export enum T = { X, Y };`
+ * @param asConst - whether to use const enums.
+ * @param comments - comments to add to each property.
+ * @param leadingComment - leading comment to add to enum.
+ * @param name - the name of the enum.
+ * @param obj - the object representing the enum.
+ * @returns ts.EnumDeclaration
+ */
+declare const createEnumDeclaration: <T extends Record<string, any> | Array<ObjectValue>>({
+  asConst,
+  comments: enumMemberComments,
+  leadingComment: comments,
+  name,
+  obj
+}: {
+  asConst: boolean;
+  comments?: Record<string | number, Comments>;
+  leadingComment?: Comments;
+  name: string | ts.TypeReferenceNode;
+  obj: T;
+}) => ts.EnumDeclaration;
+/**
+ * Create namespace declaration. Example `export namespace MyNamespace { ... }`
+ * @param name - the name of the namespace.
+ * @param nodes - the nodes in the namespace.
+ * @returns
+ */
+declare const createNamespaceDeclaration: ({
+  name,
+  statements
+}: {
+  name: string;
+  statements: Array<ts.Statement>;
+}) => ts.ModuleDeclaration;
+declare const createIndexedAccessTypeNode: ({
+  indexType,
+  objectType
+}: {
+  indexType: ts.TypeNode;
+  objectType: ts.TypeNode;
+}) => ts.IndexedAccessTypeNode;
+declare const createGetAccessorDeclaration: ({
+  modifiers,
+  name,
+  returnType,
+  statements
+}: {
+  modifiers?: Modifier | ReadonlyArray<Modifier>;
+  name: string | ts.PropertyName;
+  returnType?: string | ts.Identifier;
+  statements: ReadonlyArray<ts.Statement>;
+}) => ts.GetAccessorDeclaration;
+declare const createStringLiteral: ({
+  isSingleQuote,
+  text
+}: {
+  isSingleQuote?: boolean;
+  text: string;
+}) => ts.StringLiteral;
+declare const createConditionalExpression: ({
+  condition,
+  whenFalse,
+  whenTrue
+}: {
+  condition: ts.Expression;
+  whenFalse: ts.Expression;
+  whenTrue: ts.Expression;
+}) => ts.ConditionalExpression;
+declare const createTypeOfExpression: ({
+  text
+}: {
+  text: string | ts.Identifier;
+}) => ts.TypeOfExpression;
+/**
+ * Create a type alias declaration. Example `export type X = Y;`.
+ * @param comment (optional) comments to add
+ * @param name the name of the type
+ * @param type the type
+ * @returns ts.TypeAliasDeclaration
+ */
+declare const createTypeAliasDeclaration: ({
+  comment,
+  exportType,
+  name,
+  type,
+  typeParameters
+}: {
+  comment?: Comments;
+  exportType?: boolean;
+  name: string | ts.TypeReferenceNode;
+  type: string | ts.TypeNode | ts.Identifier;
+  typeParameters?: FunctionTypeParameter[];
+}) => ts.TypeAliasDeclaration;
+declare const createTypeReferenceNode: ({
+  typeArguments,
+  typeName
+}: {
+  typeArguments?: ts.TypeNode[];
+  typeName: string | ts.EntityName;
+}) => ts.TypeReferenceNode;
+declare const createTypeParenthesizedNode: ({
+  type
+}: {
+  type: ts.TypeNode;
+}) => ts.ParenthesizedTypeNode;
+declare const createParameterDeclaration: ({
+  initializer,
+  modifiers,
+  name,
+  required,
+  type
+}: {
+  initializer?: ts.Expression;
+  modifiers?: ReadonlyArray<ts.ModifierLike>;
+  name: string | ts.BindingName;
+  required?: boolean;
+  type?: ts.TypeNode;
+}) => ts.ParameterDeclaration;
+declare const createNewExpression: ({
+  argumentsArray,
+  expression,
+  typeArguments
+}: {
+  argumentsArray?: Array<ts.Expression>;
+  expression: ts.Expression;
+  typeArguments?: Array<ts.TypeNode>;
+}) => ts.NewExpression;
+declare const createForOfStatement: ({
+  awaitModifier,
+  expression,
+  initializer,
+  statement
+}: {
+  awaitModifier?: ts.AwaitKeyword;
+  expression: ts.Expression;
+  initializer: ts.ForInitializer;
+  statement: ts.Statement;
+}) => ts.ForOfStatement;
+declare const createAssignment: ({
+  left,
+  right
+}: {
+  left: ts.Expression;
+  right: ts.Expression;
+}) => ts.AssignmentExpression<ts.EqualsToken>;
+declare const createBlock: ({
+  multiLine,
+  statements
+}: {
+  multiLine?: boolean;
+  statements: ReadonlyArray<ts.Statement>;
+}) => ts.Block;
+declare const createPropertyAssignment: ({
+  initializer,
+  name
+}: {
+  initializer: ts.Expression;
+  name: string | ts.PropertyName;
+}) => ts.PropertyAssignment;
+declare const createRegularExpressionLiteral: ({
+  flags,
+  text
+}: {
+  flags?: ReadonlyArray<"g" | "i" | "m" | "s" | "u" | "y">;
+  text: string;
+}) => ts.RegularExpressionLiteral;
+declare const createAsExpression: ({
+  expression,
+  type
+}: {
+  expression: ts.Expression;
+  type: ts.TypeNode;
+}) => ts.AsExpression;
+declare const createTemplateLiteralType: ({
+  value
+}: {
+  value: ReadonlyArray<string | ts.TypeNode>;
+}) => ts.TemplateLiteralTypeNode;
+//#endregion
+//#region src/tsc/utils.d.ts
+interface ImportExportItemObject<Name extends string | undefined = string | undefined, Alias extends string | undefined = undefined> {
+  alias?: Alias;
+  asType?: boolean;
+  name: Name;
+}
+/**
+ * Print a TypeScript node to a string.
+ * @param node the node to print
+ * @returns string
+ */
+declare function tsNodeToString({
+  node,
+  unescape
+}: {
+  node: ts.Node;
+  unescape?: boolean;
+}): string;
+type Modifier = AccessLevel | 'async' | 'export' | 'readonly' | 'static';
+type CommentLines = Array<string | null | false | undefined>;
+type CommentObject = {
+  jsdoc?: boolean;
+  lines: CommentLines;
+};
+type Comments = CommentLines | Array<CommentObject>;
 declare namespace module_d_exports {
   export { ImportExportItem, createCallExpression, createConstVariable, createExportAllDeclaration, createNamedExportDeclarations, createNamedImportDeclarations };
 }
@@ -1199,10 +1630,12 @@ declare const tsc: {
     typeParameters?: typescript0.TypeParameterDeclaration[];
   }) => typescript0.FunctionTypeNode;
   getAccessorDeclaration: ({
+    modifiers,
     name,
     returnType,
     statements
   }: {
+    modifiers?: Modifier | ReadonlyArray<Modifier>;
     name: string | typescript0.PropertyName;
     returnType?: string | typescript0.Identifier;
     statements: ReadonlyArray<typescript0.Statement>;
@@ -1371,7 +1804,7 @@ declare const tsc: {
     type
   }: {
     initializer?: typescript0.Expression;
-    modifier?: "async" | AccessLevel | "export" | "readonly" | "static";
+    modifier?: Modifier;
     name: string | typescript0.PropertyName;
     type?: typescript0.TypeNode;
   }) => typescript0.PropertyDeclaration;
@@ -1740,10 +2173,12 @@ declare const compiler: {
     typeParameters?: typescript0.TypeParameterDeclaration[];
   }) => typescript0.FunctionTypeNode;
   getAccessorDeclaration: ({
+    modifiers,
     name,
     returnType,
     statements
   }: {
+    modifiers?: Modifier | ReadonlyArray<Modifier>;
     name: string | typescript0.PropertyName;
     returnType?: string | typescript0.Identifier;
     statements: ReadonlyArray<typescript0.Statement>;
@@ -1912,7 +2347,7 @@ declare const compiler: {
     type
   }: {
     initializer?: typescript0.Expression;
-    modifier?: "async" | AccessLevel | "export" | "readonly" | "static";
+    modifier?: Modifier;
     name: string | typescript0.PropertyName;
     type?: typescript0.TypeNode;
   }) => typescript0.PropertyDeclaration;
@@ -2138,5 +2573,5 @@ declare module '@hey-api/codegen-core' {
  */
 declare const defineConfig: <T extends MaybeArray<UserConfig>>(config: LazyOrAsync<T>) => Promise<T>;
 //#endregion
-export { type Client as AngularClient, type Client$1 as AxiosClient, type Client$2 as Client, type DefinePlugin, type ExpressionTransformer, type Client$3 as FetchClient, type IR, type LegacyIR, Logger, type Client$4 as NextClient, type Client$5 as NuxtClient, type Client$6 as OfetchClient, type OpenApi, type OpenApiMetaObject, type OpenApiOperationObject, type OpenApiParameterObject, type OpenApiRequestBodyObject, type OpenApiResponseObject, type OpenApiSchemaObject, type Operation, type Plugin, type TypeTransformer, type UserConfig, clientDefaultConfig, clientDefaultMeta, clientPluginHandler, compiler, createClient, defaultPaginationKeywords, defaultPlugins, defineConfig, definePluginConfig, tsc, utils };
+export { type Client as AngularClient, type Client$1 as AxiosClient, type Client$2 as Client, type DefinePlugin, type ExpressionTransformer, type Client$3 as FetchClient, type IR, Logger, type Client$4 as NextClient, type Client$5 as NuxtClient, type Client$6 as OfetchClient, type OpenApi, type OpenApiMetaObject, type OpenApiOperationObject, type OpenApiParameterObject, type OpenApiRequestBodyObject, type OpenApiResponseObject, type OpenApiSchemaObject, type Plugin, type TypeTransformer, type UserConfig, clientDefaultConfig, clientDefaultMeta, clientPluginHandler, compiler, createClient, defaultPaginationKeywords, defaultPlugins, defineConfig, definePluginConfig, tsc, utils };
 //# sourceMappingURL=index.d.cts.map