@hey-api/openapi-ts 0.86.11 → 0.87.0

package/dist/{types-Bxdq98WE.d.cts → config-oAoGatJ7.d.ts}

@@ -1,11 +1,13 @@
 import { IProject, Project, Symbol, SymbolIdentifier, SymbolIn, SymbolMeta } from "@hey-api/codegen-core";
-import fs from "node:fs";
 import ts from "typescript";
 import { RangeOptions, SemVer } from "semver";
+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";
 
-//#region rolldown:runtime
-
-//#endregion
 //#region src/plugins/shared/types/refs.d.ts
 /**
  * Ref wrapper which ensures a stable reference for a value.
@@ -17,8 +19,8 @@ import { RangeOptions, SemVer } from "semver";
  * console.log(num.value); // 42
  * ```
  */
-type Ref<T$1> = {
-  value: T$1;
+type Ref$1<T> = {
+  value: T;
 };
 
 /**
@@ -41,7 +43,7 @@ type Ref<T$1> = {
  * console.log(refs.a.value, refs.b.value); // 1 'x'
  * ```
  */
-type ToRefs<T$1> = { [K in keyof T$1]: Ref<T$1[K]> };
+type ToRefs<T> = { [K in keyof T]: Ref$1<T[K]> };
 //#endregion
 //#region src/openApi/shared/types/openapi-spec-extensions.d.ts
 interface EnumExtensions {
@@ -58,514 +60,16 @@ interface EnumExtensions {
    */
   'x-enumNames'?: ReadonlyArray<string>;
 }
-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: ({
-  name,
-  returnType,
-  statements
-}: {
-  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$1 extends string | undefined = string | undefined, Alias$1 extends string | undefined = undefined> {
-  alias?: Alias$1;
-  asType?: boolean;
-  name: Name$1;
-}
-/**
- * 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 CommentLines = Array<string | null | false | undefined>;
-type CommentObject = {
-  jsdoc?: boolean;
-  lines: CommentLines;
-};
-type Comments = CommentLines | Array<CommentObject>;
-//#endregion
-//#region src/generate/file.d.ts
-type FileImportResult<Name$1 extends string | undefined = string | undefined, Alias$1 extends string | undefined = undefined> = {
-  asType?: boolean;
-  name: Alias$1 extends string ? Alias$1 : Name$1;
-};
-/**
- * TODO: remove, it's used by legacy plugins
- *
- * @deprecated
- */
-declare class GeneratedFile {
-  /**
-   * Should the exports from this file be re-exported in the index barrel file?
-   */
-  private _exportFromIndex;
-  private _headers;
-  private _id;
-  private _imports;
-  private _items;
-  private _name;
-  private _path;
-  constructor({
-    dir,
-    exportFromIndex,
-    header,
-    id,
-    name
-  }: {
-    dir: string;
-    /**
-     * Should the exports from this file be re-exported in the index barrel file?
-     */
-    exportFromIndex?: boolean;
-    header?: boolean;
-    /**
-     * Unique file ID. Used to generate correct relative paths to the file.
-     * This should be refactored later as it's basically the file name unless
-     * nested inside another folder.
-     */
-    id: string;
-    name: string;
-  });
-  add(...nodes: Array<ts.Node | string>): void;
-  get exportFromIndex(): boolean;
-  get id(): string;
-  /**
-   * Adds an import to the provided module. Handles duplication, returns added
-   * import. Returns the imported name. If we import an aliased export, `name`
-   * will be equal to the specified `alias`.
-   */
-  import<Name extends string | undefined = string | undefined, Alias extends string | undefined = undefined>({
-    module,
-    ...importedItem
-  }: ImportExportItemObject<Name, Alias> & {
-    module: string;
-  }): FileImportResult<Name, Alias>;
-  isEmpty(): boolean;
-  nameWithoutExtension(): string;
-  remove(options?: Parameters<typeof fs.rmSync>[1]): void;
-  /**
-   * Removes last node form the stack. Works as undo.
-   *
-   * @deprecated
-   */
-  removeNode_LEGACY(): void;
-  private _setName;
-  private _toString;
-  write(separator?: string, tsConfig?: ts.ParsedCommandLine | null): void;
-}
 //#endregion
 //#region src/types/utils.d.ts
-/** @deprecated */
-type Files = Record<string, GeneratedFile>;
 /**
  * Accepts a value, a function returning a value, or a function returning a promise of a value.
  */
-type LazyOrAsync<T$1> = T$1 | (() => T$1) | (() => Promise<T$1>);
+type LazyOrAsync<T> = T | (() => T) | (() => Promise<T>);
 /**
  * Accepts a value or a readonly array of values of type T.
  */
-type MaybeArray<T$1> = T$1 | ReadonlyArray<T$1>;
+type MaybeArray<T> = T | ReadonlyArray<T>;
 //#endregion
 //#region src/openApi/3.1.x/types/spec.d.ts
 /**
@@ -605,7 +109,7 @@ interface OpenApiV3_1_X {
   /**
    * An array of Server Objects, which provide connectivity information to a target server. If the `servers` property is not provided, or is an empty array, the default value would be a {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#server-object Server Object} with a {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#serverUrl url} value of `/`.
    */
-  servers?: ReadonlyArray<ServerObject>;
+  servers?: ReadonlyArray<ServerObject$1>;
   /**
    * A list of tags used by the document with additional metadata. The order of the tags can be used to reflect on their order by the parsing tools. Not all tags that are used by the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#operation-object Operation Object} must be declared. The tags that are not declared MAY be organized randomly or based on the tools' logic. Each tag name in the list MUST be unique.
    */
@@ -831,7 +335,7 @@ interface ComponentsObject$1 {
   /**
    * An object to hold reusable {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#security-scheme-object Security Scheme Objects}.
    */
-  securitySchemes?: Record<string, SecuritySchemeObject | ReferenceObject$1>;
+  securitySchemes?: Record<string, SecuritySchemeObject$2 | ReferenceObject$1>;
 }
 /**
  * Contact information for the exposed API.
@@ -1425,7 +929,7 @@ interface LinkObject$1 {
   /**
    * A server object to be used by the target operation.
    */
-  server?: ServerObject;
+  server?: ServerObject$1;
 }
 /**
  * Each Media Type Object provides schema and examples for the media type identified by its key.
@@ -1460,7 +964,7 @@ interface LinkObject$1 {
  *       $ref: "#/components/examples/frog-example"
  * ```
  */
-interface MediaTypeObject$2 {
+interface MediaTypeObject$1 {
   /**
    * A map between a property name and its encoding information. The key, being the property name, MUST exist in the schema as a property. The encoding object SHALL only apply to `requestBody` objects when the media type is `multipart` or `application/x-www-form-urlencoded`.
    */
@@ -1631,7 +1135,7 @@ interface OperationObject {
   /**
    * An alternative `server` array to service this operation. If an alternative `server` object is specified at the Path Item Object or Root level, it will be overridden by this value.
    */
-  servers?: ReadonlyArray<ServerObject>;
+  servers?: ReadonlyArray<ServerObject$1>;
   /**
    * A short summary of what the operation does.
    */
@@ -1750,7 +1254,7 @@ interface ParameterObject {
   /**
    * A map containing the representations for the parameter. The key is the media type and the value describes it. The map MUST only contain one entry.
    */
-  content?: Record<string, MediaTypeObject$2>;
+  content?: Record<string, MediaTypeObject$1>;
   /**
    * Specifies that a parameter is deprecated and SHOULD be transitioned out of usage. Default value is `false`.
    */
@@ -1877,7 +1381,7 @@ interface PathItemObject$2 {
   /**
    * An alternative `server` array to service all operations in this path.
    */
-  servers?: ReadonlyArray<ServerObject>;
+  servers?: ReadonlyArray<ServerObject$1>;
   /**
    * An optional, string summary, intended to apply to all operations in this path.
    */
@@ -2039,7 +1543,7 @@ interface RequestBodyObject {
   /**
    * **REQUIRED**. The content of the request body. The key is a media type or {@link https://tools.ietf.org/html/rfc7231#appendix-D media type range} and the value describes it. For requests that match multiple keys, only the most specific key is applicable. e.g. text/plain overrides text/*
    */
-  content: Record<string, MediaTypeObject$2>;
+  content: Record<string, MediaTypeObject$1>;
   /**
    * A brief description of the request body. This could contain examples of use. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -2114,7 +1618,7 @@ interface ResponseObject {
   /**
    * A map containing descriptions of potential response payloads. The key is a media type or {@link https://datatracker.ietf.org/doc/html/rfc7231#appendix-D media type range} and the value describes it. For responses that match multiple keys, only the most specific key is applicable. e.g. text/plain overrides text/*
    */
-  content?: Record<string, MediaTypeObject$2>;
+  content?: Record<string, MediaTypeObject$1>;
   /**
    * **REQUIRED**. A description of the response. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -2276,7 +1780,7 @@ interface SecurityRequirementObject$2 {
  *       read:pets: read your pets
  * ```
  */
-type SecuritySchemeObject = {
+type SecuritySchemeObject$2 = {
   /**
    * A description for security scheme. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -2342,7 +1846,7 @@ type SecuritySchemeObject = {
  * description: Development server
  * ```
  */
-interface ServerObject {
+interface ServerObject$1 {
   /**
    * An optional string describing the host designated by the URL. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -2960,101 +2464,300 @@ interface StringKeywords {
 type JsonSchemaFormats$2 = 'date' | 'date-time' | 'duration' | 'email' | 'hostname' | 'idn-email' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'iri' | 'iri-reference' | 'json-pointer' | 'regex' | 'relative-json-pointer' | 'time' | 'uri' | 'uri-reference' | 'uri-template' | 'uuid' | (string & {});
 type JsonSchemaTypes$1 = 'array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string';
 //#endregion
-//#region src/config/utils/package.d.ts
-type Package = {
+//#region src/ir/mediaType.d.ts
+type IRMediaType = 'form-data' | 'json' | 'text' | 'url-search-params' | 'octet-stream';
+//#endregion
+//#region src/ir/types.d.ts
+interface IRBodyObject {
+  mediaType: string;
   /**
-   * Get the installed version of a package.
-   * @param name The name of the package to get the version for.
-   * @returns A SemVer object containing version information, or undefined if the package is not installed
-   *         or the version string is invalid.
+   * Does body control pagination? We handle only simple values
+   * for now, up to 1 nested field.
    */
-  getVersion: (name: string) => SemVer | undefined;
+  pagination?: boolean | string;
+  required?: boolean;
+  schema: IRSchemaObject;
+  type?: IRMediaType;
+}
+interface IRComponentsObject {
+  parameters?: Record<string, IRParameterObject>;
+  requestBodies?: Record<string, IRRequestBodyObject>;
+  schemas?: Record<string, IRSchemaObject>;
+}
+interface IROperationObject {
+  body?: IRBodyObject;
+  deprecated?: boolean;
+  description?: string;
+  id: string;
+  method: keyof IRPathItemObject;
+  operationId?: string;
+  parameters?: IRParametersObject;
+  path: keyof IRPathsObject;
+  responses?: IRResponsesObject;
+  security?: ReadonlyArray<IRSecurityObject>;
+  servers?: ReadonlyArray<IRServerObject>;
+  summary?: string;
+  tags?: ReadonlyArray<string>;
+}
+interface IRParametersObject {
+  cookie?: Record<string, IRParameterObject>;
+  header?: Record<string, IRParameterObject>;
+  path?: Record<string, IRParameterObject>;
+  query?: Record<string, IRParameterObject>;
+}
+interface IRParameterObject extends Pick<JsonSchemaDraft2020_12, 'deprecated' | 'description'> {
   /**
-   * Check if a given package is installed in the project.
-   * @param name The name of the package to check.
+   * Determines whether the parameter value SHOULD allow reserved characters, as defined by RFC3986 `:/?#[]@!$&'()*+,;=` to be included without percent-encoding. The default value is `false`. This property SHALL be ignored if the request body media type is not `application/x-www-form-urlencoded` or `multipart/form-data`. If a value is explicitly defined, then the value of `contentType` (implicit or explicit) SHALL be ignored.
    */
-  isInstalled: (name: string) => boolean;
+  allowReserved?: boolean;
   /**
-   * Check if the installed version of a package or a given SemVer object satisfies a semver range.
-   * @param nameOrVersion The name of the package to check, or a SemVer object.
-   * @param range The semver range to check against.
-   * @returns True if the version satisfies the range, false otherwise.
+   * When this is true, property values of type `array` or `object` generate separate parameters for each value of the array, or key-value-pair of the map. For other types of properties this property has no effect. When `style` is `form`, the default value is `true`. For all other styles, the default value is `false`. This property SHALL be ignored if the request body media type is not `application/x-www-form-urlencoded` or `multipart/form-data`. If a value is explicitly defined, then the value of `contentType` (implicit or explicit) SHALL be ignored.
    */
-  satisfies: (nameOrVersion: string | SemVer, range: string, optionsOrLoose?: boolean | RangeOptions) => boolean;
-};
-//#endregion
-//#region src/graph/types/graph.d.ts
-/**
- * The main graph structure for OpenAPI node analysis.
- *
- * @property nodeDependencies - For each node with at least one dependency, the set of normalized JSON Pointers it references via $ref. Nodes with no dependencies are omitted.
- * @property nodes - Map from normalized JSON Pointer to NodeInfo for every node in the spec.
- * @property reverseNodeDependencies - For each node with at least one dependent, the set of nodes that reference it via $ref. Nodes with no dependents are omitted.
- */
-type Graph = {
+  explode: boolean;
   /**
-   * For each node with at least one dependency, the set of normalized JSON Pointers it references via $ref.
-   * Nodes with no dependencies are omitted from this map.
+   * Endpoint parameters must specify their location.
    */
-  nodeDependencies: Map<string, Set<string>>;
+  location: 'cookie' | 'header' | 'path' | 'query';
+  name: string;
   /**
-   * Map from normalized JSON Pointer to NodeInfo for every node in the spec.
+   * Does this parameter control pagination? We handle only simple values
+   * for now, up to 1 nested field.
    */
-  nodes: Map<string, NodeInfo>;
+  pagination?: boolean | string;
+  required?: boolean;
+  schema: IRSchemaObject;
   /**
-   * For each node with at least one dependent, the set of nodes that reference it via $ref.
-   * Nodes with no dependents are omitted from this map.
+   * Describes how the parameter value will be serialized depending on the type of the parameter value. Default values (based on value of `in`): for `query` - `form`; for `path` - `simple`; for `header` - `simple`; for `cookie` - `form`.
    */
-  reverseNodeDependencies: Map<string, Set<string>>;
+  style: 'deepObject' | 'form' | 'label' | 'matrix' | 'pipeDelimited' | 'simple' | 'spaceDelimited';
+}
+interface IRPathsObject {
+  [path: `/${string}`]: IRPathItemObject;
+}
+interface IRPathItemObject {
+  delete?: IROperationObject;
+  get?: IROperationObject;
+  head?: IROperationObject;
+  options?: IROperationObject;
+  patch?: IROperationObject;
+  post?: IROperationObject;
+  put?: IROperationObject;
+  trace?: IROperationObject;
+}
+interface IRRequestBodyObject extends Pick<JsonSchemaDraft2020_12, 'description'> {
+  required?: boolean;
+  schema: IRSchemaObject;
+}
+interface IRResponsesObject {
   /**
-   * For each node, the set of direct $ref targets that appear anywhere inside the node's
-   * subtree (the node itself and its children). This is populated during graph construction
-   * and is used to compute top-level dependency relationships where $ref may be attached to
-   * child pointers instead of the parent.
+   * Any {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#http-status-codes HTTP status code} can be used as the property name, but only one property per code, to describe the expected response for that HTTP status code. This field MUST be enclosed in quotation marks (for example, "200") for compatibility between JSON and YAML. To define a range of response codes, this field MAY contain the uppercase wildcard character `X`. For example, `2XX` represents all response codes between `[200-299]`. Only the following range definitions are allowed: `1XX`, `2XX`, `3XX`, `4XX`, and `5XX`. If a response is defined using an explicit code, the explicit code definition takes precedence over the range definition for that code.
    */
-  subtreeDependencies: Map<string, Set<string>>;
+  [statusCode: string]: IRResponseObject | undefined;
   /**
-   * For each node, the set of all (transitive) normalized JSON Pointers it references via $ref anywhere in its subtree.
-   * This includes both direct and indirect dependencies, making it useful for filtering, codegen, and tree-shaking.
+   * The documentation of responses other than the ones declared for specific HTTP response codes. Use this field to cover undeclared responses.
    */
-  transitiveDependencies: Map<string, Set<string>>;
-};
-/**
- * Information about a node in the OpenAPI graph.
- *
- * @property deprecated - Whether the node is deprecated. Optional.
- * @property key - The property name or array index in the parent, or null for root.
- * @property node - The actual object at this pointer in the spec.
- * @property parentPointer - The JSON Pointer of the parent node, or null for root.
- * @property scopes - The set of access scopes for this node, if any. Optional.
- * @property tags - The set of tags for this node, if any. Optional.
- */
-type NodeInfo = {
-  /** Whether the node is deprecated. Optional. */
-  deprecated?: boolean;
-  /** The property name or array index in the parent, or null for root. */
-  key: string | number | null;
-  /** The actual object at this pointer in the spec.  */
-  node: unknown;
-  /** The JSON Pointer of the parent node, or null for root. */
-  parentPointer: string | null;
-  /** The set of access scopes for this node, if any. Optional. */
-  scopes?: Set<Scope>;
-  /** The set of tags for this node, if any. Optional. */
-  tags?: Set<string>;
-};
-//#endregion
-//#region src/graph/types/walk.d.ts
-type GetPointerPriorityFn = (pointer: string) => number;
-type MatchPointerToGroupFn<T$1 extends string = string> = (pointer: string, kind?: T$1) => PointerGroupMatch<T$1>;
-type PointerGroupMatch<T$1 extends string = string> = {
-  kind: T$1;
+  default?: IRResponseObject;
+}
+interface IRResponseObject {
+  // TODO: parser - handle headers, links, and possibly other media types?
+  mediaType?: string;
+  schema: IRSchemaObject;
+}
+interface IRSchemaObject extends Pick<JsonSchemaDraft2020_12, '$ref' | 'const' | 'default' | 'deprecated' | 'description' | 'exclusiveMaximum' | 'exclusiveMinimum' | 'maximum' | 'maxItems' | 'maxLength' | 'minimum' | 'minItems' | 'minLength' | 'pattern' | 'required' | 'title' | 'example'> {
+  /**
+   * If the schema is intended to be used as an object property, it can be
+   * marked as read-only or write-only. This value controls whether the schema
+   * receives the "readonly" TypeScript keyword.
+   */
+  accessScope?: 'read' | 'write';
+  /**
+   * If type is `object`, `additionalProperties` can be used to either define
+   * a schema for properties not included in `properties` or disallow such
+   * properties altogether.
+   */
+  additionalProperties?: IRSchemaObject | false;
+  /**
+   * Any string value is accepted as `format`.
+   */
+  format?: JsonSchemaDraft2020_12['format'] | 'binary' | 'integer';
+  /**
+   * If schema resolves into multiple items instead of a simple `type`, they
+   * will be included in `items` array.
+   */
+  items?: ReadonlyArray<IRSchemaObject>;
+  /**
+   * When resolving a list of items, we need to know the relationship between
+   * them. `logicalOperator` specifies this logical relationship.
+   *
+   * @default 'or'
+   */
+  logicalOperator?: 'and' | 'or';
+  /**
+   * When type is `object`, `patternProperties` can be used to define a schema
+   * for properties that match a specific regex pattern.
+   */
+  patternProperties?: Record<string, IRSchemaObject>;
+  /**
+   * When type is `object`, `properties` will contain a map of its properties.
+   */
+  properties?: Record<string, IRSchemaObject>;
+  /**
+   * The names of `properties` can be validated against a schema, irrespective
+   * of their values. This can be useful if you don't want to enforce specific
+   * properties, but you want to make sure that the names of those properties
+   * follow a specific convention.
+   */
+  propertyNames?: IRSchemaObject;
+  /**
+   * Each schema eventually resolves into `type`.
+   */
+  type?: 'array' | 'boolean' | 'enum' | 'integer' | 'never' | 'null' | 'number' | 'object' | 'string' | 'tuple' | 'undefined' | 'unknown' | 'void';
+}
+type IRSecurityObject = SecuritySchemeObject$2;
+type IRServerObject = ServerObject$1;
+type IRWebhookObject = IRPathItemObject;
+interface IRModel {
+  components?: IRComponentsObject;
+  paths?: IRPathsObject;
+  servers?: ReadonlyArray<IRServerObject>;
+  webhooks?: Record<string, IRWebhookObject>;
+}
+declare namespace IR$1 {
+  export type BodyObject = IRBodyObject;
+  export type ComponentsObject = IRComponentsObject;
+  export type Model = IRModel;
+  export type OperationObject = IROperationObject;
+  export type ParameterObject = IRParameterObject;
+  export type ParametersObject = IRParametersObject;
+  export type PathItemObject = IRPathItemObject;
+  export type PathsObject = IRPathsObject;
+  export type ReferenceObject = ReferenceObject;
+  export type RequestBodyObject = IRRequestBodyObject;
+  export type ResponseObject = IRResponseObject;
+  export type ResponsesObject = IRResponsesObject;
+  export type SchemaObject = IRSchemaObject;
+  export type SecurityObject = IRSecurityObject;
+  export type ServerObject = IRServerObject;
+  export type WebhookObject = IRWebhookObject;
+}
+//#endregion
+//#region src/config/utils/config.d.ts
+type ObjectType<T> = Extract<T, Record<string, any>> extends never ? Record<string, any> : Extract<T, Record<string, any>>;
+type NotArray<T> = T extends any[] ? never : T;
+type NotFunction<T> = T extends ((...args: any[]) => any) ? never : T;
+type PlainObject<T> = T extends object ? NotFunction<T> extends never ? never : NotArray<T> extends never ? never : T : never;
+type MappersType<T> = {
+  boolean: T extends boolean ? (value: boolean) => Partial<ObjectType<T>> : never;
+  function: T extends ((...args: any[]) => any) ? (value: (...args: any[]) => any) => Partial<ObjectType<T>> : never;
+  number: T extends number ? (value: number) => Partial<ObjectType<T>> : never;
+  object?: PlainObject<T> extends never ? never : (value: Partial<PlainObject<T>>, defaultValue: PlainObject<T>) => Partial<ObjectType<T>>;
+  string: T extends string ? (value: string) => Partial<ObjectType<T>> : never;
+} extends infer U ? { [K in keyof U as U[K] extends never ? never : K]: U[K] } : never;
+type IsObjectOnly<T> = T extends Record<string, any> | undefined ? Extract<T, string | boolean | number | ((...args: any[]) => any)> extends never ? true : false : false;
+type ValueToObject = <T extends undefined | string | boolean | number | ((...args: any[]) => any) | Record<string, any>>(args: {
+  defaultValue: ObjectType<T>;
+  value: T;
+} & (IsObjectOnly<T> extends true ? {
+  mappers?: MappersType<T>;
+} : {
+  mappers: MappersType<T>;
+})) => PlainObject<T>;
+//#endregion
+//#region src/config/utils/package.d.ts
+type Package = {
+  /**
+   * Get the installed version of a package.
+   * @param name The name of the package to get the version for.
+   * @returns A SemVer object containing version information, or undefined if the package is not installed
+   *         or the version string is invalid.
+   */
+  getVersion: (name: string) => SemVer | undefined;
+  /**
+   * Check if a given package is installed in the project.
+   * @param name The name of the package to check.
+   */
+  isInstalled: (name: string) => boolean;
+  /**
+   * Check if the installed version of a package or a given SemVer object satisfies a semver range.
+   * @param nameOrVersion The name of the package to check, or a SemVer object.
+   * @param range The semver range to check against.
+   * @returns True if the version satisfies the range, false otherwise.
+   */
+  satisfies: (nameOrVersion: string | SemVer, range: string, optionsOrLoose?: boolean | RangeOptions) => boolean;
+};
+//#endregion
+//#region src/graph/types/graph.d.ts
+/**
+ * The main graph structure for OpenAPI node analysis.
+ *
+ * @property nodeDependencies - For each node with at least one dependency, the set of normalized JSON Pointers it references via $ref. Nodes with no dependencies are omitted.
+ * @property nodes - Map from normalized JSON Pointer to NodeInfo for every node in the spec.
+ * @property reverseNodeDependencies - For each node with at least one dependent, the set of nodes that reference it via $ref. Nodes with no dependents are omitted.
+ */
+type Graph = {
+  /**
+   * For each node with at least one dependency, the set of normalized JSON Pointers it references via $ref.
+   * Nodes with no dependencies are omitted from this map.
+   */
+  nodeDependencies: Map<string, Set<string>>;
+  /**
+   * Map from normalized JSON Pointer to NodeInfo for every node in the spec.
+   */
+  nodes: Map<string, NodeInfo>;
+  /**
+   * For each node with at least one dependent, the set of nodes that reference it via $ref.
+   * Nodes with no dependents are omitted from this map.
+   */
+  reverseNodeDependencies: Map<string, Set<string>>;
+  /**
+   * For each node, the set of direct $ref targets that appear anywhere inside the node's
+   * subtree (the node itself and its children). This is populated during graph construction
+   * and is used to compute top-level dependency relationships where $ref may be attached to
+   * child pointers instead of the parent.
+   */
+  subtreeDependencies: Map<string, Set<string>>;
+  /**
+   * For each node, the set of all (transitive) normalized JSON Pointers it references via $ref anywhere in its subtree.
+   * This includes both direct and indirect dependencies, making it useful for filtering, codegen, and tree-shaking.
+   */
+  transitiveDependencies: Map<string, Set<string>>;
+};
+/**
+ * Information about a node in the OpenAPI graph.
+ *
+ * @property deprecated - Whether the node is deprecated. Optional.
+ * @property key - The property name or array index in the parent, or null for root.
+ * @property node - The actual object at this pointer in the spec.
+ * @property parentPointer - The JSON Pointer of the parent node, or null for root.
+ * @property scopes - The set of access scopes for this node, if any. Optional.
+ * @property tags - The set of tags for this node, if any. Optional.
+ */
+type NodeInfo = {
+  /** Whether the node is deprecated. Optional. */
+  deprecated?: boolean;
+  /** The property name or array index in the parent, or null for root. */
+  key: string | number | null;
+  /** The actual object at this pointer in the spec.  */
+  node: unknown;
+  /** The JSON Pointer of the parent node, or null for root. */
+  parentPointer: string | null;
+  /** The set of access scopes for this node, if any. Optional. */
+  scopes?: Set<Scope>;
+  /** The set of tags for this node, if any. Optional. */
+  tags?: Set<string>;
+};
+//#endregion
+//#region src/graph/types/walk.d.ts
+type GetPointerPriorityFn = (pointer: string) => number;
+type MatchPointerToGroupFn<T extends string = string> = (pointer: string, kind?: T) => PointerGroupMatch<T>;
+type PointerGroupMatch<T extends string = string> = {
+  kind: T;
   matched: true;
 } | {
   kind?: undefined;
   matched: false;
 };
-type WalkOptions<T$1 extends string = string> = {
+type WalkOptions<T extends string = string> = {
   /**
    * Optional priority function used to compute a numeric priority for each
    * pointer. Lower values are emitted earlier. Useful to customize ordering
@@ -3067,7 +2770,7 @@ type WalkOptions<T$1 extends string = string> = {
    * @param pointer The pointer string
    * @returns The group name, or undefined if no match
    */
-  matchPointerToGroup?: MatchPointerToGroupFn<T$1>;
+  matchPointerToGroup?: MatchPointerToGroupFn<T>;
   /**
    * Order of walking schemas.
    *
@@ -3090,7 +2793,7 @@ type WalkOptions<T$1 extends string = string> = {
    * to do so (it will only apply the preference when doing so does not
    * violate dependency ordering).
    */
-  preferGroups?: ReadonlyArray<T$1>;
+  preferGroups?: ReadonlyArray<T>;
 };
 //#endregion
 //#region src/types/case.d.ts
@@ -3101,7 +2804,7 @@ type StringName = string | ((name: string) => string);
 type IApi$20 = any;
 //#endregion
 //#region src/plugins/@angular/common/types.d.ts
-type UserConfig$27 = Plugin.Name<'@angular/common'> & Plugin.Hooks & {
+type UserConfig$22 = Plugin.Name<'@angular/common'> & Plugin.Hooks & {
   /**
    * Should the exports from the generated files be re-exported in the index
    * barrel file?
@@ -3169,7 +2872,7 @@ type UserConfig$27 = Plugin.Name<'@angular/common'> & Plugin.Hooks & {
     methodNameBuilder?: (operation: IR.OperationObject) => string;
   };
 };
-type Config$14 = Plugin.Name<'@angular/common'> & Plugin.Hooks & {
+type Config$20 = Plugin.Name<'@angular/common'> & Plugin.Hooks & {
   /**
    * Should the exports from the generated files be re-exported in the index
    * barrel file?
@@ -3232,1057 +2935,1017 @@ type Config$14 = Plugin.Name<'@angular/common'> & Plugin.Hooks & {
     methodNameBuilder: (operation: IR.OperationObject) => string;
   };
 };
-type AngularCommonPlugin = DefinePlugin<UserConfig$27, Config$14, IApi$20>;
+type AngularCommonPlugin = DefinePlugin<UserConfig$22, Config$20, IApi$20>;
 //#endregion
-//#region src/plugins/@hey-api/client-axios/api.d.ts
-type IApi$19 = any;
-//#endregion
-//#region src/plugins/@hey-api/client-axios/types.d.ts
-type UserConfig$26 = Plugin.Name<'@hey-api/client-axios'> & Client$2.Config & {
+//#region src/plugins/@hey-api/client-core/bundle/auth.d.ts
+type AuthToken = string | undefined;
+interface Auth {
   /**
-   * Throw an error instead of returning it in the response?
+   * Which part of the request do we use to send the auth?
    *
-   * @default false
+   * @default 'header'
    */
-  throwOnError?: boolean;
-};
-type HeyApiClientAxiosPlugin = DefinePlugin<UserConfig$26, UserConfig$26, IApi$19>;
-//#endregion
-//#region src/plugins/@hey-api/client-fetch/api.d.ts
-type IApi$18 = any;
-//#endregion
-//#region src/plugins/@hey-api/client-fetch/types.d.ts
-type UserConfig$25 = Plugin.Name<'@hey-api/client-fetch'> & Client$2.Config & {
+  in?: 'header' | 'query' | 'cookie';
   /**
-   * Throw an error instead of returning it in the response?
+   * Header or query parameter name.
    *
-   * @default false
+   * @default 'Authorization'
    */
-  throwOnError?: boolean;
-};
-type HeyApiClientFetchPlugin = DefinePlugin<UserConfig$25, UserConfig$25, IApi$18>;
+  name?: string;
+  scheme?: 'basic' | 'bearer';
+  type: 'apiKey' | 'http';
+}
 //#endregion
-//#region src/plugins/@hey-api/client-next/api.d.ts
-type IApi$17 = any;
+//#region src/plugins/@hey-api/client-core/bundle/pathSerializer.d.ts
+interface SerializerOptions<T> {
+  /**
+   * @default true
+   */
+  explode: boolean;
+  style: T;
+}
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject';
 //#endregion
-//#region src/plugins/@hey-api/client-next/types.d.ts
-type UserConfig$24 = Plugin.Name<'@hey-api/client-next'> & Client$2.Config & {
+//#region src/plugins/@hey-api/client-core/bundle/bodySerializer.d.ts
+type QuerySerializer$1 = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: any) => any;
+type QuerySerializerOptionsObject = {
+  allowReserved?: boolean;
+  array?: Partial<SerializerOptions<ArrayStyle>>;
+  object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+type QuerySerializerOptions = QuerySerializerOptionsObject & {
   /**
-   * Throw an error instead of returning it in the response?
-   *
-   * @default false
+   * Per-parameter serialization overrides. When provided, these settings
+   * override the global array/object settings for specific parameter names.
    */
-  throwOnError?: boolean;
+  parameters?: Record<string, QuerySerializerOptionsObject>;
 };
-type HeyApiClientNextPlugin = DefinePlugin<UserConfig$24, UserConfig$24, IApi$17>;
-//#endregion
-//#region src/plugins/@hey-api/client-nuxt/api.d.ts
-type IApi$16 = any;
 //#endregion
-//#region src/plugins/@hey-api/client-nuxt/types.d.ts
-type UserConfig$23 = Plugin.Name<'@hey-api/client-nuxt'> & Client$2.Config;
-type HeyApiClientNuxtPlugin = DefinePlugin<UserConfig$23, UserConfig$23, IApi$16>;
-//#endregion
-//#region src/plugins/@hey-api/client-ofetch/api.d.ts
-type IApi$15 = any;
-//#endregion
-//#region src/plugins/@hey-api/client-ofetch/types.d.ts
-type UserConfig$22 = Plugin.Name<'@hey-api/client-ofetch'> & Client$2.Config & {
+//#region src/plugins/@hey-api/client-core/bundle/types.d.ts
+type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+type Client$1<RequestFn$6 = never, Config$21 = unknown, MethodFn$6 = never, BuildUrlFn$6 = never, SseFn$6 = never> = {
   /**
-   * Throw an error instead of returning it in the response?
+   * Returns the final request URL.
+   */
+  buildUrl: BuildUrlFn$6;
+  getConfig: () => Config$21;
+  request: RequestFn$6;
+  setConfig: (config: Config$21) => Config$21;
+} & { [K in HttpMethod]: MethodFn$6 } & ([SseFn$6] extends [never] ? {
+  sse?: never;
+} : {
+  sse: { [K in HttpMethod]: SseFn$6 };
+});
+interface Config$13 {
+  /**
+   * Auth token or a function returning auth token. The resolved value will be
+   * added to the request payload as defined by its `security` array.
+   */
+  auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+  /**
+   * A function for serializing request body parameter. By default,
+   * {@link JSON.stringify()} will be used.
+   */
+  bodySerializer?: BodySerializer | null;
+  /**
+   * An object containing any HTTP headers that you want to pre-populate your
+   * `Headers` object with.
    *
-   * @default false
+   * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
    */
-  throwOnError?: boolean;
-};
-type HeyApiClientOfetchPlugin = DefinePlugin<UserConfig$22, UserConfig$22, IApi$15>;
-//#endregion
-//#region src/plugins/@hey-api/client-core/types.d.ts
-interface PluginHandler {
-  (...args: Parameters<HeyApiClientAngularPlugin['Handler']>): void;
-  (...args: Parameters<HeyApiClientAxiosPlugin['Handler']>): void;
-  (...args: Parameters<HeyApiClientFetchPlugin['Handler']>): void;
-  (...args: Parameters<HeyApiClientNextPlugin['Handler']>): void;
-  (...args: Parameters<HeyApiClientNuxtPlugin['Handler']>): void;
-  (...args: Parameters<HeyApiClientOfetchPlugin['Handler']>): void;
-}
-/**
- * Public Client API.
- */
-declare namespace Client$2 {
-  export type Config = Plugin.Hooks & {
-    /**
-     * Set a default base URL when creating the client? You can set `baseUrl`
-     * to a string which will be used as the base URL. If your input defines
-     * server(s), you can set `baseUrl` to a number to pick a specific server
-     * to use as the base URL. You can disable setting the base URL by setting
-     * `baseUrl` to `false`. By default, `baseUrl` is `true` and it will try to
-     * use the first defined server value. If there's none, we won't set a
-     * base URL.
-     *
-     * If the matched URL contains template literals, it will be ignored.
-     *
-     * @default true
-     */
-    baseUrl?: string | number | boolean;
-    /**
-     * Bundle the client module? When `true`, the client module will be copied
-     * from the client plugin and bundled with the generated output.
-     *
-     * @default true
-     */
-    bundle?: boolean;
-    /**
-     * Should the exports from the generated files be re-exported in the index
-     * barrel file?
-     *
-     * @default false
-     */
-    exportFromIndex?: boolean;
-    /**
-     * Relative path to the runtime configuration file. This file must export
-     * a `createClientConfig()` function. The `createClientConfig()` function
-     * will be called on client initialization and the returned object will
-     * become the client's initial configuration.
-     *
-     * You may want to initialize your client this way instead of calling
-     * `setConfig()`. This is useful for example if you're using Next.js
-     * to ensure your client always has the correct values.
-     */
-    runtimeConfigPath?: string;
-    /**
-     * Should the type helper for base URL allow only values matching the
-     * server(s) defined in the input? By default, `strictBaseUrl` is `false`
-     * which will provide type hints and allow you to pass any string.
-     *
-     * Note that setting `strictBaseUrl` to `true` can produce an invalid
-     * build if you specify `baseUrl` which doesn't conform to the type helper.
-     *
-     * @default false
-     */
-    strictBaseUrl?: boolean;
-  };
+  headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+  /**
+   * The request method.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+   */
+  method?: Uppercase<HttpMethod>;
+  /**
+   * A function for serializing request query parameters. By default, arrays
+   * will be exploded in form style, objects will be exploded in deepObject
+   * style, and reserved characters are percent-encoded.
+   *
+   * This method will have no effect if the native `paramsSerializer()` Axios
+   * API function is used.
+   *
+   * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+   */
+  querySerializer?: QuerySerializer$1 | QuerySerializerOptions;
+  /**
+   * A function validating request data. This is useful if you want to ensure
+   * the request conforms to the desired shape, so it can be safely sent to
+   * the server.
+   */
+  requestValidator?: (data: unknown) => Promise<unknown>;
+  /**
+   * A function transforming response data before it's returned. This is useful
+   * for post-processing data, e.g. converting ISO strings into Date objects.
+   */
+  responseTransformer?: (data: unknown) => Promise<unknown>;
+  /**
+   * A function validating response data. This is useful if you want to ensure
+   * the response conforms to the desired shape, so it can be safely passed to
+   * the transformers and returned to the user.
+   */
+  responseValidator?: (data: unknown) => Promise<unknown>;
 }
 //#endregion
-//#region src/plugins/@hey-api/client-angular/api.d.ts
-type IApi$14 = any;
-//#endregion
-//#region src/plugins/@hey-api/client-angular/types.d.ts
-type UserConfig$21 = Plugin.Name<'@hey-api/client-angular'> & Client$2.Config & {
+//#region src/plugins/@hey-api/client-core/bundle/serverSentEvents.d.ts
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$13, 'method' | 'responseTransformer' | 'responseValidator'> & {
   /**
-   * Throw an error instead of returning it in the response?
+   * Fetch API implementation. You can use this option to provide a custom
+   * fetch instance.
    *
-   * @default false
+   * @default globalThis.fetch
    */
-  throwOnError?: boolean;
+  fetch?: typeof fetch;
+  /**
+   * Implementing clients can call request interceptors inside this hook.
+   */
+  onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+  /**
+   * Callback invoked when a network or parsing error occurs during streaming.
+   *
+   * This option applies only if the endpoint returns a stream of events.
+   *
+   * @param error The error that occurred.
+   */
+  onSseError?: (error: unknown) => void;
+  /**
+   * Callback invoked when an event is streamed from the server.
+   *
+   * This option applies only if the endpoint returns a stream of events.
+   *
+   * @param event Event streamed from the server.
+   * @returns Nothing (void).
+   */
+  onSseEvent?: (event: StreamEvent<TData>) => void;
+  serializedBody?: RequestInit['body'];
+  /**
+   * Default retry delay in milliseconds.
+   *
+   * This option applies only if the endpoint returns a stream of events.
+   *
+   * @default 3000
+   */
+  sseDefaultRetryDelay?: number;
+  /**
+   * Maximum number of retry attempts before giving up.
+   */
+  sseMaxRetryAttempts?: number;
+  /**
+   * Maximum retry delay in milliseconds.
+   *
+   * Applies only when exponential backoff is used.
+   *
+   * This option applies only if the endpoint returns a stream of events.
+   *
+   * @default 30000
+   */
+  sseMaxRetryDelay?: number;
+  /**
+   * Optional sleep function for retry backoff.
+   *
+   * Defaults to using `setTimeout`.
+   */
+  sseSleepFn?: (ms: number) => Promise<void>;
+  url: string;
+};
+interface StreamEvent<TData = unknown> {
+  data: TData;
+  event?: string;
+  id?: string;
+  retry?: number;
+}
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+  stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
 };
-type HeyApiClientAngularPlugin = DefinePlugin<UserConfig$21, UserConfig$21, IApi$14>;
-//#endregion
-//#region src/plugins/@hey-api/legacy-angular/types.d.ts
-type UserConfig$20 = Plugin.Name<'legacy/angular'> & Pick<Client$2.Config, 'output'>;
-type HeyApiClientLegacyAngularPlugin = DefinePlugin<UserConfig$20>;
-//#endregion
-//#region src/plugins/@hey-api/legacy-axios/types.d.ts
-type UserConfig$19 = Plugin.Name<'legacy/axios'> & Pick<Client$2.Config, 'output'>;
-type HeyApiClientLegacyAxiosPlugin = DefinePlugin<UserConfig$19>;
-//#endregion
-//#region src/plugins/@hey-api/legacy-fetch/types.d.ts
-type UserConfig$18 = Plugin.Name<'legacy/fetch'> & Pick<Client$2.Config, 'output'>;
-type HeyApiClientLegacyFetchPlugin = DefinePlugin<UserConfig$18>;
-//#endregion
-//#region src/plugins/@hey-api/legacy-node/types.d.ts
-type UserConfig$17 = Plugin.Name<'legacy/node'> & Pick<Client$2.Config, 'output'>;
-type HeyApiClientLegacyNodePlugin = DefinePlugin<UserConfig$17>;
-//#endregion
-//#region src/plugins/@hey-api/legacy-xhr/types.d.ts
-type UserConfig$16 = Plugin.Name<'legacy/xhr'> & Pick<Client$2.Config, 'output'>;
-type HeyApiClientLegacyXhrPlugin = DefinePlugin<UserConfig$16>;
 //#endregion
-//#region src/openApi/common/interfaces/Dictionary.d.ts
-interface Dictionary<T$1 = unknown> {
-  [key: string]: T$1;
+//#region src/plugins/@hey-api/client-angular/bundle/utils.d.ts
+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;
+  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;
 }
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiReference.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#reference-object
- */
-interface OpenApiReference {
-  $ref?: string;
+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/openApi/v3/interfaces/OpenApiExample.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#example-object
- */
-interface OpenApiExample extends OpenApiReference {
-  description?: string;
-  externalValue?: string;
-  summary?: string;
-  value?: unknown;
+//#region src/plugins/@hey-api/client-angular/bundle/types.d.ts
+type ResponseStyle$2 = 'data' | 'fields';
+interface Config$19<T extends ClientOptions$5 = ClientOptions$5> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Omit<Config$13, 'headers'> {
+  /**
+   * Base URL for all requests made by this client.
+   */
+  baseUrl?: T['baseUrl'];
+  /**
+   * An object containing any HTTP headers that you want to pre-populate your
+   * `HttpHeaders` object with.
+   *
+   * {@link https://angular.dev/api/common/http/HttpHeaders#constructor See more}
+   */
+  headers?: HttpHeaders | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+  /**
+   * The HTTP client to use for making requests.
+   */
+  httpClient?: HttpClient;
+  /**
+   * Should we return only data or multiple fields (data, error, response, etc.)?
+   *
+   * @default 'fields'
+   */
+  responseStyle?: ResponseStyle$2;
+  /**
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
+   */
+  throwOnError?: T['throwOnError'];
 }
-//#endregion
-//#region src/openApi/common/interfaces/WithEnumExtension.d.ts
-interface WithEnumExtension {
-  'x-enum-descriptions'?: ReadonlyArray<string>;
-  'x-enum-varnames'?: ReadonlyArray<string>;
-  'x-enumNames'?: ReadonlyArray<string>;
+interface RequestOptions$5<TData = unknown, TResponseStyle extends ResponseStyle$2 = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$19<{
+  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;
+  /**
+   * Optional custom injector for dependency resolution if you don't implicitly or explicitly provide one.
+   */
+  injector?: Injector;
+  path?: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  /**
+   * Security mechanism(s) to use for the request.
+   */
+  security?: ReadonlyArray<Auth>;
+  url: Url;
 }
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiDiscriminator.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#discriminator-object
- */
-interface OpenApiDiscriminator {
-  mapping?: Dictionary<string>;
-  propertyName: string;
+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;
 }
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiExternalDocs.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#external-documentation-object
- */
-interface OpenApiExternalDocs {
-  description?: string;
+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>;
+} : 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>;
+} | {
+  data: undefined;
+  error: TError[keyof TError];
+  request: HttpRequest<unknown>;
+  response: HttpErrorResponse & {
+    error: TError[keyof TError] | null;
+  };
+}>;
+interface ClientOptions$5 {
+  baseUrl?: string;
+  responseStyle?: ResponseStyle$2;
+  throwOnError?: boolean;
+}
+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: TData & Options$5<TData>) => string;
+type Client$7 = Client$1<RequestFn$5, Config$19, MethodFn$5, BuildUrlFn$5, SseFn$5> & {
+  interceptors: Middleware$3<HttpRequest<unknown>, HttpResponse<unknown>, unknown, ResolvedRequestOptions$3>;
+  requestOptions: RequestOptionsFn;
+};
+interface TDataShape$5 {
+  body?: unknown;
+  headers?: unknown;
+  path?: unknown;
+  query?: unknown;
   url: string;
 }
+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/openApi/v3/interfaces/OpenApiXml.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#xml-object
- */
-interface OpenApiXml$1 {
-  attribute?: boolean;
-  name?: string;
-  namespace?: string;
-  prefix?: string;
-  wrapped?: boolean;
+//#region src/plugins/@hey-api/client-axios/bundle/types.d.ts
+interface Config$18<T extends ClientOptions$4 = ClientOptions$4> extends Omit<CreateAxiosDefaults, 'auth' | 'baseURL' | 'headers' | 'method'>, Config$13 {
+  /**
+   * Axios implementation. You can use this option to provide either an
+   * `AxiosStatic` or an `AxiosInstance`.
+   *
+   * @default axios
+   */
+  axios?: AxiosStatic | AxiosInstance;
+  /**
+   * Base URL for all requests made by this client.
+   */
+  baseURL?: T['baseURL'];
+  /**
+   * An object containing any HTTP headers that you want to pre-populate your
+   * `Headers` object with.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+   */
+  headers?: AxiosRequestHeaders | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+  /**
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
+   */
+  throwOnError?: T['throwOnError'];
 }
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiSchema.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#schema-object
- */
-interface OpenApiSchema$1 extends OpenApiReference, WithEnumExtension {
-  additionalProperties?: boolean | OpenApiSchema$1;
-  allOf?: OpenApiSchema$1[];
-  anyOf?: OpenApiSchema$1[];
-  const?: string | number | boolean | null;
-  default?: unknown;
-  deprecated?: boolean;
-  description?: string;
-  discriminator?: OpenApiDiscriminator;
-  enum?: (string | number)[];
-  example?: unknown;
-  exclusiveMaximum?: boolean;
-  exclusiveMinimum?: boolean;
-  externalDocs?: OpenApiExternalDocs;
-  format?: 'binary' | 'boolean' | 'byte' | 'date-time' | 'date' | 'double' | 'float' | 'int32' | 'int64' | 'password' | 'string';
-  items?: OpenApiSchema$1;
-  maxItems?: number;
-  maxLength?: number;
-  maxProperties?: number;
-  maximum?: number;
-  minItems?: number;
-  minLength?: number;
-  minProperties?: number;
-  minimum?: number;
-  multipleOf?: number;
-  not?: OpenApiSchema$1[];
-  nullable?: boolean;
-  oneOf?: OpenApiSchema$1[];
-  pattern?: string;
-  prefixItems?: OpenApiSchema$1[];
-  properties?: Dictionary<OpenApiSchema$1>;
-  readOnly?: boolean;
-  required?: string[];
-  title?: string;
-  type?: string | string[];
-  uniqueItems?: boolean;
-  writeOnly?: boolean;
-  xml?: OpenApiXml$1;
+interface RequestOptions$4<TData = unknown, ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$18<{
+  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;
 }
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiParameter.d.ts
-/**
- * add only one type for now as that's needed to resolve the reported issue,
- * more types should be added though
- * {@link https://github.com/hey-api/openapi-ts/issues/612}
- */
-type MediaType = 'application/json';
-/**
- * encoding interface should be added, not adding it for now as it's not needed
- * to resolve the issue reported
- * {@link https://github.com/hey-api/openapi-ts/issues/612}
- */
-interface MediaTypeObject$1 {
-  example?: unknown;
-  examples?: Dictionary<OpenApiExample>;
-  schema: OpenApiSchema$1;
+interface ClientOptions$4 {
+  baseURL?: string;
+  throwOnError?: boolean;
 }
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-object
- */
-interface OpenApiParameter extends OpenApiReference {
-  allowEmptyValue?: boolean;
-  allowReserved?: boolean;
-  content?: Record<MediaType, MediaTypeObject$1>;
-  deprecated?: boolean;
-  description?: string;
-  example?: unknown;
-  examples?: Dictionary<OpenApiExample>;
-  explode?: boolean;
-  in: 'cookie' | 'formData' | 'header' | 'path' | 'query';
-  name: string;
-  nullable?: boolean;
-  required?: boolean;
-  schema?: OpenApiSchema$1;
-  style?: string;
+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$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: TData & Options$4<TData>) => string;
+type Client$6 = Client$1<RequestFn$4, Config$18, MethodFn$4, BuildUrlFn$4, SseFn$4> & {
+  instance: AxiosInstance;
+};
+interface TDataShape$4 {
+  body?: unknown;
+  headers?: unknown;
+  path?: unknown;
+  query?: unknown;
+  url: string;
 }
+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/openApi/common/interfaces/client.d.ts
-interface Enum {
-  customDescription?: string;
-  customName?: string;
-  description?: string;
-  value: string | number;
-}
-interface OperationParameter extends Model {
-  in: 'body' | 'cookie' | 'formData' | 'header' | 'path' | 'query';
-  mediaType: string | null;
-  prop: string;
-}
-interface OperationParameters extends Pick<Model, '$refs' | 'imports'> {
-  parameters: OperationParameter[];
-  parametersBody: OperationParameter | null;
-  parametersCookie: OperationParameter[];
-  parametersForm: OperationParameter[];
-  parametersHeader: OperationParameter[];
-  parametersPath: OperationParameter[];
-  parametersQuery: OperationParameter[];
-}
-interface OperationResponse extends Model {
-  code: number | 'default' | '1XX' | '2XX' | '3XX' | '4XX' | '5XX';
-  in: 'header' | 'response';
-  responseTypes: Array<'error' | 'success'>;
-}
-type Method = 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
-interface Operation$1 extends OperationParameters {
-  deprecated: boolean;
-  description: string | null;
-  /**
-   * The operationId from OpenAPI specification.
-   */
-  id: string | null;
-  method: Method;
-  name: string;
-  path: string;
-  responseHeader: string | null;
+//#region src/plugins/@hey-api/client-axios/api.d.ts
+type IApi$19 = any;
+//#endregion
+//#region src/plugins/@hey-api/client-axios/types.d.ts
+type UserConfig$21 = Plugin.Name<'@hey-api/client-axios'> & Client.Config & {
   /**
-   * All operation responses defined in OpenAPI specification.
-   * Sorted by status code.
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
    */
-  responses: OperationResponse[];
-  summary: string | null;
-  tags: string[] | null;
+  throwOnError?: boolean;
+};
+type HeyApiClientAxiosPlugin = DefinePlugin<UserConfig$21, UserConfig$21, IApi$19>;
+//#endregion
+//#region src/plugins/@hey-api/client-fetch/bundle/utils.d.ts
+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;
+  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 Schema {
-  default?: unknown;
-  exclusiveMaximum?: boolean;
-  exclusiveMinimum?: boolean;
-  format?: 'binary' | 'boolean' | 'byte' | 'date-time' | 'date' | 'double' | 'float' | 'int32' | 'int64' | 'password' | 'string';
-  isDefinition: boolean;
-  isNullable: boolean;
-  isReadOnly: boolean;
-  isRequired: boolean;
-  maxItems?: number;
-  maxLength?: number;
-  maxProperties?: number;
-  maximum?: number;
-  minItems?: number;
-  minLength?: number;
-  minProperties?: number;
-  minimum?: number;
-  multipleOf?: number;
-  pattern?: string;
-  uniqueItems?: boolean;
+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>>;
 }
-interface ModelMeta {
+//#endregion
+//#region src/plugins/@hey-api/client-fetch/bundle/types.d.ts
+type ResponseStyle$1 = 'data' | 'fields';
+interface Config$17<T extends ClientOptions$3 = ClientOptions$3> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$13 {
   /**
-   * Ref to the type in OpenAPI specification.
+   * Base URL for all requests made by this client.
    */
-  $ref: string;
+  baseUrl?: T['baseUrl'];
   /**
-   * Name passed to the initial `getModel()` call.
+   * Fetch API implementation. You can use this option to provide a custom
+   * fetch instance.
+   *
+   * @default globalThis.fetch
    */
-  name: string;
-}
-interface Model extends Schema {
+  fetch?: typeof fetch;
   /**
-   * **Experimental.** Contains list of original refs so they can be used
-   * to access the schema from anywhere instead of relying on string name.
-   * This allows us to do things like detect type of ref.
+   * 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.
    */
-  $refs: string[];
-  base: string;
-  deprecated?: boolean;
-  description: string | null;
-  enum: Enum[];
-  enums: Model[];
-  export: 'all-of' | 'any-of' | 'array' | 'const' | 'dictionary' | 'enum' | 'generic' | 'interface' | 'one-of' | 'reference';
-  imports: string[];
-  in: OperationParameter['in'] | OpenApiParameter['in'] | OperationResponse['in'] | '';
-  link: Model | Model[] | null;
-  meta?: ModelMeta;
+  next?: never;
   /**
-   * @deprecated use `meta.name` instead
+   * 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'
    */
-  name: string;
-  properties: Model[];
-  template: string | null;
-  type: string;
-}
-interface Client$1 {
+  parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
   /**
-   * Configuration for parsing and generating the output. This
-   * is a mix of user-provided and default values.
+   * Should we return only data or multiple fields (data, error, response, etc.)?
+   *
+   * @default 'fields'
    */
-  config: Config$1;
-  models: Model[];
-  operations: Operation$1[];
-  server: string;
+  responseStyle?: ResponseStyle$1;
   /**
-   * Map of generated types where type names are keys. This is used to track
-   * uniquely generated types as we may want to deduplicate if there are
-   * multiple definitions with the same name but different value, or if we
-   * want to transform names.
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
    */
-  types: Record<string, ModelMeta>;
-  version: string;
+  throwOnError?: T['throwOnError'];
 }
-//#endregion
-//#region src/utils/logger.d.ts
-declare class Logger {
-  private events;
-  private end;
+interface RequestOptions$3<TData = unknown, TResponseStyle extends ResponseStyle$1 = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$17<{
+  responseStyle: TResponseStyle;
+  throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
   /**
-   * Recursively end all unended events in the event tree.
-   * This ensures all events have end marks before measuring.
+   * Any body that you want to add to your request.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
    */
-  private endAllEvents;
-  report(print?: boolean): PerformanceMeasure | undefined;
-  private reportEvent;
-  private start;
-  private storeEvent;
-  timeEvent(name: string): {
-    mark: PerformanceMark;
-    timeEnd: () => void;
-  };
+  body?: unknown;
+  path?: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  /**
+   * Security mechanism(s) to use for the request.
+   */
+  security?: ReadonlyArray<Auth>;
+  url: Url;
 }
-//#endregion
-//#region src/openApi/v2/interfaces/OpenApiExternalDocs.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#external-documentation-object
- */
-interface OpenApiExternalDocs$1 {
-  description?: string;
-  url: string;
+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;
 }
-//#endregion
-//#region src/openApi/v2/interfaces/OpenApiContact.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#contact-object
- */
-interface OpenApiContact$1 {
-  email?: string;
-  name?: string;
-  url?: string;
+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 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$3 {
+  baseUrl?: string;
+  responseStyle?: ResponseStyle$1;
+  throwOnError?: boolean;
 }
-//#endregion
-//#region src/openApi/v2/interfaces/OpenApiLicense.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#license-object
- */
-interface OpenApiLicense$1 {
-  name: string;
-  url?: string;
+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: TData & Options$3<TData>) => string;
+type Client$5 = Client$1<RequestFn$3, Config$17, MethodFn$3, BuildUrlFn$3, SseFn$3> & {
+  interceptors: Middleware$2<Request, Response, unknown, ResolvedRequestOptions$2>;
+};
+interface TDataShape$3 {
+  body?: unknown;
+  headers?: unknown;
+  path?: unknown;
+  query?: unknown;
+  url: string;
 }
+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/openApi/v2/interfaces/OpenApiInfo.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#info-object
- */
-interface OpenApiInfo$1 {
-  contact?: OpenApiContact$1;
-  description?: string;
-  license?: OpenApiLicense$1;
-  termsOfService?: string;
-  title: string;
-  version: string;
-}
+//#region src/plugins/@hey-api/client-fetch/api.d.ts
+type IApi$18 = any;
 //#endregion
-//#region src/openApi/v2/interfaces/Extensions/WithNullableExtension.d.ts
-interface WithNullableExtension {
-  'x-nullable'?: boolean;
-}
+//#region src/plugins/@hey-api/client-fetch/types.d.ts
+type UserConfig$20 = Plugin.Name<'@hey-api/client-fetch'> & Client.Config & {
+  /**
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
+   */
+  throwOnError?: boolean;
+};
+type HeyApiClientFetchPlugin = DefinePlugin<UserConfig$20, UserConfig$20, IApi$18>;
 //#endregion
-//#region src/openApi/v2/interfaces/OpenApiItems.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#items-object)
- */
-interface OpenApiItems extends WithEnumExtension {
-  collectionFormat?: 'csv' | 'ssv' | 'tsv' | 'pipes';
-  default?: unknown;
-  enum?: (string | number)[];
-  exclusiveMaximum?: number;
-  exclusiveMinimum?: number;
-  format?: 'int32' | 'int64' | 'float' | 'double' | 'string' | 'boolean' | 'byte' | 'binary' | 'date' | 'date-time' | 'password';
-  items?: OpenApiItems;
-  maxItems?: number;
-  maxLength?: number;
-  maximum?: number;
-  minItems?: number;
-  minLength?: number;
-  minimum?: number;
-  multipleOf?: number;
-  pattern?: string;
-  type?: string;
-  uniqueItems?: boolean;
+//#region src/plugins/@hey-api/client-next/bundle/utils.d.ts
+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;
+  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;
 }
-//#endregion
-//#region src/openApi/v2/interfaces/OpenApiReference.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#reference-object
- */
-interface OpenApiReference$1 {
-  $ref?: string;
+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/openApi/v2/interfaces/OpenApiXml.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#xml-object
- */
-interface OpenApiXml {
-  attribute?: boolean;
-  name?: string;
-  namespace?: string;
-  prefix?: string;
-  wrapped?: boolean;
+//#region src/plugins/@hey-api/client-next/bundle/types.d.ts
+interface Config$16<T extends ClientOptions$2 = ClientOptions$2> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$13 {
+  /**
+   * Base URL for all requests made by this client.
+   */
+  baseUrl?: T['baseUrl'];
+  /**
+   * Fetch API implementation. You can use this option to provide a custom
+   * fetch instance.
+   *
+   * @default globalThis.fetch
+   */
+  fetch?: typeof fetch;
+  /**
+   * 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';
+  /**
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
+   */
+  throwOnError?: T['throwOnError'];
 }
-//#endregion
-//#region src/openApi/v2/interfaces/OpenApiSchema.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#schema-object
- */
-interface OpenApiSchema extends OpenApiReference$1, WithEnumExtension, WithNullableExtension {
-  additionalProperties?: boolean | OpenApiSchema;
-  allOf?: OpenApiSchema[];
-  default?: unknown;
-  description?: string;
-  discriminator?: string;
-  enum?: (string | number)[];
-  example?: unknown;
-  exclusiveMaximum?: boolean;
-  exclusiveMinimum?: boolean;
-  externalDocs?: OpenApiExternalDocs$1;
-  format?: 'int32' | 'int64' | 'float' | 'double' | 'string' | 'boolean' | 'byte' | 'binary' | 'date' | 'date-time' | 'password';
-  items?: OpenApiSchema;
-  maxItems?: number;
-  maxLength?: number;
-  maxProperties?: number;
-  maximum?: number;
-  minItems?: number;
-  minLength?: number;
-  minProperties?: number;
-  minimum?: number;
-  multipleOf?: number;
-  pattern?: string;
-  properties?: Dictionary<OpenApiSchema>;
-  readOnly?: boolean;
-  required?: string[];
-  title?: string;
-  type?: string;
-  uniqueItems?: boolean;
-  xml?: OpenApiXml;
+interface RequestOptions$2<TData = unknown, ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$16<{
+  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;
 }
-//#endregion
-//#region src/openApi/v2/interfaces/OpenApiParameter.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#parameter-object
- */
-interface OpenApiParameter$1 extends OpenApiReference$1, WithEnumExtension, WithNullableExtension {
-  allowEmptyValue?: boolean;
-  collectionFormat?: 'csv' | 'ssv' | 'tsv' | 'pipes' | 'multi';
-  default?: unknown;
-  description?: string;
-  enum?: (string | number)[];
-  exclusiveMaximum?: boolean;
-  exclusiveMinimum?: boolean;
-  format?: 'int32' | 'int64' | 'float' | 'double' | 'string' | 'boolean' | 'byte' | 'binary' | 'date' | 'date-time' | 'password';
-  in: 'path' | 'query' | 'header' | 'formData' | 'body';
-  items?: OpenApiItems;
-  maxItems?: number;
-  maxLength?: number;
-  maximum?: number;
-  minItems?: number;
-  minLength?: number;
-  minimum?: number;
-  multipleOf?: number;
-  name: string;
-  pattern?: string;
-  required?: boolean;
-  schema?: OpenApiSchema;
-  type?: string;
-  uniqueItems?: boolean;
+interface ResolvedRequestOptions$1<ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions$2<unknown, ThrowOnError, Url> {
+  serializedBody?: string;
 }
-//#endregion
-//#region src/openApi/v2/interfaces/OpenApiExample.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#example-object
- */
-interface OpenApiExample$1 {
-  [mimetype: string]: unknown;
+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 extends Record<string, unknown> ? TData[keyof TData] : TData;
+  error: undefined;
+} | {
+  data: undefined;
+  error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+  response: Response;
+}>;
+interface ClientOptions$2 {
+  baseUrl?: string;
+  throwOnError?: boolean;
 }
-//#endregion
-//#region src/openApi/v2/interfaces/OpenApiHeader.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#header-object
- */
-interface OpenApiHeader$1 {
-  collectionFormat?: 'csv' | 'ssv' | 'tsv' | 'pipes';
-  default?: unknown;
-  description?: string;
-  enum?: (string | number)[];
-  exclusiveMaximum?: boolean;
-  exclusiveMinimum?: boolean;
-  format?: 'int32' | 'int64' | 'float' | 'double' | 'string' | 'boolean' | 'byte' | 'binary' | 'date' | 'date-time' | 'password';
-  items?: Dictionary<OpenApiItems>;
-  maxItems?: number;
-  maxLength?: number;
-  maximum?: number;
-  minItems?: number;
-  minLength?: number;
-  minimum?: number;
-  multipleOf?: number;
-  pattern?: string;
-  type: 'string' | 'number' | 'integer' | 'boolean' | 'array';
-  uniqueItems?: boolean;
+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: TData & Options$2<TData>) => string;
+type Client$4 = Client$1<RequestFn$2, Config$16, MethodFn$2, BuildUrlFn$2, SseFn$2> & {
+  interceptors: Middleware$1<Response, unknown, ResolvedRequestOptions$1>;
+};
+interface TDataShape$2 {
+  body?: unknown;
+  headers?: unknown;
+  path?: unknown;
+  query?: unknown;
+  url: string;
 }
+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/openApi/v2/interfaces/OpenApiResponse.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#response-object
- */
-interface OpenApiResponse$1 extends OpenApiReference$1 {
-  description: string;
-  examples?: OpenApiExample$1;
-  headers?: Dictionary<OpenApiHeader$1>;
-  schema?: OpenApiSchema & OpenApiReference$1;
-}
+//#region src/plugins/@hey-api/client-next/api.d.ts
+type IApi$17 = any;
 //#endregion
-//#region src/openApi/v2/interfaces/OpenApiResponses.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#responses-object
- */
-interface Response$1 {
-  [httpcode: string]: OpenApiResponse$1;
-}
-type OpenApiResponses$1 = Response$1 & {
-  default?: OpenApiResponse$1;
+//#region src/plugins/@hey-api/client-next/types.d.ts
+type UserConfig$19 = Plugin.Name<'@hey-api/client-next'> & Client.Config & {
+  /**
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
+   */
+  throwOnError?: boolean;
 };
+type HeyApiClientNextPlugin = DefinePlugin<UserConfig$19, UserConfig$19, IApi$17>;
 //#endregion
-//#region src/openApi/v2/interfaces/OpenApiSecurityRequirement.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#security-requirement-object
- */
-interface OpenApiSecurityRequirement$1 {
-  [key: string]: string;
+//#region src/plugins/@hey-api/client-nuxt/bundle/types.d.ts
+type QuerySerializer = (query: Parameters<Client$3['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$15<T extends ClientOptions$1 = ClientOptions$1> extends Omit<FetchOptions$1<unknown>, 'baseURL' | 'body' | 'headers' | 'method' | 'query'>, WithRefs<Pick<FetchOptions$1<unknown>, 'query'>>, Omit<Config$13, 'querySerializer'> {
+  /**
+   * Base URL for all requests made by this client.
+   */
+  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
+   * style, and reserved characters are percent-encoded.
+   *
+   * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+   */
+  querySerializer?: QuerySerializer | QuerySerializerOptions;
 }
-//#endregion
-//#region src/openApi/v2/interfaces/OpenApiOperation.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#operation-object
- */
-interface OpenApiOperation$1 {
-  consumes?: string[];
-  deprecated?: boolean;
-  description?: string;
-  externalDocs?: OpenApiExternalDocs$1;
-  operationId?: string;
-  parameters?: OpenApiParameter$1[];
-  produces?: string[];
-  responses: OpenApiResponses$1;
-  schemes?: ('http' | 'https' | 'ws' | 'wss')[];
-  security?: OpenApiSecurityRequirement$1[];
-  summary?: string;
-  tags?: string[];
+interface RequestOptions$1<TComposable extends Composable = '$fetch', ResT = unknown, DefaultT = undefined, Url extends string = string> extends Config$15, WithRefs<{
+  /**
+   * Any body that you want to add to your request.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+   */
+  body?: unknown;
+  path?: FetchOptions$1<unknown>['query'];
+  query?: FetchOptions$1<unknown>['query'];
+  rawBody?: unknown;
+}>, 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.
+   */
+  security?: ReadonlyArray<Auth>;
+  url: Url;
 }
-//#endregion
-//#region src/openApi/v2/interfaces/OpenApiPath.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#path-item-object
- */
-interface OpenApiPath$1 extends OpenApiReference$1 {
-  connect?: OpenApiOperation$1;
-  delete?: OpenApiOperation$1;
-  get?: OpenApiOperation$1;
-  head?: OpenApiOperation$1;
-  options?: OpenApiOperation$1;
-  parameters?: OpenApiParameter$1[];
-  patch?: OpenApiOperation$1;
-  post?: OpenApiOperation$1;
-  put?: OpenApiOperation$1;
-  trace?: OpenApiOperation$1;
+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;
 }
-//#endregion
-//#region src/openApi/v2/interfaces/OpenApiSecurityScheme.d.ts
+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>;
 /**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#security-scheme-object
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
  */
-interface OpenApiSecurityScheme$1 {
-  authorizationUrl?: string;
-  description?: string;
-  flow?: 'implicit' | 'password' | 'application' | 'accessCode';
-  in?: 'query' | 'header';
-  name?: string;
-  scopes: Dictionary<string>;
-  tokenUrl?: string;
-  type: 'basic' | 'apiKey' | 'oauth2';
+
+interface TDataShape$1 {
+  body?: unknown;
+  headers?: unknown;
+  path?: FetchOptions$1<unknown>['query'];
+  query?: FetchOptions$1<unknown>['query'];
+  url: string;
 }
+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$3 = Client$1<RequestFn$1, Config$15, 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/openApi/v2/interfaces/OpenApiTag.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#tag-object
- */
-interface OpenApiTag$1 {
-  description?: string;
-  externalDocs?: OpenApiExternalDocs$1;
-  name: string;
-}
+//#region src/plugins/@hey-api/client-nuxt/api.d.ts
+type IApi$16 = any;
 //#endregion
-//#region src/openApi/v2/interfaces/OpenApi.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md
- */
-interface OpenApi$2 {
-  basePath?: string;
-  consumes?: string[];
-  definitions?: Dictionary<OpenApiSchema>;
-  externalDocs?: OpenApiExternalDocs$1;
-  host?: string;
-  info: OpenApiInfo$1;
-  parameters?: Dictionary<OpenApiParameter$1>;
-  paths: Dictionary<OpenApiPath$1>;
-  produces?: string[];
-  responses?: Dictionary<OpenApiResponse$1>;
-  schemes?: string[];
-  security?: OpenApiSecurityRequirement$1[];
-  securityDefinitions?: Dictionary<OpenApiSecurityScheme$1>;
-  swagger: string;
-  tags?: OpenApiTag$1[];
-}
+//#region src/plugins/@hey-api/client-nuxt/types.d.ts
+type UserConfig$18 = Plugin.Name<'@hey-api/client-nuxt'> & Client.Config;
+type HeyApiClientNuxtPlugin = DefinePlugin<UserConfig$18, UserConfig$18, IApi$16>;
 //#endregion
-//#region src/openApi/v3/interfaces/OpenApiHeader.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#header-object
- */
-interface OpenApiHeader extends OpenApiReference {
-  allowEmptyValue?: boolean;
-  allowReserved?: boolean;
-  deprecated?: boolean;
-  description?: string;
-  example?: unknown;
-  examples?: Dictionary<OpenApiExample>;
-  explode?: boolean;
-  required?: boolean;
-  schema?: OpenApiSchema$1;
-  style?: string;
+//#region src/plugins/@hey-api/client-ofetch/bundle/utils.d.ts
+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;
+  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;
 }
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiEncoding.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#encoding-object
- */
-interface OpenApiEncoding {
-  allowReserved?: boolean;
-  contentType?: string;
-  explode?: boolean;
-  headers?: Dictionary<OpenApiHeader>;
-  style?: string;
+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/openApi/v3/interfaces/OpenApiMediaType.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#media-type-object
- */
-interface OpenApiMediaType extends OpenApiReference {
-  encoding?: Dictionary<OpenApiEncoding>;
-  example?: unknown;
-  examples?: Dictionary<OpenApiExample>;
-  schema?: OpenApiSchema$1;
-}
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiRequestBody.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#request-body-object
- */
-interface OpenApiRequestBody extends OpenApiReference {
-  content: Dictionary<OpenApiMediaType>;
-  description?: string;
-  nullable?: boolean;
-  required?: boolean;
-  'x-body-name'?: string;
-}
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiServerVariable.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#server-variable-object
- */
-interface OpenApiServerVariable extends WithEnumExtension {
-  default: string;
-  description?: string;
-  enum?: (string | number)[];
-}
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiServer.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#server-object
- */
-interface OpenApiServer {
-  description?: string;
-  url: string;
-  variables?: Dictionary<OpenApiServerVariable>;
+//#region src/plugins/@hey-api/client-ofetch/bundle/types.d.ts
+type ResponseStyle = 'data' | 'fields';
+interface Config$14<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$13 {
+  /**
+   * HTTP(S) agent configuration (Node.js only). Passed through to ofetch.
+   */
+  agent?: FetchOptions['agent'];
+  /**
+   * Base URL for all requests made by this client.
+   */
+  baseUrl?: T['baseUrl'];
+  /**
+   * Node-only proxy/agent options.
+   */
+  dispatcher?: FetchOptions['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['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['onRequest'];
+  /**
+   * ofetch hook called when a request fails before receiving a response
+   * (e.g., network errors or aborted requests).
+   */
+  onRequestError?: FetchOptions['onRequestError'];
+  /**
+   * ofetch hook called after a successful response is received and parsed.
+   */
+  onResponse?: FetchOptions['onResponse'];
+  /**
+   * ofetch hook called when the response indicates an error (non-ok status)
+   * or when response parsing fails.
+   */
+  onResponseError?: FetchOptions['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['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['retry'];
+  /**
+   * Delay (in ms) between retry attempts.
+   */
+  retryDelay?: FetchOptions['retryDelay'];
+  /**
+   * HTTP status codes that should trigger a retry.
+   */
+  retryStatusCodes?: FetchOptions['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;
 }
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiLink.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#link-object
- */
-interface OpenApiLink extends OpenApiReference {
-  description?: string;
-  operationId?: string;
-  operationRef?: string;
-  parameters?: Dictionary<unknown>;
-  requestBody?: unknown;
-  server?: OpenApiServer;
+interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$14<{
+  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;
 }
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiResponse.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#response-object
- */
-interface OpenApiResponse extends OpenApiReference {
-  content?: Dictionary<OpenApiMediaType>;
-  description: string;
-  headers?: Dictionary<OpenApiHeader>;
-  links?: Dictionary<OpenApiLink>;
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+  serializedBody?: string;
 }
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiResponses.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#responses-object
- */
-interface Response {
-  [httpcode: string]: OpenApiResponse;
+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 OpenApiResponses = OpenApiReference & Response & {
-  default: OpenApiResponse;
+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: TData & Options<TData>) => string;
+type Client$2 = Client$1<RequestFn, Config$14, MethodFn, BuildUrlFn, SseFn> & {
+  interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
 };
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiSecurityRequirement.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#security-requirement-object
- */
-interface OpenApiSecurityRequirement {
-  [name: string]: string;
-}
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiOperation.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#operation-object
- */
-interface OpenApiOperation {
-  callbacks?: Dictionary<OpenApiCallback>;
-  deprecated?: boolean;
-  description?: string;
-  externalDocs?: OpenApiExternalDocs;
-  operationId?: string;
-  parameters?: OpenApiParameter[];
-  requestBody?: OpenApiRequestBody;
-  responses: OpenApiResponses;
-  security?: OpenApiSecurityRequirement[];
-  servers?: OpenApiServer[];
-  summary?: string;
-  tags?: string[];
-}
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiPath.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#path-item-object
- */
-interface OpenApiPath {
-  connect?: OpenApiOperation;
-  delete?: OpenApiOperation;
-  description?: string;
-  get?: OpenApiOperation;
-  head?: OpenApiOperation;
-  options?: OpenApiOperation;
-  parameters?: OpenApiParameter[];
-  patch?: OpenApiOperation;
-  post?: OpenApiOperation;
-  put?: OpenApiOperation;
-  servers?: OpenApiServer[];
-  summary?: string;
-  trace?: OpenApiOperation;
-}
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiCallback.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#callback-object
- */
-interface Callback {
-  [key: string]: OpenApiPath;
-}
-type OpenApiCallback = OpenApiReference & Callback;
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiOAuthFlow.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#oauth-flow-object
- */
-interface OpenApiOAuthFlow {
-  authorizationUrl: string;
-  refreshUrl?: string;
-  scopes: Dictionary<string>;
-  tokenUrl: string;
-}
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiOAuthFlows.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#oauth-flows-object
- */
-interface OpenApiOAuthFlows {
-  authorizationCode?: OpenApiOAuthFlow;
-  clientCredentials?: OpenApiOAuthFlow;
-  implicit?: OpenApiOAuthFlow;
-  password?: OpenApiOAuthFlow;
-}
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiSecurityScheme.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#security-scheme-object
- */
-interface OpenApiSecurityScheme extends OpenApiReference {
-  bearerFormat?: string;
-  description?: string;
-  flows?: OpenApiOAuthFlows;
-  in?: 'query' | 'header' | 'cookie';
-  name?: string;
-  openIdConnectUrl?: string;
-  scheme?: string;
-  type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
-}
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiComponents.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#components-object
- */
-interface OpenApiComponents {
-  callbacks?: Dictionary<OpenApiCallback>;
-  examples?: Dictionary<OpenApiExample>;
-  headers?: Dictionary<OpenApiHeader>;
-  links?: Dictionary<OpenApiLink>;
-  parameters?: Dictionary<OpenApiParameter>;
-  requestBodies?: Dictionary<OpenApiRequestBody>;
-  responses?: Dictionary<OpenApiResponses>;
-  schemas?: Dictionary<OpenApiSchema$1>;
-  securitySchemes?: Dictionary<OpenApiSecurityScheme>;
-}
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiContact.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#contact-object
- */
-interface OpenApiContact {
-  email?: string;
-  name?: string;
-  url?: string;
-}
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApiLicense.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#license-object
- */
-interface OpenApiLicense {
-  name: string;
-  url?: string;
+interface TDataShape {
+  body?: unknown;
+  headers?: unknown;
+  path?: unknown;
+  query?: unknown;
+  url: string;
 }
+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/openApi/v3/interfaces/OpenApiInfo.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#info-object
- */
-interface OpenApiInfo {
-  contact?: OpenApiContact;
-  description?: string;
-  license?: OpenApiLicense;
-  termsOfService?: string;
-  title: string;
-  version: string;
-}
+//#region src/plugins/@hey-api/client-ofetch/api.d.ts
+type IApi$15 = any;
 //#endregion
-//#region src/openApi/v3/interfaces/OpenApiPaths.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#paths-object
- */
-interface OpenApiPaths {
-  [path: string]: OpenApiPath;
-}
+//#region src/plugins/@hey-api/client-ofetch/types.d.ts
+type UserConfig$17 = Plugin.Name<'@hey-api/client-ofetch'> & Client.Config & {
+  /**
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
+   */
+  throwOnError?: boolean;
+};
+type HeyApiClientOfetchPlugin = DefinePlugin<UserConfig$17, UserConfig$17, IApi$15>;
 //#endregion
-//#region src/openApi/v3/interfaces/OpenApiTag.d.ts
-/**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#tag-object
- */
-interface OpenApiTag {
-  description?: string;
-  externalDocs?: OpenApiExternalDocs;
-  name: string;
+//#region src/plugins/@hey-api/client-core/types.d.ts
+interface PluginHandler {
+  (...args: Parameters<HeyApiClientAngularPlugin['Handler']>): void;
+  (...args: Parameters<HeyApiClientAxiosPlugin['Handler']>): void;
+  (...args: Parameters<HeyApiClientFetchPlugin['Handler']>): void;
+  (...args: Parameters<HeyApiClientNextPlugin['Handler']>): void;
+  (...args: Parameters<HeyApiClientNuxtPlugin['Handler']>): void;
+  (...args: Parameters<HeyApiClientOfetchPlugin['Handler']>): void;
 }
-//#endregion
-//#region src/openApi/v3/interfaces/OpenApi.d.ts
 /**
- * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md
+ * Public Client API.
  */
-interface OpenApi$3 {
-  components?: OpenApiComponents;
-  externalDocs?: OpenApiExternalDocs;
-  info: OpenApiInfo;
-  openapi: string;
-  paths: OpenApiPaths;
-  security?: OpenApiSecurityRequirement[];
-  servers?: OpenApiServer[];
-  tags?: OpenApiTag[];
+declare namespace Client {
+  export type Config = Plugin.Hooks & {
+    /**
+     * Set a default base URL when creating the client? You can set `baseUrl`
+     * to a string which will be used as the base URL. If your input defines
+     * server(s), you can set `baseUrl` to a number to pick a specific server
+     * to use as the base URL. You can disable setting the base URL by setting
+     * `baseUrl` to `false`. By default, `baseUrl` is `true` and it will try to
+     * use the first defined server value. If there's none, we won't set a
+     * base URL.
+     *
+     * If the matched URL contains template literals, it will be ignored.
+     *
+     * @default true
+     */
+    baseUrl?: string | number | boolean;
+    /**
+     * Bundle the client module? When `true`, the client module will be copied
+     * from the client plugin and bundled with the generated output.
+     *
+     * @default true
+     */
+    bundle?: boolean;
+    /**
+     * Should the exports from the generated files be re-exported in the index
+     * barrel file?
+     *
+     * @default false
+     */
+    exportFromIndex?: boolean;
+    /**
+     * Relative path to the runtime configuration file. This file must export
+     * a `createClientConfig()` function. The `createClientConfig()` function
+     * will be called on client initialization and the returned object will
+     * become the client's initial configuration.
+     *
+     * You may want to initialize your client this way instead of calling
+     * `setConfig()`. This is useful for example if you're using Next.js
+     * to ensure your client always has the correct values.
+     */
+    runtimeConfigPath?: string;
+    /**
+     * Should the type helper for base URL allow only values matching the
+     * server(s) defined in the input? By default, `strictBaseUrl` is `false`
+     * which will provide type hints and allow you to pass any string.
+     *
+     * Note that setting `strictBaseUrl` to `true` can produce an invalid
+     * build if you specify `baseUrl` which doesn't conform to the type helper.
+     *
+     * @default false
+     */
+    strictBaseUrl?: boolean;
+  };
 }
 //#endregion
-//#region src/openApi/common/interfaces/OpenApi.d.ts
-type OpenApi = OpenApi$2 | OpenApi$3;
+//#region src/plugins/@hey-api/client-angular/api.d.ts
+type IApi$14 = any;
 //#endregion
-//#region src/openApi/index.d.ts
-/**
- * @internal
- * Parse the resolved OpenAPI specification. This will populate and return
- * `context` with intermediate representation obtained from the parsed spec.
- */
-declare const parseOpenApiSpec: ({
-  config,
-  dependencies,
-  logger,
-  spec
-}: {
-  config: Config$1;
-  dependencies: Record<string, string>;
-  logger: Logger;
-  spec: unknown;
-}) => IR$1.Context | undefined;
+//#region src/plugins/@hey-api/client-angular/types.d.ts
+type UserConfig$16 = Plugin.Name<'@hey-api/client-angular'> & Client.Config & {
+  /**
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
+   */
+  throwOnError?: boolean;
+};
+type HeyApiClientAngularPlugin = DefinePlugin<UserConfig$16, UserConfig$16, IApi$14>;
 //#endregion
 //#region src/openApi/2.0.x/types/json-schema-draft-4.d.ts
 interface JsonSchemaDraft4 extends EnumExtensions {
@@ -5818,7 +5481,7 @@ interface SecurityDefinitionsObject {
   /**
    * A single security scheme definition, mapping a "name" to the scheme it defines.
    */
-  [name: string]: SecuritySchemeObject$2;
+  [name: string]: SecuritySchemeObject$1;
 }
 /**
  * Lists the required security schemes to execute this operation. The object can have multiple security schemes declared in it which are all required (that is, there is a logical AND between the schemes).
@@ -5882,7 +5545,7 @@ interface SecurityRequirementObject$1 {
  *   read:pets: read your pets
  * ```
  */
-type SecuritySchemeObject$2 = {
+type SecuritySchemeObject$1 = {
   /**
    * A short description for security scheme.
    */
@@ -6029,7 +5692,7 @@ interface OpenApiV3_0_X {
   /**
    * An array of Server Objects, which provide connectivity information to a target server. If the `servers` field is not provided, or is an empty array, the default value would be a {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#server-object Server Object} with a {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#server-url url} value of `/`.
    */
-  servers?: ReadonlyArray<ServerObject$1>;
+  servers?: ReadonlyArray<ServerObject>;
   /**
    * A list of tags used by the OpenAPI Description with additional metadata. The order of the tags can be used to reflect on their order by the parsing tools. Not all tags that are used by the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#operation-object Operation Object} must be declared. The tags that are not declared MAY be organized randomly or based on the tools' logic. Each tag name in the list MUST be unique.
    */
@@ -6093,7 +5756,7 @@ interface ComponentsObject {
   /**
    * An object to hold reusable {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#security-scheme-object Security Scheme Objects}.
    */
-  securitySchemes?: Record<string, SecuritySchemeObject$1 | ReferenceObject$2>;
+  securitySchemes?: Record<string, SecuritySchemeObject | ReferenceObject$2>;
 }
 /**
  * Contact information for the exposed API.
@@ -6341,7 +6004,7 @@ interface LinkObject {
   /**
    * A server object to be used by the target operation.
    */
-  server?: ServerObject$1;
+  server?: ServerObject;
 }
 /**
  * Each Media Type Object provides schema and examples for the media type identified by its key.
@@ -6465,7 +6128,7 @@ interface OperationObject$1 {
   /**
    * An alternative `servers` array to service this operation. If a `servers` array is specified at the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#path-item-servers Path Item Object} or {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#oas-servers OpenAPI Object} level, it will be overridden by this value.
    */
-  servers?: ReadonlyArray<ServerObject$1>;
+  servers?: ReadonlyArray<ServerObject>;
   /**
    * A short summary of what the operation does.
    */
@@ -6627,7 +6290,7 @@ interface PathItemObject {
   /**
    * An alternative `servers` array to service all operations in this path. If a `servers` array is specified at the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#oas-servers OpenAPI Object} level, it will be overridden by this value.
    */
-  servers?: ReadonlyArray<ServerObject$1>;
+  servers?: ReadonlyArray<ServerObject>;
   /**
    * An optional string summary, intended to apply to all operations in this path.
    */
@@ -7054,7 +6717,7 @@ interface SecurityRequirementObject {
  *
  * TODO: examples
  */
-type SecuritySchemeObject$1 = {
+type SecuritySchemeObject = {
   /**
    * A description for security scheme. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -7111,7 +6774,7 @@ type SecuritySchemeObject$1 = {
  *
  * TODO: examples
  */
-interface ServerObject$1 {
+interface ServerObject {
   /**
    * An optional string describing the host designated by the URL. {@link https://spec.commonmark.org/ CommonMark syntax} MAY be used for rich text representation.
    */
@@ -7251,7 +6914,7 @@ type UserConfig$15 = Plugin.Name<'@hey-api/schemas'> & Plugin.Hooks & {
    *
    * @default '{{name}}Schema'
    */
-  nameBuilder?: string | ((name: string, schema: OpenApiSchema | OpenApiSchema$1 | OpenApiV2_0_XTypes['SchemaObject'] | OpenApiV3_0_XTypes['ReferenceObject'] | OpenApiV3_0_XTypes['SchemaObject'] | OpenApiV3_1_XTypes['SchemaObject']) => string);
+  nameBuilder?: string | ((name: string, schema: OpenApiV2_0_XTypes['SchemaObject'] | OpenApiV3_0_XTypes['ReferenceObject'] | OpenApiV3_0_XTypes['SchemaObject'] | OpenApiV3_1_XTypes['SchemaObject']) => string);
   /**
    * Choose schema type to generate. Select 'form' if you don't want
    * descriptions to reduce bundle size and you plan to use schemas
@@ -7263,598 +6926,102 @@ type UserConfig$15 = Plugin.Name<'@hey-api/schemas'> & Plugin.Hooks & {
 };
 type HeyApiSchemasPlugin = DefinePlugin<UserConfig$15, UserConfig$15, IApi$13>;
 //#endregion
-//#region src/config/utils/config.d.ts
-type ObjectType<T$1> = Extract<T$1, Record<string, any>> extends never ? Record<string, any> : Extract<T$1, Record<string, any>>;
-type NotArray<T$1> = T$1 extends any[] ? never : T$1;
-type NotFunction<T$1> = T$1 extends ((...args: any[]) => any) ? never : T$1;
-type PlainObject<T$1> = T$1 extends object ? NotFunction<T$1> extends never ? never : NotArray<T$1> extends never ? never : T$1 : never;
-type MappersType<T$1> = {
-  boolean: T$1 extends boolean ? (value: boolean) => Partial<ObjectType<T$1>> : never;
-  function: T$1 extends ((...args: any[]) => any) ? (value: (...args: any[]) => any) => Partial<ObjectType<T$1>> : never;
-  number: T$1 extends number ? (value: number) => Partial<ObjectType<T$1>> : never;
-  object?: PlainObject<T$1> extends never ? never : (value: Partial<PlainObject<T$1>>, defaultValue: PlainObject<T$1>) => Partial<ObjectType<T$1>>;
-  string: T$1 extends string ? (value: string) => Partial<ObjectType<T$1>> : never;
-} extends infer U ? { [K in keyof U as U[K] extends never ? never : K]: U[K] } : never;
-type IsObjectOnly<T$1> = T$1 extends Record<string, any> | undefined ? Extract<T$1, string | boolean | number | ((...args: any[]) => any)> extends never ? true : false : false;
-type ValueToObject = <T extends undefined | string | boolean | number | ((...args: any[]) => any) | Record<string, any>>(args: {
-  defaultValue: ObjectType<T>;
-  value: T;
-} & (IsObjectOnly<T> extends true ? {
-  mappers?: MappersType<T>;
-} : {
-  mappers: MappersType<T>;
-})) => PlainObject<T>;
-//#endregion
-//#region src/ir/graph.d.ts
-declare const irTopLevelKinds: readonly ["operation", "parameter", "requestBody", "schema", "server", "webhook"];
-type IrTopLevelKind = (typeof irTopLevelKinds)[number];
-//#endregion
-//#region src/openApi/types.d.ts
-declare namespace OpenApi$1 {
-  export type V2_0_X = OpenApiV2_0_X;
-  export type V3_0_X = OpenApiV3_0_X;
-  export type V3_1_X = OpenApiV3_1_X;
-}
-declare namespace OpenApiMetaObject {
-  export type V2_0_X = OpenApiV2_0_XTypes['InfoObject'];
-  export type V3_0_X = OpenApiV3_0_XTypes['InfoObject'];
-  export type V3_1_X = OpenApiV3_1_XTypes['InfoObject'];
-}
-declare namespace OpenApiOperationObject {
-  export type V2_0_X = OpenApiV2_0_XTypes['OperationObject'];
-  export type V3_0_X = OpenApiV3_0_XTypes['OperationObject'];
-  export type V3_1_X = OpenApiV3_1_XTypes['OperationObject'];
-}
-declare namespace OpenApiParameterObject {
-  export type V3_0_X = OpenApiV3_0_XTypes['ParameterObject'] | OpenApiV3_0_XTypes['ReferenceObject'];
-  export type V3_1_X = OpenApiV3_1_XTypes['ParameterObject'] | OpenApiV3_1_XTypes['ReferenceObject'];
-}
-declare namespace OpenApiRequestBodyObject {
-  export type V3_0_X = OpenApiV3_0_XTypes['RequestBodyObject'] | OpenApiV3_0_XTypes['ReferenceObject'];
-  export type V3_1_X = OpenApiV3_1_XTypes['RequestBodyObject'] | OpenApiV3_1_XTypes['ReferenceObject'];
-}
-declare namespace OpenApiResponseObject {
-  export type V3_0_X = OpenApiV3_0_XTypes['ResponseObject'] | OpenApiV3_0_XTypes['ReferenceObject'];
-  export type V3_1_X = OpenApiV3_1_XTypes['ResponseObject'] | OpenApiV3_1_XTypes['ReferenceObject'];
-}
-declare namespace OpenApiSchemaObject {
-  export type V2_0_X = OpenApiV2_0_XTypes['SchemaObject'];
-  export type V3_0_X = OpenApiV3_0_XTypes['SchemaObject'];
-  export type V3_1_X = OpenApiV3_1_XTypes['SchemaObject'];
-}
+//#region src/plugins/@hey-api/sdk/api.d.ts
+type IApi$12 = any;
 //#endregion
-//#region src/plugins/shared/types/instance.d.ts
-type BaseEvent = {
+//#region src/plugins/@hey-api/sdk/types.d.ts
+type UserConfig$14 = Plugin.Name<'@hey-api/sdk'> & Plugin.Hooks & {
   /**
-   * Path to the node, derived from the pointer.
+   * Group operation methods into classes? When enabled, you can select which
+   * classes to export with `sdk.include` and/or transform their names with
+   * `sdk.classNameBuilder`.
+   *
+   * Note that by enabling this option, your SDKs will **NOT**
+   * support {@link https://developer.mozilla.org/docs/Glossary/Tree_shaking tree-shaking}.
+   * For this reason, it is disabled by default.
+   *
+   * @default false
    */
-  _path: ReadonlyArray<string | number>;
+  asClass?: boolean;
   /**
-   * Pointer to the node in the graph.
+   * Should the generated functions contain auth mechanisms? You may want to
+   * disable this option if you're handling auth yourself or defining it
+   * globally on the client and want to reduce the size of generated code.
+   *
+   * @default true
    */
-  pointer: string;
+  auth?: boolean;
   /**
-   * Tags associated with the node.
+   * Customize the generated class names. The name variable is obtained from
+   * your OpenAPI specification tags or `instance` value.
+   *
+   * This option has no effect if `sdk.asClass` is `false`.
    */
-  tags?: ReadonlyArray<string>;
-};
-type WalkEvents = BaseEvent & ({
-  method: keyof IR$1.PathItemObject;
-  operation: IR$1.OperationObject;
-  path: string;
-  type: Extract<IrTopLevelKind, 'operation'>;
-} | {
-  name: string;
-  parameter: IR$1.ParameterObject;
-  type: Extract<IrTopLevelKind, 'parameter'>;
-} | {
-  name: string;
-  requestBody: IR$1.RequestBodyObject;
-  type: Extract<IrTopLevelKind, 'requestBody'>;
-} | {
-  name: string;
-  schema: IR$1.SchemaObject;
-  type: Extract<IrTopLevelKind, 'schema'>;
-} | {
-  server: IR$1.ServerObject;
-  type: Extract<IrTopLevelKind, 'server'>;
-} | {
-  key: string;
-  method: keyof IR$1.PathItemObject;
-  operation: IR$1.OperationObject;
-  type: Extract<IrTopLevelKind, 'webhook'>;
-});
-type WalkEvent<T$1 extends IrTopLevelKind = IrTopLevelKind> = Extract<WalkEvents, {
-  type: T$1;
-}>;
-//#endregion
-//#region src/plugins/shared/utils/instance.d.ts
-declare class PluginInstance<T$1 extends Plugin.Types = Plugin.Types> {
-  api: T$1['api'];
-  config: Omit<T$1['resolvedConfig'], 'name' | 'output'>;
-  context: IR$1.Context;
-  dependencies: Required<Plugin.Config<T$1>>['dependencies'];
-  private eventHooks;
-  gen: IProject;
-  private handler;
-  name: T$1['resolvedConfig']['name'];
-  output: string;
+  classNameBuilder?: StringName;
   /**
-   * The package metadata and utilities for the current context, constructed
-   * from the provided dependencies. Used for managing package-related
-   * information such as name, version, and dependency resolution during
-   * code generation.
+   * How should we structure your SDK? By default, we try to infer the ideal
+   * structure using `operationId` keywords. If you prefer a flatter structure,
+   * you can set `classStructure` to `off` to disable this behavior.
+   *
+   * @default 'auto'
    */
-  package: IR$1.Context['package'];
-  constructor(props: Pick<Required<Plugin.Config<T$1>>, 'config' | 'dependencies' | 'handler'> & {
-    api?: T$1['api'];
-    context: IR$1.Context<OpenApi$1.V2_0_X | OpenApi$1.V3_0_X | OpenApi$1.V3_1_X>;
-    gen: IProject;
-    name: string;
-    output: string;
-  });
+  classStructure?: 'auto' | 'off';
   /**
-   * Iterates over various input elements as specified by the event types, in
-   * a specific order: servers, schemas, parameters, request bodies, then
-   * operations.
+   * Use an internal client instance to send HTTP requests? This is useful if
+   * you don't want to manually pass the client to each SDK function.
    *
-   * This ensures, for example, that schemas are always processed before
-   * operations, which may reference them.
+   * You can customize the selected client output through its plugin. You can
+   * also set `client` to `true` to automatically choose the client from your
+   * defined plugins. If we can't detect a client plugin when using `true`, we
+   * will default to `@hey-api/client-fetch`.
    *
-   * @template TKind - The event type(s) to yield. Defaults to all event types.
-   * @param events - The event types to walk over. If none are provided, all event types are included.
-   * @param callback - Function to execute for each event.
+   * @default true
+   */
+  client?: PluginClientNames | boolean;
+  /**
+   * Should the exports from the generated files be re-exported in the index
+   * barrel file?
    *
-   * @example
-   * // Iterate over all operations and schemas
-   * plugin.forEach('operation', 'schema', (event) => {
-   *   if (event.type === 'operation') {
-   *     // handle operation
-   *   } else if (event.type === 'schema') {
-   *     // handle schema
-   *   }
-   * });
+   * @default true
    */
-  forEach<TKind extends IrTopLevelKind = IrTopLevelKind>(...args: [...events: ReadonlyArray<TKind>, callback: (event: WalkEvent<TKind>) => void]): void;
-  forEach<TKind extends IrTopLevelKind = IrTopLevelKind>(...args: [...events: ReadonlyArray<TKind>, callback: (event: WalkEvent<TKind>) => void, options: WalkOptions<TKind>]): void;
+  exportFromIndex?: boolean;
   /**
-   * Retrieves a registered plugin instance by its name from the context. This
-   * allows plugins to access other plugins that have been registered in the
-   * same context, enabling cross-plugin communication and dependencies.
+   * Include only service classes with names matching regular expression
    *
-   * @param name Plugin name as defined in the configuration.
-   * @returns The plugin instance if found, undefined otherwise.
+   * This option has no effect if `sdk.asClass` is `false`.
    */
-  getPlugin<TName extends keyof PluginConfigMap>(name: TName): TName extends any ? PluginInstance<PluginConfigMap[TName]> | undefined : never;
+  include?: string;
   /**
-   * Retrieves a registered plugin instance by its name from the context. This
-   * allows plugins to access other plugins that have been registered in the
-   * same context, enabling cross-plugin communication and dependencies.
+   * Set `instance` to create an instantiable SDK. Using `true` will use the
+   * default instance name; in practice, you want to define your own by passing
+   * a string value.
    *
-   * @param name Plugin name as defined in the configuration.
-   * @returns The plugin instance if found, throw otherwise.
+   * @default false
    */
-  getPluginOrThrow<TName extends keyof PluginConfigMap>(name: TName): TName extends any ? PluginInstance<PluginConfigMap[TName]> : never;
-  getSymbol(identifier: SymbolIdentifier): Symbol | undefined;
-  hooks: {
-    operation: {
-      isMutation: (operation: IR$1.OperationObject) => boolean;
-      isQuery: (operation: IR$1.OperationObject) => boolean;
-    };
-  };
-  isSymbolRegistered(identifier: SymbolIdentifier): boolean;
-  querySymbol(filter: SymbolMeta): Symbol | undefined;
-  referenceSymbol(meta: SymbolMeta): Symbol;
-  registerSymbol(symbol: SymbolIn): Symbol;
+  instance?: string | boolean;
   /**
-   * Executes plugin's handler function.
+   * Customise the name of methods within the service. By default,
+   * {@link IR.OperationObject.id} is used.
    */
-  run(): Promise<void>;
-  setSymbolValue(symbol: Symbol, value: unknown): void;
-  private buildEventHooks;
-  private forEachError;
-  private getSymbolFilePath;
-  private isOperationKind;
-}
-//#endregion
-//#region src/parser/types/hooks.d.ts
-type Hooks = {
+  methodNameBuilder?: (operation: IR$1.OperationObject) => string;
+  // TODO: parser - rename operationId option to something like inferId?: boolean
   /**
-   * Event hooks.
+   * Use operation ID to generate operation names?
+   *
+   * @default true
    */
-  events?: {
-    /**
-     * Triggered after executing a plugin handler.
-     *
-     * @param args Arguments object.
-     * @returns void
-     */
-    'plugin:handler:after'?: (args: {
-      /** Plugin that just executed. */
-      plugin: PluginInstance;
-    }) => void;
-    /**
-     * Triggered before executing a plugin handler.
-     *
-     * @param args Arguments object.
-     * @returns void
-     */
-    'plugin:handler:before'?: (args: {
-      /** Plugin about to execute. */
-      plugin: PluginInstance;
-    }) => void;
-    /**
-     * Triggered after registering a symbol.
-     *
-     * You can use this to perform actions after a symbol is registered.
-     *
-     * @param args Arguments object.
-     * @returns void
-     */
-    'symbol:register:after'?: (args: {
-      /** Plugin that registered the symbol. */
-      plugin: PluginInstance;
-      /** The registered symbol. */
-      symbol: Symbol;
-    }) => void;
-    /**
-     * Triggered before registering a symbol.
-     *
-     * You can use this to modify the symbol before it's registered.
-     *
-     * @param args Arguments object.
-     * @returns void
-     */
-    'symbol:register:before'?: (args: {
-      /** Plugin registering the symbol. */
-      plugin: PluginInstance;
-      /** Symbol to register. */
-      symbol: SymbolIn;
-    }) => void;
-    /**
-     * Triggered after setting a symbol value.
-     *
-     * You can use this to perform actions after a symbol's value is set.
-     *
-     * @param args Arguments object.
-     * @returns void
-     */
-    'symbol:setValue:after'?: (args: {
-      /** Plugin that set the symbol value. */
-      plugin: PluginInstance;
-      /** The symbol. */
-      symbol: Symbol;
-      /** The value that was set. */
-      value: unknown;
-    }) => void;
-    /**
-     * Triggered before setting a symbol value.
-     *
-     *  You can use this to modify the value before it's set.
-     *
-     * @param args Arguments object.
-     * @returns void
-     */
-    'symbol:setValue:before'?: (args: {
-      /** Plugin setting the symbol value. */
-      plugin: PluginInstance;
-      /** The symbol. */
-      symbol: Symbol;
-      /** The value to set. */
-      value: unknown;
-    }) => void;
-  };
-  /**
-   * Hooks specifically for overriding operations behavior.
-   *
-   * Use these to classify operations, decide which outputs to generate,
-   * or apply custom behavior to individual operations.
-   */
-  operations?: {
-    /**
-     * Classify the given operation into one or more kinds.
-     *
-     * Each kind determines how we treat the operation (e.g., generating queries or mutations).
-     *
-     * **Default behavior:**
-     * - GET → 'query'
-     * - DELETE, PATCH, POST, PUT → 'mutation'
-     *
-     * **Resolution order:**
-     * 1. If `isQuery` or `isMutation` returns `true` or `false`, that overrides `getKind`.
-     * 2. If `isQuery` or `isMutation` returns `undefined`, the result of `getKind` is used.
-     *
-     * @param operation - The operation object to classify.
-     * @returns An array containing one or more of 'query' or 'mutation', or undefined to fallback to default behavior.
-     * @example
-     * ```ts
-     * getKind: (operation) => {
-     *   if (operation.method === 'get' && operation.path === '/search') {
-     *     return ['query', 'mutation'];
-     *   }
-     *   return; // fallback to default behavior
-     * }
-     * ```
-     */
-    getKind?: (operation: IROperationObject) => ReadonlyArray<'mutation' | 'query'> | undefined;
-    /**
-     * Check if the given operation should be treated as a mutation.
-     *
-     * This affects which outputs are generated for the operation.
-     *
-     * **Default behavior:** DELETE, PATCH, POST, and PUT operations are treated as mutations.
-     *
-     * **Resolution order:** If this returns `true` or `false`, it overrides `getKind`.
-     * If it returns `undefined`, `getKind` is used instead.
-     *
-     * @param operation - The operation object to check.
-     * @returns true if the operation is a mutation, false otherwise, or undefined to fallback to `getKind`.
-     * @example
-     * ```ts
-     * isMutation: (operation) => {
-     *   if (operation.method === 'post' && operation.path === '/search') {
-     *     return true;
-     *   }
-     *   return; // fallback to default behavior
-     * }
-     * ```
-     */
-    isMutation?: (operation: IROperationObject) => boolean | undefined;
-    /**
-     * Check if the given operation should be treated as a query.
-     *
-     * This affects which outputs are generated for the operation.
-     *
-     * **Default behavior:** GET operations are treated as queries.
-     *
-     * **Resolution order:** If this returns `true` or `false`, it overrides `getKind`.
-     * If it returns `undefined`, `getKind` is used instead.
-     *
-     * @param operation - The operation object to check.
-     * @returns true if the operation is a query, false otherwise, or undefined to fallback to `getKind`.
-     * @example
-     * ```ts
-     * isQuery: (operation) => {
-     *   if (operation.method === 'post' && operation.path === '/search') {
-     *     return true;
-     *   }
-     *   return; // fallback to default behavior
-     * }
-     * ```
-     */
-    isQuery?: (operation: IROperationObject) => boolean | undefined;
-  };
-  /**
-   * Hooks specifically for overriding symbols behavior.
-   *
-   * Use these to customize file placement.
-   */
-  symbols?: {
-    /**
-     * Optional output strategy to override default plugin behavior.
-     *
-     * Use this to route generated symbols to specific files.
-     *
-     * @returns The file path to output the symbol to, or undefined to fallback to default behavior.
-     */
-    getFilePath?: (symbol: Symbol) => string | undefined;
-  };
-};
-//#endregion
-//#region src/types/client.d.ts
-interface Operation extends Omit<Operation$1, 'tags'> {
-  service: string;
-}
-interface Service extends Pick<Model, '$refs' | 'imports' | 'name'> {
-  operations: Operation[];
-}
-interface Client extends Omit<Client$1, 'operations'> {
-  services: Service[];
-}
-//#endregion
-//#region src/plugins/types.d.ts
-type PluginClientNames = '@hey-api/client-angular' | '@hey-api/client-axios' | '@hey-api/client-fetch' | '@hey-api/client-next' | '@hey-api/client-nuxt' | '@hey-api/client-ofetch' | 'legacy/angular' | 'legacy/axios' | 'legacy/fetch' | 'legacy/node' | 'legacy/xhr';
-type PluginValidatorNames = 'arktype' | 'valibot' | 'zod';
-type PluginNames = PluginClientNames | '@angular/common' | '@hey-api/schemas' | '@hey-api/sdk' | '@hey-api/transformers' | '@hey-api/typescript' | '@pinia/colada' | '@tanstack/angular-query-experimental' | '@tanstack/react-query' | '@tanstack/solid-query' | '@tanstack/svelte-query' | '@tanstack/vue-query' | 'fastify' | PluginValidatorNames;
-type AnyPluginName = PluginNames | (string & {});
-type PluginTag = 'client' | 'transformer' | 'validator';
-type PluginContext = {
-  package: Package;
-  pluginByTag: <T extends AnyPluginName | boolean = AnyPluginName>(tag: PluginTag, props?: {
-    defaultPlugin?: Exclude<T, boolean>;
-    errorMessage?: string;
-  }) => Exclude<T, boolean> | undefined;
-  valueToObject: ValueToObject;
-};
-type BaseApi = Record<string, unknown>;
-type BaseConfig = {
-  /**
-   * Should the exports from the plugin's file be re-exported in the index
-   * barrel file?
-   */
-  exportFromIndex?: boolean;
-  name: AnyPluginName;
-  /**
-   * Optional hooks to override default plugin behavior.
-   *
-   * Use these to classify resources, control which outputs are generated,
-   * or provide custom behavior for specific resources.
-   */
-  '~hooks'?: Hooks;
-};
-
-/**
- * Public Plugin API.
- */
-declare namespace Plugin {
-  export type Config<T extends Types> = Pick<T, 'api'> & {
-    config: Omit<T['config'], 'name' | 'output'>;
-    /**
-     * Dependency plugins will be always processed, regardless of whether user
-     * explicitly defines them in their `plugins` config.
-     */
-    dependencies?: ReadonlyArray<AnyPluginName>;
-    handler: Handler<T>;
-    handlerLegacy?: LegacyHandler<T>;
-    name: T['config']['name'];
-    output?: NonNullable<T['config']['output']>;
-    /**
-     * Resolves static configuration values into their runtime equivalents. For
-     * example, when `validator` is set to `true`, it figures out which plugin
-     * should be used for validation.
-     */
-    resolveConfig?: (plugin: Omit<Plugin.Config<T>, 'dependencies'> & {
-      dependencies: Set<AnyPluginName>;
-    }, context: PluginContext) => void;
-    /**
-     * Optional tags can be used to help with deciding plugin order and resolving
-     * plugin configuration options.
-     */
-    tags?: ReadonlyArray<PluginTag>;
-  };
-  export type ConfigWithName<T extends Types> = Omit<Config<T>, 'config'> & {
-    config: Omit<T['config'], 'output'>;
-  };
-
-  /** @deprecated use `definePluginConfig()` instead */
-  export type DefineConfig<Config extends BaseConfig, ResolvedConfig extends BaseConfig = Config> = (config?: UserConfig<Omit<Config, 'name'>>) => Omit<Plugin.Config<Config, ResolvedConfig>, 'name'> & {
-    /**
-     * Cast name to `any` so it doesn't throw type error in `plugins` array.
-     * We could allow any `string` as plugin `name` in the object syntax, but
-     * that TypeScript trick would cause all string methods to appear as
-     * suggested auto completions, which is undesirable.
-     */
-    name: any;
-  };
-
-  /**
-   * Generic wrapper for plugin hooks.
-   */
-  export type Hooks = Pick<BaseConfig, '~hooks'>;
-  export interface Name<Name extends PluginNames> {
-    name: Name;
-  }
-  export type Types<Config extends BaseConfig = BaseConfig, ResolvedConfig extends BaseConfig = Config, Api extends BaseApi = never> = ([Api] extends [never] ? {
-    api?: BaseApi;
-  } : {
-    api: Api;
-  }) & {
-    config: Config;
-    resolvedConfig: ResolvedConfig;
-  };
-
-  /**
-   * Users cannot modify output file path to avoid risk of conflicts.
-   */
-  export type UserConfig<Config extends BaseConfig> = Omit<Config, 'output'>;
-}
-type DefinePlugin<Config$15 extends BaseConfig = BaseConfig, ResolvedConfig$1 extends BaseConfig = Config$15, Api$1 extends BaseApi = never> = {
-  Config: Plugin.Config<Plugin.Types<Config$15, ResolvedConfig$1, Api$1>>;
-  Handler: (args: {
-    plugin: PluginInstance<Plugin.Types<Config$15, ResolvedConfig$1, Api$1>>;
-  }) => void;
-  Instance: PluginInstance<Plugin.Types<Config$15, ResolvedConfig$1, Api$1>>;
-  /**
-   * Plugin implementation for legacy parser.
-   *
-   * @deprecated
-   */
-  LegacyHandler: (args: {
-    client: Client;
-    files: Files;
-    openApi: OpenApi;
-    plugin: PluginInstance<Plugin.Types<Config$15, ResolvedConfig$1, Api$1>>;
-  }) => void;
-  Types: Plugin.Types<Config$15, ResolvedConfig$1, Api$1>;
-};
-//#endregion
-//#region src/plugins/@hey-api/sdk/api.d.ts
-type IApi$12 = any;
-//#endregion
-//#region src/plugins/@hey-api/sdk/types.d.ts
-type UserConfig$14 = Plugin.Name<'@hey-api/sdk'> & Plugin.Hooks & {
-  /**
-   * Group operation methods into classes? When enabled, you can select which
-   * classes to export with `sdk.include` and/or transform their names with
-   * `sdk.classNameBuilder`.
-   *
-   * Note that by enabling this option, your SDKs will **NOT**
-   * support {@link https://developer.mozilla.org/docs/Glossary/Tree_shaking tree-shaking}.
-   * For this reason, it is disabled by default.
-   *
-   * @default false
-   */
-  asClass?: boolean;
-  /**
-   * Should the generated functions contain auth mechanisms? You may want to
-   * disable this option if you're handling auth yourself or defining it
-   * globally on the client and want to reduce the size of generated code.
-   *
-   * @default true
-   */
-  auth?: boolean;
-  /**
-   * Customize the generated class names. The name variable is obtained from
-   * your OpenAPI specification tags or `instance` value.
-   *
-   * This option has no effect if `sdk.asClass` is `false`.
-   */
-  classNameBuilder?: StringName;
-  /**
-   * How should we structure your SDK? By default, we try to infer the ideal
-   * structure using `operationId` keywords. If you prefer a flatter structure,
-   * you can set `classStructure` to `off` to disable this behavior.
-   *
-   * @default 'auto'
-   */
-  classStructure?: 'auto' | 'off';
+  operationId?: boolean;
   /**
-   * Use an internal client instance to send HTTP requests? This is useful if
-   * you don't want to manually pass the client to each SDK function.
+   * Define how request parameters are structured in generated SDK methods.
    *
-   * You can customize the selected client output through its plugin. You can
-   * also set `client` to `true` to automatically choose the client from your
-   * defined plugins. If we can't detect a client plugin when using `true`, we
-   * will default to `@hey-api/client-fetch`.
+   * - `'flat'` merges parameters into a single object.
+   * - `'grouped'` separates parameters by transport layer.
    *
-   * @default true
-   */
-  client?: PluginClientNames | boolean;
-  /**
-   * Should the exports from the generated files be re-exported in the index
-   * barrel file?
+   * Use `'flat'` for simpler calls or `'grouped'` for stricter typing and code clarity.
    *
-   * @default true
-   */
-  exportFromIndex?: boolean;
-  /**
-   * Include only service classes with names matching regular expression
-   *
-   * This option has no effect if `sdk.asClass` is `false`.
+   * @default 'grouped'
    */
-  include?: string;
-  /**
-   * Set `instance` to create an instantiable SDK. Using `true` will use the
-   * default instance name; in practice, you want to define your own by passing
-   * a string value.
-   *
-   * @default false
-   */
-  instance?: string | boolean;
-  /**
-   * Customise the name of methods within the service. By default,
-   * {@link IR.OperationObject.id} or {@link Operation.name} is used.
-   */
-  methodNameBuilder?: (operation: IR$1.OperationObject | Operation) => string;
-  // TODO: parser - rename operationId option to something like inferId?: boolean
-  /**
-   * Use operation ID to generate operation names?
-   *
-   * @default true
-   */
-  operationId?: boolean;
-  /** @deprecated - this is an experimental feature, do not use */
-  params_EXPERIMENTAL?: 'default' | 'experiment';
+  paramsStructure?: 'flat' | 'grouped';
   /**
    * **This feature works only with the Fetch client**
    *
@@ -7937,7 +7104,7 @@ type UserConfig$14 = Plugin.Name<'@hey-api/sdk'> & Plugin.Hooks & {
    */
   response?: 'body' | 'response';
 };
-type Config$13 = Plugin.Name<'@hey-api/sdk'> & Plugin.Hooks & {
+type Config$12 = Plugin.Name<'@hey-api/sdk'> & Plugin.Hooks & {
   /**
    * Group operation methods into classes? When enabled, you can select which
    * classes to export with `sdk.include` and/or transform their names with
@@ -8008,9 +7175,9 @@ type Config$13 = Plugin.Name<'@hey-api/sdk'> & Plugin.Hooks & {
   instance: string | boolean;
   /**
    * Customise the name of methods within the service. By default,
-   * {@link IR.OperationObject.id} or {@link Operation.name} is used.
+   * {@link IR.OperationObject.id} is used.
    */
-  methodNameBuilder?: (operation: IR$1.OperationObject | Operation) => string;
+  methodNameBuilder?: (operation: IR$1.OperationObject) => string;
   // TODO: parser - rename operationId option to something like inferId?: boolean
   /**
    * Use operation ID to generate operation names?
@@ -8018,8 +7185,17 @@ type Config$13 = Plugin.Name<'@hey-api/sdk'> & Plugin.Hooks & {
    * @default true
    */
   operationId: boolean;
-  /** @deprecated - this is an experimental feature, do not use */
-  params_EXPERIMENTAL: 'default' | 'experiment';
+  /**
+   * Define how request parameters are structured in generated SDK methods.
+   *
+   * - `'flat'` merges parameters into a single object.
+   * - `'grouped'` separates parameters by transport layer.
+   *
+   * Use `'flat'` for simpler calls or `'grouped'` for stricter typing and code clarity.
+   *
+   * @default 'grouped'
+   */
+  paramsStructure: 'flat' | 'grouped';
   /**
    * **This feature works only with the Fetch client**
    *
@@ -8084,7 +7260,7 @@ type Config$13 = Plugin.Name<'@hey-api/sdk'> & Plugin.Hooks & {
    */
   response: 'body' | 'response';
 };
-type HeyApiSdkPlugin = DefinePlugin<UserConfig$14, Config$13, IApi$12>;
+type HeyApiSdkPlugin = DefinePlugin<UserConfig$14, Config$12, IApi$12>;
 //#endregion
 //#region src/plugins/@hey-api/transformers/api.d.ts
 type IApi$11 = any;
@@ -8139,7 +7315,7 @@ type UserConfig$13 = Plugin.Name<'@hey-api/transformers'> & Plugin.Hooks & {
    */
   typeTransformers?: ReadonlyArray<TypeTransformer>;
 };
-type Config$12 = Plugin.Name<'@hey-api/transformers'> & Plugin.Hooks & {
+type Config$11 = Plugin.Name<'@hey-api/transformers'> & Plugin.Hooks & {
   /**
    * Convert long integers into BigInt values?
    *
@@ -8168,7 +7344,7 @@ type Config$12 = Plugin.Name<'@hey-api/transformers'> & Plugin.Hooks & {
    */
   typeTransformers: ReadonlyArray<TypeTransformer>;
 };
-type HeyApiTransformersPlugin = DefinePlugin<UserConfig$13, Config$12, IApi$11>;
+type HeyApiTransformersPlugin = DefinePlugin<UserConfig$13, Config$11, IApi$11>;
 //#endregion
 //#region src/plugins/@hey-api/typescript/shared/types.d.ts
 type IrSchemaToAstOptions = {
@@ -8446,7 +7622,7 @@ type UserConfig$12 = Plugin.Name<'@hey-api/typescript'> & Plugin.Hooks & {
    */
   tree?: boolean;
 };
-type Config$11 = Plugin.Name<'@hey-api/typescript'> & Plugin.Hooks & {
+type Config$10 = Plugin.Name<'@hey-api/typescript'> & Plugin.Hooks & {
   /**
    * The casing convention to use for generated names.
    *
@@ -8667,7 +7843,7 @@ type Config$11 = Plugin.Name<'@hey-api/typescript'> & Plugin.Hooks & {
    */
   tree: boolean;
 };
-type HeyApiTypeScriptPlugin = DefinePlugin<UserConfig$12, Config$11, IApi$10>;
+type HeyApiTypeScriptPlugin = DefinePlugin<UserConfig$12, Config$10, IApi$10>;
 //#endregion
 //#region src/plugins/@pinia/colada/api.d.ts
 type IApi$9 = any;
@@ -8851,7 +8027,7 @@ type UserConfig$11 = Plugin.Name<'@pinia/colada'> & Plugin.Hooks & {
     name?: StringName;
   };
 };
-type Config$10 = Plugin.Name<'@pinia/colada'> & Plugin.Hooks & {
+type Config$9 = Plugin.Name<'@pinia/colada'> & Plugin.Hooks & {
   /**
    * The casing convention to use for generated names.
    *
@@ -9000,7 +8176,7 @@ type Config$10 = Plugin.Name<'@pinia/colada'> & Plugin.Hooks & {
     name: StringName;
   };
 };
-type PiniaColadaPlugin = DefinePlugin<UserConfig$11, Config$10, IApi$9>;
+type PiniaColadaPlugin = DefinePlugin<UserConfig$11, Config$9, IApi$9>;
 //#endregion
 //#region src/plugins/@tanstack/angular-query-experimental/api.d.ts
 type IApi$8 = any;
@@ -9287,7 +8463,7 @@ type UserConfig$10 = Plugin.Name<'@tanstack/angular-query-experimental'> & Plugi
     name?: StringName;
   };
 };
-type Config$9 = Plugin.Name<'@tanstack/angular-query-experimental'> & Plugin.Hooks & {
+type Config$8 = Plugin.Name<'@tanstack/angular-query-experimental'> & Plugin.Hooks & {
   /**
    * The casing convention to use for generated names.
    *
@@ -9528,7 +8704,7 @@ type Config$9 = Plugin.Name<'@tanstack/angular-query-experimental'> & Plugin.Hoo
     name: StringName;
   };
 };
-type TanStackAngularQueryPlugin = DefinePlugin<UserConfig$10, Config$9, IApi$8>;
+type TanStackAngularQueryPlugin = DefinePlugin<UserConfig$10, Config$8, IApi$8>;
 //#endregion
 //#region src/plugins/@tanstack/react-query/api.d.ts
 type IApi$7 = any;
@@ -9859,7 +9035,7 @@ type UserConfig$9 = Plugin.Name<'@tanstack/react-query'> & Plugin.Hooks & {
     name?: StringName;
   };
 };
-type Config$8 = Plugin.Name<'@tanstack/react-query'> & Plugin.Hooks & {
+type Config$7 = Plugin.Name<'@tanstack/react-query'> & Plugin.Hooks & {
   /**
    * The casing convention to use for generated names.
    *
@@ -10131,7 +9307,7 @@ type Config$8 = Plugin.Name<'@tanstack/react-query'> & Plugin.Hooks & {
     name: StringName;
   };
 };
-type TanStackReactQueryPlugin = DefinePlugin<UserConfig$9, Config$8, IApi$7>;
+type TanStackReactQueryPlugin = DefinePlugin<UserConfig$9, Config$7, IApi$7>;
 //#endregion
 //#region src/plugins/@tanstack/solid-query/api.d.ts
 type IApi$6 = any;
@@ -10419,7 +9595,7 @@ type UserConfig$8 = Plugin.Name<'@tanstack/solid-query'> & Plugin.Hooks & {
     name?: StringName;
   };
 };
-type Config$7 = Plugin.Name<'@tanstack/solid-query'> & Plugin.Hooks & {
+type Config$6 = Plugin.Name<'@tanstack/solid-query'> & Plugin.Hooks & {
   /**
    * The casing convention to use for generated names.
    *
@@ -10660,7 +9836,7 @@ type Config$7 = Plugin.Name<'@tanstack/solid-query'> & Plugin.Hooks & {
     name: StringName;
   };
 };
-type TanStackSolidQueryPlugin = DefinePlugin<UserConfig$8, Config$7, IApi$6>;
+type TanStackSolidQueryPlugin = DefinePlugin<UserConfig$8, Config$6, IApi$6>;
 //#endregion
 //#region src/plugins/@tanstack/svelte-query/api.d.ts
 type IApi$5 = any;
@@ -10947,7 +10123,7 @@ type UserConfig$7 = Plugin.Name<'@tanstack/svelte-query'> & Plugin.Hooks & {
     name?: StringName;
   };
 };
-type Config$6 = Plugin.Name<'@tanstack/svelte-query'> & Plugin.Hooks & {
+type Config$5 = Plugin.Name<'@tanstack/svelte-query'> & Plugin.Hooks & {
   /**
    * The casing convention to use for generated names.
    *
@@ -11188,7 +10364,7 @@ type Config$6 = Plugin.Name<'@tanstack/svelte-query'> & Plugin.Hooks & {
     name: StringName;
   };
 };
-type TanStackSvelteQueryPlugin = DefinePlugin<UserConfig$7, Config$6, IApi$5>;
+type TanStackSvelteQueryPlugin = DefinePlugin<UserConfig$7, Config$5, IApi$5>;
 //#endregion
 //#region src/plugins/@tanstack/vue-query/api.d.ts
 type IApi$4 = any;
@@ -11478,7 +10654,7 @@ type UserConfig$6 = Plugin.Name<'@tanstack/vue-query'> & Plugin.Hooks & {
     name?: StringName;
   };
 };
-type Config$5 = Plugin.Name<'@tanstack/vue-query'> & Plugin.Hooks & {
+type Config$4 = Plugin.Name<'@tanstack/vue-query'> & Plugin.Hooks & {
   /**
    * The casing convention to use for generated names.
    *
@@ -11722,7 +10898,7 @@ type Config$5 = Plugin.Name<'@tanstack/vue-query'> & Plugin.Hooks & {
     name: StringName;
   };
 };
-type TanStackVueQueryPlugin = DefinePlugin<UserConfig$6, Config$5, IApi$4>;
+type TanStackVueQueryPlugin = DefinePlugin<UserConfig$6, Config$4, IApi$4>;
 //#endregion
 //#region src/plugins/arktype/shared/types.d.ts
 type ValidatorArgs$2 = {
@@ -12082,7 +11258,7 @@ type UserConfig$5 = Plugin.Name<'arktype'> & Plugin.Hooks & {
     };
   };
 };
-type Config$4 = Plugin.Name<'arktype'> & Plugin.Hooks & {
+type Config$3 = Plugin.Name<'arktype'> & Plugin.Hooks & {
   /**
    * The casing convention to use for generated names.
    *
@@ -12366,7 +11542,7 @@ type Config$4 = Plugin.Name<'arktype'> & Plugin.Hooks & {
     };
   };
 };
-type ArktypePlugin = DefinePlugin<UserConfig$5, Config$4, IApi$3>;
+type ArktypePlugin = DefinePlugin<UserConfig$5, Config$3, IApi$3>;
 //#endregion
 //#region src/plugins/fastify/api.d.ts
 type IApi$2 = any;
@@ -12554,7 +11730,7 @@ type UserConfig$3 = Plugin.Name<'valibot'> & Plugin.Hooks & {
     name?: StringName;
   };
 };
-type Config$3 = Plugin.Name<'valibot'> & Plugin.Hooks & {
+type Config$2 = Plugin.Name<'valibot'> & Plugin.Hooks & {
   /**
    * The casing convention to use for generated names.
    *
@@ -12690,7 +11866,7 @@ type Config$3 = Plugin.Name<'valibot'> & Plugin.Hooks & {
     name: StringName;
   };
 };
-type ValibotPlugin = DefinePlugin<UserConfig$3, Config$3, IApi$1>;
+type ValibotPlugin = DefinePlugin<UserConfig$3, Config$2, IApi$1>;
 //#endregion
 //#region src/plugins/zod/shared/types.d.ts
 type ValidatorArgs = {
@@ -13089,7 +12265,7 @@ type UserConfig$2 = Plugin.Name<'zod'> & Plugin.Hooks & {
     };
   };
 };
-type Config$2 = Plugin.Name<'zod'> & Plugin.Hooks & {
+type Config$1 = Plugin.Name<'zod'> & Plugin.Hooks & {
   /**
    * The casing convention to use for generated names.
    *
@@ -13410,7 +12586,7 @@ type Config$2 = Plugin.Name<'zod'> & Plugin.Hooks & {
     };
   };
 };
-type ZodPlugin = DefinePlugin<UserConfig$2, Config$2, IApi>;
+type ZodPlugin = DefinePlugin<UserConfig$2, Config$1, IApi>;
 //#endregion
 //#region src/plugins/config.d.ts
 interface PluginConfigMap {
@@ -13433,22 +12609,36 @@ interface PluginConfigMap {
   '@tanstack/vue-query': TanStackVueQueryPlugin['Types'];
   arktype: ArktypePlugin['Types'];
   fastify: FastifyPlugin['Types'];
-  'legacy/angular': HeyApiClientLegacyAngularPlugin['Types'];
-  'legacy/axios': HeyApiClientLegacyAxiosPlugin['Types'];
-  'legacy/fetch': HeyApiClientLegacyFetchPlugin['Types'];
-  'legacy/node': HeyApiClientLegacyNodePlugin['Types'];
-  'legacy/xhr': HeyApiClientLegacyXhrPlugin['Types'];
   valibot: ValibotPlugin['Types'];
   zod: ZodPlugin['Types'];
 }
 //#endregion
+//#region src/utils/logger.d.ts
+declare class Logger {
+  private events;
+  private end;
+  /**
+   * Recursively end all unended events in the event tree.
+   * This ensures all events have end marks before measuring.
+   */
+  private endAllEvents;
+  report(print?: boolean): PerformanceMeasure | undefined;
+  private reportEvent;
+  private start;
+  private storeEvent;
+  timeEvent(name: string): {
+    mark: PerformanceMark;
+    timeEnd: () => void;
+  };
+}
+//#endregion
 //#region src/ir/context.d.ts
-declare class Context<Spec$1 extends Record<string, any> = any> {
+declare class Context<Spec extends Record<string, any> = any> {
   /**
    * Configuration for parsing and generating the output. This
    * is a mix of user-provided and default values.
    */
-  config: Config$1;
+  config: Config;
   /**
    * The code generation project instance used to manage files, symbols,
    */
@@ -13481,17 +12671,17 @@ declare class Context<Spec$1 extends Record<string, any> = any> {
   /**
    * Resolved specification from `input`.
    */
-  spec: Spec$1;
+  spec: Spec;
   constructor({
     config,
     dependencies,
     logger,
     spec
   }: {
-    config: Config$1;
+    config: Config;
     dependencies: Record<string, string>;
     logger: Logger;
-    spec: Spec$1;
+    spec: Spec;
   });
   /**
    * Returns a resolved and dereferenced schema from `spec`.
@@ -13521,183 +12711,465 @@ declare class Context<Spec$1 extends Record<string, any> = any> {
   resolveRef<T>($ref: string): T;
 }
 //#endregion
-//#region src/ir/mediaType.d.ts
-type IRMediaType = 'form-data' | 'json' | 'text' | 'url-search-params' | 'octet-stream';
+//#region src/ir/graph.d.ts
+declare const irTopLevelKinds: readonly ["operation", "parameter", "requestBody", "schema", "server", "webhook"];
+type IrTopLevelKind = (typeof irTopLevelKinds)[number];
 //#endregion
-//#region src/ir/types.d.ts
-interface IRBodyObject {
-  mediaType: string;
-  /**
-   * Does body control pagination? We handle only simple values
-   * for now, up to 1 nested field.
-   */
-  pagination?: boolean | string;
-  required?: boolean;
-  schema: IRSchemaObject;
-  type?: IRMediaType;
+//#region src/openApi/types.d.ts
+declare namespace OpenApi {
+  export type V2_0_X = OpenApiV2_0_X;
+  export type V3_0_X = OpenApiV3_0_X;
+  export type V3_1_X = OpenApiV3_1_X;
 }
-interface IRComponentsObject {
-  parameters?: Record<string, IRParameterObject>;
-  requestBodies?: Record<string, IRRequestBodyObject>;
-  schemas?: Record<string, IRSchemaObject>;
+declare namespace OpenApiMetaObject {
+  export type V2_0_X = OpenApiV2_0_XTypes['InfoObject'];
+  export type V3_0_X = OpenApiV3_0_XTypes['InfoObject'];
+  export type V3_1_X = OpenApiV3_1_XTypes['InfoObject'];
 }
-interface IROperationObject {
-  body?: IRBodyObject;
-  deprecated?: boolean;
-  description?: string;
-  id: string;
-  method: keyof IRPathItemObject;
-  operationId?: string;
-  parameters?: IRParametersObject;
-  path: keyof IRPathsObject;
-  responses?: IRResponsesObject;
-  security?: ReadonlyArray<IRSecurityObject>;
-  servers?: ReadonlyArray<IRServerObject>;
-  summary?: string;
-  tags?: ReadonlyArray<string>;
+declare namespace OpenApiOperationObject {
+  export type V2_0_X = OpenApiV2_0_XTypes['OperationObject'];
+  export type V3_0_X = OpenApiV3_0_XTypes['OperationObject'];
+  export type V3_1_X = OpenApiV3_1_XTypes['OperationObject'];
 }
-interface IRParametersObject {
-  cookie?: Record<string, IRParameterObject>;
-  header?: Record<string, IRParameterObject>;
-  path?: Record<string, IRParameterObject>;
-  query?: Record<string, IRParameterObject>;
+declare namespace OpenApiParameterObject {
+  export type V3_0_X = OpenApiV3_0_XTypes['ParameterObject'] | OpenApiV3_0_XTypes['ReferenceObject'];
+  export type V3_1_X = OpenApiV3_1_XTypes['ParameterObject'] | OpenApiV3_1_XTypes['ReferenceObject'];
+}
+declare namespace OpenApiRequestBodyObject {
+  export type V3_0_X = OpenApiV3_0_XTypes['RequestBodyObject'] | OpenApiV3_0_XTypes['ReferenceObject'];
+  export type V3_1_X = OpenApiV3_1_XTypes['RequestBodyObject'] | OpenApiV3_1_XTypes['ReferenceObject'];
+}
+declare namespace OpenApiResponseObject {
+  export type V3_0_X = OpenApiV3_0_XTypes['ResponseObject'] | OpenApiV3_0_XTypes['ReferenceObject'];
+  export type V3_1_X = OpenApiV3_1_XTypes['ResponseObject'] | OpenApiV3_1_XTypes['ReferenceObject'];
 }
-interface IRParameterObject extends Pick<JsonSchemaDraft2020_12, 'deprecated' | 'description'> {
+declare namespace OpenApiSchemaObject {
+  export type V2_0_X = OpenApiV2_0_XTypes['SchemaObject'];
+  export type V3_0_X = OpenApiV3_0_XTypes['SchemaObject'];
+  export type V3_1_X = OpenApiV3_1_XTypes['SchemaObject'];
+}
+//#endregion
+//#region src/plugins/shared/types/instance.d.ts
+type BaseEvent = {
   /**
-   * Determines whether the parameter value SHOULD allow reserved characters, as defined by RFC3986 `:/?#[]@!$&'()*+,;=` to be included without percent-encoding. The default value is `false`. This property SHALL be ignored if the request body media type is not `application/x-www-form-urlencoded` or `multipart/form-data`. If a value is explicitly defined, then the value of `contentType` (implicit or explicit) SHALL be ignored.
+   * Path to the node, derived from the pointer.
    */
-  allowReserved?: boolean;
+  _path: ReadonlyArray<string | number>;
   /**
-   * When this is true, property values of type `array` or `object` generate separate parameters for each value of the array, or key-value-pair of the map. For other types of properties this property has no effect. When `style` is `form`, the default value is `true`. For all other styles, the default value is `false`. This property SHALL be ignored if the request body media type is not `application/x-www-form-urlencoded` or `multipart/form-data`. If a value is explicitly defined, then the value of `contentType` (implicit or explicit) SHALL be ignored.
+   * Pointer to the node in the graph.
    */
-  explode: boolean;
+  pointer: string;
   /**
-   * Endpoint parameters must specify their location.
+   * Tags associated with the node.
    */
-  location: 'cookie' | 'header' | 'path' | 'query';
+  tags?: ReadonlyArray<string>;
+};
+type WalkEvents = BaseEvent & ({
+  method: keyof IR$1.PathItemObject;
+  operation: IR$1.OperationObject;
+  path: string;
+  type: Extract<IrTopLevelKind, 'operation'>;
+} | {
   name: string;
+  parameter: IR$1.ParameterObject;
+  type: Extract<IrTopLevelKind, 'parameter'>;
+} | {
+  name: string;
+  requestBody: IR$1.RequestBodyObject;
+  type: Extract<IrTopLevelKind, 'requestBody'>;
+} | {
+  name: string;
+  schema: IR$1.SchemaObject;
+  type: Extract<IrTopLevelKind, 'schema'>;
+} | {
+  server: IR$1.ServerObject;
+  type: Extract<IrTopLevelKind, 'server'>;
+} | {
+  key: string;
+  method: keyof IR$1.PathItemObject;
+  operation: IR$1.OperationObject;
+  type: Extract<IrTopLevelKind, 'webhook'>;
+});
+type WalkEvent<T extends IrTopLevelKind = IrTopLevelKind> = Extract<WalkEvents, {
+  type: T;
+}>;
+//#endregion
+//#region src/plugins/shared/utils/instance.d.ts
+declare class PluginInstance<T extends Plugin.Types = Plugin.Types> {
+  api: T['api'];
+  config: Omit<T['resolvedConfig'], 'name' | 'output'>;
+  context: Context;
+  dependencies: Required<Plugin.Config<T>>['dependencies'];
+  private eventHooks;
+  gen: IProject;
+  private handler;
+  name: T['resolvedConfig']['name'];
+  output: string;
   /**
-   * Does this parameter control pagination? We handle only simple values
-   * for now, up to 1 nested field.
-   */
-  pagination?: boolean | string;
-  required?: boolean;
-  schema: IRSchemaObject;
-  /**
-   * Describes how the parameter value will be serialized depending on the type of the parameter value. Default values (based on value of `in`): for `query` - `form`; for `path` - `simple`; for `header` - `simple`; for `cookie` - `form`.
+   * The package metadata and utilities for the current context, constructed
+   * from the provided dependencies. Used for managing package-related
+   * information such as name, version, and dependency resolution during
+   * code generation.
    */
-  style: 'deepObject' | 'form' | 'label' | 'matrix' | 'pipeDelimited' | 'simple' | 'spaceDelimited';
-}
-interface IRPathsObject {
-  [path: `/${string}`]: IRPathItemObject;
-}
-interface IRPathItemObject {
-  delete?: IROperationObject;
-  get?: IROperationObject;
-  head?: IROperationObject;
-  options?: IROperationObject;
-  patch?: IROperationObject;
-  post?: IROperationObject;
-  put?: IROperationObject;
-  trace?: IROperationObject;
-}
-interface IRRequestBodyObject extends Pick<JsonSchemaDraft2020_12, 'description'> {
-  required?: boolean;
-  schema: IRSchemaObject;
-}
-interface IRResponsesObject {
+  package: Context['package'];
+  constructor(props: Pick<Required<Plugin.Config<T>>, 'config' | 'dependencies' | 'handler'> & {
+    api?: T['api'];
+    context: Context<OpenApi.V2_0_X | OpenApi.V3_0_X | OpenApi.V3_1_X>;
+    gen: IProject;
+    name: string;
+    output: string;
+  });
   /**
-   * Any {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#http-status-codes HTTP status code} can be used as the property name, but only one property per code, to describe the expected response for that HTTP status code. This field MUST be enclosed in quotation marks (for example, "200") for compatibility between JSON and YAML. To define a range of response codes, this field MAY contain the uppercase wildcard character `X`. For example, `2XX` represents all response codes between `[200-299]`. Only the following range definitions are allowed: `1XX`, `2XX`, `3XX`, `4XX`, and `5XX`. If a response is defined using an explicit code, the explicit code definition takes precedence over the range definition for that code.
+   * Iterates over various input elements as specified by the event types, in
+   * a specific order: servers, schemas, parameters, request bodies, then
+   * operations.
+   *
+   * This ensures, for example, that schemas are always processed before
+   * operations, which may reference them.
+   *
+   * @template TKind - The event type(s) to yield. Defaults to all event types.
+   * @param events - The event types to walk over. If none are provided, all event types are included.
+   * @param callback - Function to execute for each event.
+   *
+   * @example
+   * // Iterate over all operations and schemas
+   * plugin.forEach('operation', 'schema', (event) => {
+   *   if (event.type === 'operation') {
+   *     // handle operation
+   *   } else if (event.type === 'schema') {
+   *     // handle schema
+   *   }
+   * });
    */
-  [statusCode: string]: IRResponseObject | undefined;
+  forEach<TKind extends IrTopLevelKind = IrTopLevelKind>(...args: [...events: ReadonlyArray<TKind>, callback: (event: WalkEvent<TKind>) => void]): void;
+  forEach<TKind extends IrTopLevelKind = IrTopLevelKind>(...args: [...events: ReadonlyArray<TKind>, callback: (event: WalkEvent<TKind>) => void, options: WalkOptions<TKind>]): void;
   /**
-   * The documentation of responses other than the ones declared for specific HTTP response codes. Use this field to cover undeclared responses.
+   * Retrieves a registered plugin instance by its name from the context. This
+   * allows plugins to access other plugins that have been registered in the
+   * same context, enabling cross-plugin communication and dependencies.
+   *
+   * @param name Plugin name as defined in the configuration.
+   * @returns The plugin instance if found, undefined otherwise.
    */
-  default?: IRResponseObject;
-}
-interface IRResponseObject {
-  // TODO: parser - handle headers, links, and possibly other media types?
-  mediaType?: string;
-  schema: IRSchemaObject;
-}
-interface IRSchemaObject extends Pick<JsonSchemaDraft2020_12, '$ref' | 'const' | 'default' | 'deprecated' | 'description' | 'exclusiveMaximum' | 'exclusiveMinimum' | 'maximum' | 'maxItems' | 'maxLength' | 'minimum' | 'minItems' | 'minLength' | 'pattern' | 'required' | 'title' | 'example'> {
+  getPlugin<TName extends keyof PluginConfigMap>(name: TName): TName extends any ? PluginInstance<PluginConfigMap[TName]> | undefined : never;
   /**
-   * If the schema is intended to be used as an object property, it can be
-   * marked as read-only or write-only. This value controls whether the schema
-   * receives the "readonly" TypeScript keyword.
+   * Retrieves a registered plugin instance by its name from the context. This
+   * allows plugins to access other plugins that have been registered in the
+   * same context, enabling cross-plugin communication and dependencies.
+   *
+   * @param name Plugin name as defined in the configuration.
+   * @returns The plugin instance if found, throw otherwise.
    */
-  accessScope?: 'read' | 'write';
+  getPluginOrThrow<TName extends keyof PluginConfigMap>(name: TName): TName extends any ? PluginInstance<PluginConfigMap[TName]> : never;
+  getSymbol(identifier: SymbolIdentifier): Symbol | undefined;
+  hooks: {
+    operation: {
+      isMutation: (operation: IR$1.OperationObject) => boolean;
+      isQuery: (operation: IR$1.OperationObject) => boolean;
+    };
+  };
+  isSymbolRegistered(identifier: SymbolIdentifier): boolean;
+  querySymbol(filter: SymbolMeta): Symbol | undefined;
+  referenceSymbol(meta: SymbolMeta): Symbol;
+  registerSymbol(symbol: SymbolIn): Symbol;
   /**
-   * If type is `object`, `additionalProperties` can be used to either define
-   * a schema for properties not included in `properties` or disallow such
-   * properties altogether.
+   * Executes plugin's handler function.
    */
-  additionalProperties?: IRSchemaObject | false;
+  run(): Promise<void>;
+  setSymbolValue(symbol: Symbol, value: unknown): void;
+  private buildEventHooks;
+  private forEachError;
+  private getSymbolFilePath;
+  private isOperationKind;
+}
+//#endregion
+//#region src/parser/types/hooks.d.ts
+type Hooks = {
   /**
-   * Any string value is accepted as `format`.
+   * Event hooks.
    */
-  format?: JsonSchemaDraft2020_12['format'] | 'binary' | 'integer';
+  events?: {
+    /**
+     * Triggered after executing a plugin handler.
+     *
+     * @param args Arguments object.
+     * @returns void
+     */
+    'plugin:handler:after'?: (args: {
+      /** Plugin that just executed. */
+      plugin: PluginInstance;
+    }) => void;
+    /**
+     * Triggered before executing a plugin handler.
+     *
+     * @param args Arguments object.
+     * @returns void
+     */
+    'plugin:handler:before'?: (args: {
+      /** Plugin about to execute. */
+      plugin: PluginInstance;
+    }) => void;
+    /**
+     * Triggered after registering a symbol.
+     *
+     * You can use this to perform actions after a symbol is registered.
+     *
+     * @param args Arguments object.
+     * @returns void
+     */
+    'symbol:register:after'?: (args: {
+      /** Plugin that registered the symbol. */
+      plugin: PluginInstance;
+      /** The registered symbol. */
+      symbol: Symbol;
+    }) => void;
+    /**
+     * Triggered before registering a symbol.
+     *
+     * You can use this to modify the symbol before it's registered.
+     *
+     * @param args Arguments object.
+     * @returns void
+     */
+    'symbol:register:before'?: (args: {
+      /** Plugin registering the symbol. */
+      plugin: PluginInstance;
+      /** Symbol to register. */
+      symbol: SymbolIn;
+    }) => void;
+    /**
+     * Triggered after setting a symbol value.
+     *
+     * You can use this to perform actions after a symbol's value is set.
+     *
+     * @param args Arguments object.
+     * @returns void
+     */
+    'symbol:setValue:after'?: (args: {
+      /** Plugin that set the symbol value. */
+      plugin: PluginInstance;
+      /** The symbol. */
+      symbol: Symbol;
+      /** The value that was set. */
+      value: unknown;
+    }) => void;
+    /**
+     * Triggered before setting a symbol value.
+     *
+     *  You can use this to modify the value before it's set.
+     *
+     * @param args Arguments object.
+     * @returns void
+     */
+    'symbol:setValue:before'?: (args: {
+      /** Plugin setting the symbol value. */
+      plugin: PluginInstance;
+      /** The symbol. */
+      symbol: Symbol;
+      /** The value to set. */
+      value: unknown;
+    }) => void;
+  };
   /**
-   * If schema resolves into multiple items instead of a simple `type`, they
-   * will be included in `items` array.
+   * Hooks specifically for overriding operations behavior.
+   *
+   * Use these to classify operations, decide which outputs to generate,
+   * or apply custom behavior to individual operations.
    */
-  items?: ReadonlyArray<IRSchemaObject>;
+  operations?: {
+    /**
+     * Classify the given operation into one or more kinds.
+     *
+     * Each kind determines how we treat the operation (e.g., generating queries or mutations).
+     *
+     * **Default behavior:**
+     * - GET → 'query'
+     * - DELETE, PATCH, POST, PUT → 'mutation'
+     *
+     * **Resolution order:**
+     * 1. If `isQuery` or `isMutation` returns `true` or `false`, that overrides `getKind`.
+     * 2. If `isQuery` or `isMutation` returns `undefined`, the result of `getKind` is used.
+     *
+     * @param operation - The operation object to classify.
+     * @returns An array containing one or more of 'query' or 'mutation', or undefined to fallback to default behavior.
+     * @example
+     * ```ts
+     * getKind: (operation) => {
+     *   if (operation.method === 'get' && operation.path === '/search') {
+     *     return ['query', 'mutation'];
+     *   }
+     *   return; // fallback to default behavior
+     * }
+     * ```
+     */
+    getKind?: (operation: IROperationObject) => ReadonlyArray<'mutation' | 'query'> | undefined;
+    /**
+     * Check if the given operation should be treated as a mutation.
+     *
+     * This affects which outputs are generated for the operation.
+     *
+     * **Default behavior:** DELETE, PATCH, POST, and PUT operations are treated as mutations.
+     *
+     * **Resolution order:** If this returns `true` or `false`, it overrides `getKind`.
+     * If it returns `undefined`, `getKind` is used instead.
+     *
+     * @param operation - The operation object to check.
+     * @returns true if the operation is a mutation, false otherwise, or undefined to fallback to `getKind`.
+     * @example
+     * ```ts
+     * isMutation: (operation) => {
+     *   if (operation.method === 'post' && operation.path === '/search') {
+     *     return true;
+     *   }
+     *   return; // fallback to default behavior
+     * }
+     * ```
+     */
+    isMutation?: (operation: IROperationObject) => boolean | undefined;
+    /**
+     * Check if the given operation should be treated as a query.
+     *
+     * This affects which outputs are generated for the operation.
+     *
+     * **Default behavior:** GET operations are treated as queries.
+     *
+     * **Resolution order:** If this returns `true` or `false`, it overrides `getKind`.
+     * If it returns `undefined`, `getKind` is used instead.
+     *
+     * @param operation - The operation object to check.
+     * @returns true if the operation is a query, false otherwise, or undefined to fallback to `getKind`.
+     * @example
+     * ```ts
+     * isQuery: (operation) => {
+     *   if (operation.method === 'post' && operation.path === '/search') {
+     *     return true;
+     *   }
+     *   return; // fallback to default behavior
+     * }
+     * ```
+     */
+    isQuery?: (operation: IROperationObject) => boolean | undefined;
+  };
   /**
-   * When resolving a list of items, we need to know the relationship between
-   * them. `logicalOperator` specifies this logical relationship.
+   * Hooks specifically for overriding symbols behavior.
    *
-   * @default 'or'
+   * Use these to customize file placement.
    */
-  logicalOperator?: 'and' | 'or';
+  symbols?: {
+    /**
+     * Optional output strategy to override default plugin behavior.
+     *
+     * Use this to route generated symbols to specific files.
+     *
+     * @returns The file path to output the symbol to, or undefined to fallback to default behavior.
+     */
+    getFilePath?: (symbol: Symbol) => string | undefined;
+  };
+};
+//#endregion
+//#region src/plugins/types.d.ts
+type PluginClientNames = '@hey-api/client-angular' | '@hey-api/client-axios' | '@hey-api/client-fetch' | '@hey-api/client-next' | '@hey-api/client-nuxt' | '@hey-api/client-ofetch';
+type PluginValidatorNames = 'arktype' | 'valibot' | 'zod';
+type PluginNames = PluginClientNames | '@angular/common' | '@hey-api/schemas' | '@hey-api/sdk' | '@hey-api/transformers' | '@hey-api/typescript' | '@pinia/colada' | '@tanstack/angular-query-experimental' | '@tanstack/react-query' | '@tanstack/solid-query' | '@tanstack/svelte-query' | '@tanstack/vue-query' | 'fastify' | PluginValidatorNames;
+type AnyPluginName = PluginNames | (string & {});
+type PluginTag = 'client' | 'transformer' | 'validator';
+type PluginContext = {
+  package: Package;
+  pluginByTag: <T extends AnyPluginName | boolean = AnyPluginName>(tag: PluginTag, props?: {
+    defaultPlugin?: Exclude<T, boolean>;
+    errorMessage?: string;
+  }) => Exclude<T, boolean> | undefined;
+  valueToObject: ValueToObject;
+};
+type BaseApi = Record<string, unknown>;
+type BaseConfig = {
   /**
-   * When type is `object`, `patternProperties` can be used to define a schema
-   * for properties that match a specific regex pattern.
+   * Should the exports from the plugin's file be re-exported in the index
+   * barrel file?
    */
-  patternProperties?: Record<string, IRSchemaObject>;
+  exportFromIndex?: boolean;
+  name: AnyPluginName;
   /**
-   * When type is `object`, `properties` will contain a map of its properties.
+   * Optional hooks to override default plugin behavior.
+   *
+   * Use these to classify resources, control which outputs are generated,
+   * or provide custom behavior for specific resources.
    */
-  properties?: Record<string, IRSchemaObject>;
+  '~hooks'?: Hooks;
+};
+
+/**
+ * Public Plugin API.
+ */
+declare namespace Plugin {
+  export type Config<T extends Types> = Pick<T, 'api'> & {
+    config: Omit<T['config'], 'name' | 'output'>;
+    /**
+     * Dependency plugins will be always processed, regardless of whether user
+     * explicitly defines them in their `plugins` config.
+     */
+    dependencies?: ReadonlyArray<AnyPluginName>;
+    handler: Handler<T>;
+    name: T['config']['name'];
+    output?: NonNullable<T['config']['output']>;
+    /**
+     * Resolves static configuration values into their runtime equivalents. For
+     * example, when `validator` is set to `true`, it figures out which plugin
+     * should be used for validation.
+     */
+    resolveConfig?: (plugin: Omit<Plugin.Config<T>, 'dependencies'> & {
+      dependencies: Set<AnyPluginName>;
+    }, context: PluginContext) => void;
+    /**
+     * Optional tags can be used to help with deciding plugin order and resolving
+     * plugin configuration options.
+     */
+    tags?: ReadonlyArray<PluginTag>;
+  };
+  export type ConfigWithName<T extends Types> = Omit<Config$21<T>, 'config'> & {
+    config: Omit<T['config'], 'output'>;
+  };
+
+  /** @deprecated use `definePluginConfig()` instead */
+  export type DefineConfig<Config$21 extends BaseConfig, ResolvedConfig extends BaseConfig = Config$21> = (config?: UserConfig<Omit<Config$21, 'name'>>) => Omit<Plugin.Config<Config$21, ResolvedConfig>, 'name'> & {
+    /**
+     * Cast name to `any` so it doesn't throw type error in `plugins` array.
+     * We could allow any `string` as plugin `name` in the object syntax, but
+     * that TypeScript trick would cause all string methods to appear as
+     * suggested auto completions, which is undesirable.
+     */
+    name: any;
+  };
+
   /**
-   * The names of `properties` can be validated against a schema, irrespective
-   * of their values. This can be useful if you don't want to enforce specific
-   * properties, but you want to make sure that the names of those properties
-   * follow a specific convention.
+   * Generic wrapper for plugin hooks.
    */
-  propertyNames?: IRSchemaObject;
+  export type Hooks = Pick<BaseConfig, '~hooks'>;
+  export interface Name<Name extends PluginNames> {
+    name: Name;
+  }
+  export type Types<Config$21 extends BaseConfig = BaseConfig, ResolvedConfig extends BaseConfig = Config$21, Api extends BaseApi = never> = ([Api] extends [never] ? {
+    api?: BaseApi;
+  } : {
+    api: Api;
+  }) & {
+    config: Config$21;
+    resolvedConfig: ResolvedConfig;
+  };
+
   /**
-   * Each schema eventually resolves into `type`.
+   * Users cannot modify output file path to avoid risk of conflicts.
    */
-  type?: 'array' | 'boolean' | 'enum' | 'integer' | 'never' | 'null' | 'number' | 'object' | 'string' | 'tuple' | 'undefined' | 'unknown' | 'void';
-}
-type IRSecurityObject = SecuritySchemeObject;
-type IRServerObject = ServerObject;
-type IRWebhookObject = IRPathItemObject;
-interface IRModel {
-  components?: IRComponentsObject;
-  paths?: IRPathsObject;
-  servers?: ReadonlyArray<IRServerObject>;
-  webhooks?: Record<string, IRWebhookObject>;
-}
-declare namespace IR$1 {
-  export type BodyObject = IRBodyObject;
-  export type ComponentsObject = IRComponentsObject;
-  export type Context<Spec extends Record<string, any> = any> = Context<Spec>;
-  export type Model = IRModel;
-  export type OperationObject = IROperationObject;
-  export type ParameterObject = IRParameterObject;
-  export type ParametersObject = IRParametersObject;
-  export type PathItemObject = IRPathItemObject;
-  export type PathsObject = IRPathsObject;
-  export type ReferenceObject = ReferenceObject;
-  export type RequestBodyObject = IRRequestBodyObject;
-  export type ResponseObject = IRResponseObject;
-  export type ResponsesObject = IRResponsesObject;
-  export type SchemaObject = IRSchemaObject;
-  export type SecurityObject = IRSecurityObject;
-  export type ServerObject = IRServerObject;
-  export type WebhookObject = IRWebhookObject;
+  export type UserConfig<Config$21 extends BaseConfig> = Omit<Config$21, 'output'>;
 }
+type DefinePlugin<Config$21 extends BaseConfig = BaseConfig, ResolvedConfig extends BaseConfig = Config$21, Api extends BaseApi = never> = {
+  Config: Plugin.Config<Plugin.Types<Config$21, ResolvedConfig, Api>>;
+  Handler: (args: {
+    plugin: PluginInstance<Plugin.Types<Config$21, ResolvedConfig, Api>>;
+  }) => void;
+  Instance: PluginInstance<Plugin.Types<Config$21, ResolvedConfig, Api>>;
+  Types: Plugin.Types<Config$21, ResolvedConfig, Api>;
+};
 //#endregion
 //#region src/types/input.d.ts
 type JsonSchema = Record<string, unknown>;
@@ -14728,61 +14200,12 @@ interface UserConfig$1 {
   plugins?: ReadonlyArray<PluginNames | { [K in PluginNames]: Plugin.UserConfig<PluginConfigMap[K]['config']> & {
     name: K;
   } }[PluginNames]>;
-
-  // DEPRECATED OPTIONS BELOW
-
-  /**
-   * Manually set base in OpenAPI config instead of inferring from server value
-   *
-   * @deprecated
-   */
-  // eslint-disable-next-line typescript-sort-keys/interface
-  base?: string;
-  /**
-   * Opt in to the experimental parser?
-   *
-   * @deprecated
-   * @default true
-   */
-  experimentalParser?: boolean;
-  /**
-   * Generate core client classes?
-   *
-   * @deprecated
-   * @default true
-   */
-  exportCore?: boolean;
-  /**
-   * Custom client class name. Please note this option is deprecated and
-   * will be removed in favor of clients.
-   *
-   * @deprecated
-   * @link https://heyapi.dev/openapi-ts/migrating.html#deprecated-name
-   */
-  name?: string;
-  /**
-   * Path to custom request file. Please note this option is deprecated and
-   * will be removed in favor of clients.
-   *
-   * @deprecated
-   * @link https://heyapi.dev/openapi-ts/migrating.html#deprecated-request
-   */
-  request?: string;
-  /**
-   * Use options or arguments functions. Please note this option is deprecated and
-   * will be removed in favor of clients.
-   *
-   * @deprecated
-   * @default true
-   * @link https://heyapi.dev/openapi-ts/migrating.html#deprecated-useoptions
-   */
-  useOptions?: boolean;
   /**
    * @deprecated use `input.watch` instead
    */
   watch?: boolean | number | Watch;
 }
-type Config$1 = Omit<Required<UserConfig$1>, 'base' | 'input' | 'logs' | 'name' | 'output' | 'parser' | 'plugins' | 'request' | 'watch'> & Pick<UserConfig$1, 'base' | 'name' | 'request'> & {
+type Config = Omit<Required<UserConfig$1>, 'input' | 'logs' | 'output' | 'parser' | 'plugins' | 'watch'> & {
   /**
    * Path to the input specification.
    */
@@ -14801,27 +14224,5 @@ type Config$1 = Omit<Required<UserConfig$1>, 'base' | 'input' | 'logs' | 'name'
   plugins: { [K in PluginNames]?: Plugin.ConfigWithName<PluginConfigMap[K]> };
 };
 //#endregion
-//#region src/types/types.d.ts
-declare namespace LegacyIR {
-  export type LegacyOperation = Operation;
-}
-interface WatchValues {
-  /**
-   * Headers to be sent with each HEAD and/or GET request. This effectively
-   * serves as a mechanism resolver because setting certain headers will opt
-   * into comparing the specifications using that method.
-   */
-  headers: Headers;
-  /**
-   * Can we send a HEAD request instead of fetching the whole specification?
-   * This value will be set after the first successful fetch.
-   */
-  isHeadMethodSupported?: boolean;
-  /**
-   * String content of the last successfully fetched specification.
-   */
-  lastValue?: string;
-}
-//#endregion
-export { AccessLevel as A, PluginHandler as C, Comments as D, MaybeArray as E, types_d_exports as F, __export as I, FunctionTypeParameter as M, ObjectValue as N, ImportExportItemObject as O, SyntaxKindKeyword as P, Client$2 as S, LazyOrAsync as T, OpenApiRequestBodyObject as _, Input as a, parseOpenApiSpec as b, ExpressionTransformer as c, Client as d, Operation as f, OpenApiParameterObject as g, OpenApiOperationObject as h, UserConfig$1 as i, FunctionParameter as j, tsNodeToString as k, DefinePlugin as l, OpenApiMetaObject as m, WatchValues as n, IR$1 as o, OpenApi$1 as p, Config$1 as r, TypeTransformer as s, LegacyIR as t, Plugin as u, OpenApiResponseObject as v, StringCase as w, Logger as x, OpenApiSchemaObject as y };
-//# sourceMappingURL=types-Bxdq98WE.d.cts.map
+export { Client$6 as C, LazyOrAsync as D, IR$1 as E, MaybeArray as O, Client$5 as S, StringCase as T, Client as _, Plugin as a, Client$3 as b, OpenApiOperationObject as c, OpenApiResponseObject as d, OpenApiSchemaObject as f, ExpressionTransformer as g, TypeTransformer as h, DefinePlugin as i, OpenApiParameterObject as l, Logger as m, UserConfig$1 as n, OpenApi as o, Context as p, Input as r, OpenApiMetaObject as s, Config as t, OpenApiRequestBodyObject as u, PluginHandler as v, Client$7 as w, Client$4 as x, Client$2 as y };
+//# sourceMappingURL=config-oAoGatJ7.d.ts.map