@hey-api/openapi-ts 0.86.2 → 0.86.4

package/dist/{types-DGAzCzMG.d.ts → types-yDJUUQN6.d.ts}

@@ -1,9 +1,8 @@
 import { n as __export } from "./chunk-C-EqMg7d.js";
+import { IProject, Project, Selector, Symbol, SymbolIn, SymbolMeta } from "@hey-api/codegen-core";
 import fs from "node:fs";
-import * as typescript0 from "typescript";
 import ts from "typescript";
 import { RangeOptions, SemVer } from "semver";
-import { IProject, Project, Selector, Symbol, SymbolIn } from "@hey-api/codegen-core";
 
 //#region src/openApi/shared/types/openapi-spec-extensions.d.ts
 interface EnumExtensions {
@@ -2945,52 +2944,7 @@ type Package = {
   satisfies: (nameOrVersion: string | SemVer, range: string, optionsOrLoose?: boolean | RangeOptions) => boolean;
 };
 //#endregion
-//#region src/utils/logger.d.ts
-declare class Logger {
-  private events;
-  private end;
-  report(print?: boolean): PerformanceMeasure | undefined;
-  private reportEvent;
-  private start;
-  private storeEvent;
-  timeEvent(name: string): {
-    mark: PerformanceMark;
-    timeEnd: () => void;
-  };
-}
-//#endregion
-//#region src/openApi/shared/utils/graph.d.ts
-/**
- * Represents the possible access scopes for OpenAPI nodes.
- * - 'normal': Default scope for regular nodes.
- * - 'read': Node is read-only (e.g., readOnly: true).
- * - 'write': Node is write-only (e.g., writeOnly: true).
- */
-type Scope = 'normal' | 'read' | 'write';
-/**
- * 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>;
-};
+//#region src/graph/types/graph.d.ts
 /**
  * The main graph structure for OpenAPI node analysis.
  *
@@ -3026,6 +2980,116 @@ type Graph = {
    */
   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;
+  matched: true;
+} | {
+  kind?: undefined;
+  matched: false;
+};
+type WalkOptions<T$1 extends string = string> = {
+  /**
+   * Optional priority function used to compute a numeric priority for each
+   * pointer. Lower values are emitted earlier. Useful to customize ordering
+   * beyond the built-in group preferences.
+   */
+  getPointerPriority?: GetPointerPriorityFn;
+  /**
+   * Optional function to match a pointer to a group name.
+   *
+   * @param pointer The pointer string
+   * @returns The group name, or undefined if no match
+   */
+  matchPointerToGroup?: MatchPointerToGroupFn<T$1>;
+  /**
+   * Order of walking schemas.
+   *
+   * The "declarations" option ensures that schemas are walked in the order
+   * they are declared in the input document. This is useful for scenarios where
+   * the order of declaration matters, such as when generating code that relies
+   * on the sequence of schema definitions.
+   *
+   * The "topological" option ensures that schemas are walked in an order
+   * where dependencies are visited before the schemas that depend on them.
+   * This is useful for scenarios where you need to process or generate
+   * schemas in a way that respects their interdependencies.
+   *
+   * @default 'topological'
+   */
+  order?: 'declarations' | 'topological';
+  /**
+   * Optional grouping preference for walking. When provided, walk function
+   * will prefer emitting kinds listed earlier in this array when it is safe
+   * to do so (it will only apply the preference when doing so does not
+   * violate dependency ordering).
+   */
+  preferGroups?: ReadonlyArray<T$1>;
+};
+//#endregion
+//#region src/plugins/shared/types/refs.d.ts
+/**
+ * Ref wrapper which ensures a stable reference for a value.
+ *
+ * @example
+ * ```ts
+ * type NumRef = Ref<number>; // { value: number }
+ * const num: NumRef = { value: 42 };
+ * console.log(num.value); // 42
+ * ```
+ */
+type Ref<T$1> = {
+  value: T$1;
+};
+
+/**
+ * Utility type: wraps a value in a Ref.
+ *
+ * @example
+ * ```ts
+ * type R = ToRef<number>; // { value: number }
+ * ```
+ */
+
+/**
+ * Maps every property of `T` to a `Ref` of that property.
+ *
+ * @example
+ * ```ts
+ * type Foo = { a: number; b: string };
+ * type Refs = ToRefs<Foo>; // { a: Ref<number>; b: Ref<string> }
+ * const refs: Refs = { a: { value: 1 }, b: { value: 'x' } };
+ * console.log(refs.a.value, refs.b.value); // 1 'x'
+ * ```
+ */
+type ToRefs<T$1> = { [K in keyof T$1]: Ref<T$1[K]> };
 //#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>>;
@@ -6556,7 +6620,7 @@ interface OpenApiV3_1_XTypes {
 }
 //#endregion
 //#region src/openApi/types.d.ts
-declare namespace OpenApi$1 {
+declare namespace OpenApi$3 {
   export type V2_0_X = OpenApiV2_0_X;
   export type V3_0_X = OpenApiV3_0_X;
   export type V3_1_X = OpenApiV3_1_X;
@@ -6589,51 +6653,372 @@ declare namespace OpenApiSchemaObject {
   export type V3_1_X = OpenApiV3_1_XTypes['SchemaObject'];
 }
 //#endregion
-//#region src/types/parser.d.ts
-type EnumsMode = 'inline' | 'root';
-type UserParser = {
+//#region src/ir/graph.d.ts
+declare const irTopLevelKinds: readonly ["operation", "parameter", "requestBody", "schema", "server", "webhook"];
+type IrTopLevelKind = (typeof irTopLevelKinds)[number];
+//#endregion
+//#region src/plugins/shared/types/instance.d.ts
+type BaseEvent = {
   /**
-   * Filters can be used to select a subset of your input before it's passed
-   * to plugins.
+   * Path to the node, derived from the pointer.
    */
-  filters?: Filters;
+  _path: ReadonlyArray<string | number>;
   /**
-   * Optional hooks to override default plugin behavior.
+   * Pointer to the node in the graph.
+   */
+  pointer: string;
+  /**
+   * Tags associated with the node.
+   */
+  tags?: Set<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;
+  /**
+   * 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.
+   */
+  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$3.V2_0_X | OpenApi$3.V3_0_X | OpenApi$3.V3_1_X>;
+    gen: IProject;
+    name: string;
+    output: string;
+  });
+  /**
+   * Iterates over various input elements as specified by the event types, in
+   * a specific order: servers, schemas, parameters, request bodies, then
+   * operations.
    *
-   * Use these to classify resources, control which outputs are generated,
-   * or provide custom behavior for specific resources.
+   * This ensures, for example, that schemas are always processed before
+   * operations, which may reference them.
+   *
+   * @template T - 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
+   *   }
+   * });
    */
-  hooks?: IR$1.Hooks;
+  forEach<T extends IrTopLevelKind = IrTopLevelKind>(...args: [...events: ReadonlyArray<T$1>, callback: (event: WalkEvent<T$1>) => void]): void;
+  forEach<T extends IrTopLevelKind = IrTopLevelKind>(...args: [...events: ReadonlyArray<T$1>, callback: (event: WalkEvent<T$1>) => void, options: WalkOptions<T$1>]): void;
   /**
-   * Pagination configuration.
+   * 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.
    */
-  pagination?: {
-    /**
-     * Array of keywords to be considered as pagination field names.
-     * These will be used to detect pagination fields in schemas and parameters.
-     *
-     * @default ['after', 'before', 'cursor', 'offset', 'page', 'start']
-     */
-    keywords?: ReadonlyArray<string>;
+  getPlugin<T extends keyof PluginConfigMap>(name: T$1): T$1 extends any ? PluginInstance<PluginConfigMap[T$1]> | undefined : never;
+  /**
+   * 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.
+   */
+  getPluginOrThrow<T extends keyof PluginConfigMap>(name: T$1): T$1 extends any ? PluginInstance<PluginConfigMap[T$1]> : never;
+  getSymbol(symbolIdOrSelector: number | Selector): Symbol | undefined;
+  hooks: {
+    operation: {
+      isMutation: (operation: IR$1.OperationObject) => boolean;
+      isQuery: (operation: IR$1.OperationObject) => boolean;
+    };
   };
+  isSymbolRegistered(symbolIdOrSelector: number | Selector): boolean;
+  referenceSymbol(symbolIdOrSelector: number | Selector): Symbol;
+  registerSymbol(symbol: SymbolIn): Symbol;
   /**
-   * Custom input transformations to execute before parsing. Use this
-   * to modify, fix, or enhance input before it's passed to plugins.
+   * Executes plugin's handler function.
    */
-  patch?: Patch;
+  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 = {
   /**
-   * Built-in transformations that modify or normalize the input before it's
-   * passed to plugins. These options enable predictable, documented behaviors
-   * and are distinct from custom patches. Use this to perform structural
-   * changes to input in a standardized way.
+   * Event hooks.
    */
-  transforms?: {
+  events?: {
     /**
-     * Your input might contain two types of enums:
-     * - enums defined as reusable components (root enums)
-     * - non-reusable enums nested within other schemas (inline enums)
+     * Triggered after executing a plugin handler.
      *
-     * You may want all enums to be reusable. This is because only root enums
+     * @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/parser.d.ts
+type EnumsMode = 'inline' | 'root';
+type UserParser = {
+  /**
+   * Filters can be used to select a subset of your input before it's passed
+   * to plugins.
+   */
+  filters?: Filters;
+  /**
+   * 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;
+  /**
+   * Pagination configuration.
+   */
+  pagination?: {
+    /**
+     * Array of keywords to be considered as pagination field names.
+     * These will be used to detect pagination fields in schemas and parameters.
+     *
+     * @default ['after', 'before', 'cursor', 'offset', 'page', 'start']
+     */
+    keywords?: ReadonlyArray<string>;
+  };
+  /**
+   * Custom input transformations to execute before parsing. Use this
+   * to modify, fix, or enhance input before it's passed to plugins.
+   */
+  patch?: Patch;
+  /**
+   * Built-in transformations that modify or normalize the input before it's
+   * passed to plugins. These options enable predictable, documented behaviors
+   * and are distinct from custom patches. Use this to perform structural
+   * changes to input in a standardized way.
+   */
+  transforms?: {
+    /**
+     * Your input might contain two types of enums:
+     * - enums defined as reusable components (root enums)
+     * - non-reusable enums nested within other schemas (inline enums)
+     *
+     * You may want all enums to be reusable. This is because only root enums
      * are typically exported by plugins. Inline enums will never be directly
      * importable since they're nested inside other schemas.
      *
@@ -6775,7 +7160,7 @@ type Parser = {
    * Use these to classify resources, control which outputs are generated,
    * or provide custom behavior for specific resources.
    */
-  hooks: IR$1.Hooks;
+  hooks: Hooks;
   /**
    * Pagination configuration.
    */
@@ -7400,6 +7785,20 @@ interface Client$2 {
   version: string;
 }
 //#endregion
+//#region src/utils/logger.d.ts
+declare class Logger {
+  private events;
+  private end;
+  report(print?: boolean): PerformanceMeasure | undefined;
+  private reportEvent;
+  private start;
+  private storeEvent;
+  timeEvent(name: string): {
+    mark: PerformanceMark;
+    timeEnd: () => void;
+  };
+}
+//#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
@@ -7684,7 +8083,7 @@ interface OpenApiTag$1 {
 /**
  * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md
  */
-interface OpenApi$2 {
+interface OpenApi$1 {
   basePath?: string;
   consumes?: string[];
   definitions?: Dictionary<OpenApiSchema>;
@@ -7972,7 +8371,7 @@ interface OpenApiTag {
 /**
  * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md
  */
-interface OpenApi$3 {
+interface OpenApi$2 {
   components?: OpenApiComponents;
   externalDocs?: OpenApiExternalDocs;
   info: OpenApiInfo;
@@ -7984,7 +8383,7 @@ interface OpenApi$3 {
 }
 //#endregion
 //#region src/openApi/common/interfaces/OpenApi.d.ts
-type OpenApi = OpenApi$2 | OpenApi$3;
+type OpenApi = OpenApi$1 | OpenApi$2;
 //#endregion
 //#region src/openApi/index.d.ts
 /**
@@ -8004,160 +8403,6 @@ declare const parseOpenApiSpec: ({
   spec: unknown;
 }) => IR$1.Context | undefined;
 //#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/plugins/shared/types/instance.d.ts
-type WalkEvents = {
-  _path: ReadonlyArray<string | number>;
-  method: keyof IR$1.PathItemObject;
-  operation: IR$1.OperationObject;
-  path: string;
-  type: Extract<IrTopLevelKind, 'operation'>;
-} | {
-  $ref: string;
-  _path: ReadonlyArray<string | number>;
-  name: string;
-  parameter: IR$1.ParameterObject;
-  type: Extract<IrTopLevelKind, 'parameter'>;
-} | {
-  $ref: string;
-  _path: ReadonlyArray<string | number>;
-  name: string;
-  requestBody: IR$1.RequestBodyObject;
-  type: Extract<IrTopLevelKind, 'requestBody'>;
-} | {
-  $ref: string;
-  _path: ReadonlyArray<string | number>;
-  name: string;
-  schema: IR$1.SchemaObject;
-  type: Extract<IrTopLevelKind, 'schema'>;
-} | {
-  _path: ReadonlyArray<string | number>;
-  server: IR$1.ServerObject;
-  type: Extract<IrTopLevelKind, 'server'>;
-} | {
-  _path: ReadonlyArray<string | number>;
-  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;
-}>;
-type WalkOptions = {
-  /**
-   * Order of walking schemas.
-   *
-   * The "declarations" option ensures that schemas are walked in the order
-   * they are declared in the input document. This is useful for scenarios where
-   * the order of declaration matters, such as when generating code that relies
-   * on the sequence of schema definitions.
-   *
-   * The "topological" option ensures that schemas are walked in an order
-   * where dependencies are visited before the schemas that depend on them.
-   * This is useful for scenarios where you need to process or generate
-   * schemas in a way that respects their interdependencies.
-   *
-   * @default 'topological'
-   */
-  order?: 'declarations' | 'topological';
-};
-//#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'];
-  gen: IProject;
-  private handler;
-  name: T$1['resolvedConfig']['name'];
-  output: string;
-  /**
-   * 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.
-   */
-  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;
-  });
-  /**
-   * 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 T - 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
-   *   }
-   * });
-   */
-  forEach<T extends IrTopLevelKind = IrTopLevelKind>(...args: [...events: ReadonlyArray<T$1>, callback: (event: WalkEvent<T$1>) => void]): void;
-  forEach<T extends IrTopLevelKind = IrTopLevelKind>(...args: [...events: ReadonlyArray<T$1>, callback: (event: WalkEvent<T$1>) => void, options: WalkOptions]): void;
-  private forEachError;
-  /**
-   * 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.
-   */
-  getPlugin<T extends keyof PluginConfigMap>(name: T$1): T$1 extends any ? PluginInstance<PluginConfigMap[T$1]> | undefined : never;
-  /**
-   * 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.
-   */
-  getPluginOrThrow<T extends keyof PluginConfigMap>(name: T$1): T$1 extends any ? PluginInstance<PluginConfigMap[T$1]> : never;
-  getSymbol(symbolIdOrSelector: number | Selector): Symbol | undefined;
-  private getSymbolFilePath;
-  getSymbolValue(idOrSymbol: number | Symbol): unknown;
-  hasSymbolValue(idOrSymbol: number | Symbol): boolean;
-  hooks: {
-    operation: {
-      isMutation: (operation: IR$1.OperationObject) => boolean;
-      isQuery: (operation: IR$1.OperationObject) => boolean;
-    };
-    symbol: {
-      getFilePath: (symbol: Symbol) => string | undefined;
-    };
-  };
-  private isOperationKind;
-  isSymbolRegistered(symbolIdOrSelector: number | Selector): boolean;
-  referenceSymbol(symbolIdOrSelector: number | Selector): Symbol;
-  registerSymbol(symbol: SymbolIn): Symbol;
-  /**
-   * Executes plugin's handler function.
-   */
-  run(): Promise<void>;
-  setSymbolValue(idOrSymbol: number | Symbol, value: unknown): Map<number, unknown>;
-  private symbolToId;
-}
-//#endregion
 //#region src/types/client.d.ts
 interface Operation extends Omit<Operation$1, 'tags'> {
   service: string;
@@ -8197,7 +8442,7 @@ type BaseConfig = {
    * Use these to classify resources, control which outputs are generated,
    * or provide custom behavior for specific resources.
    */
-  '~hooks'?: IR$1.Hooks;
+  '~hooks'?: Hooks;
 };
 
 /**
@@ -8596,1284 +8841,107 @@ declare namespace Client {
      * `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/plugins/@hey-api/client-angular/api.d.ts
-type SelectorType$14 = 'client';
-type IApi$14 = {
-  /**
-   * @param type Selector type.
-   * @param value Depends on `type`:
-   *  - `client`: never
-   * @returns Selector array
-   */
-  selector: (type: SelectorType$14, value?: string) => Selector;
-};
-//#endregion
-//#region src/plugins/@hey-api/client-angular/types.d.ts
-type UserConfig$20 = 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$20, UserConfig$20, IApi$14>;
-//#endregion
-//#region src/plugins/@hey-api/legacy-angular/types.d.ts
-type UserConfig$19 = Plugin.Name<'legacy/angular'> & Pick<Client.Config, 'output'>;
-type HeyApiClientLegacyAngularPlugin = DefinePlugin<UserConfig$19>;
-//#endregion
-//#region src/plugins/@hey-api/legacy-axios/types.d.ts
-type UserConfig$18 = Plugin.Name<'legacy/axios'> & Pick<Client.Config, 'output'>;
-type HeyApiClientLegacyAxiosPlugin = DefinePlugin<UserConfig$18>;
-//#endregion
-//#region src/plugins/@hey-api/legacy-fetch/types.d.ts
-type UserConfig$17 = Plugin.Name<'legacy/fetch'> & Pick<Client.Config, 'output'>;
-type HeyApiClientLegacyFetchPlugin = DefinePlugin<UserConfig$17>;
-//#endregion
-//#region src/plugins/@hey-api/legacy-node/types.d.ts
-type UserConfig$16 = Plugin.Name<'legacy/node'> & Pick<Client.Config, 'output'>;
-type HeyApiClientLegacyNodePlugin = DefinePlugin<UserConfig$16>;
-//#endregion
-//#region src/plugins/@hey-api/legacy-xhr/types.d.ts
-type UserConfig$15 = Plugin.Name<'legacy/xhr'> & Pick<Client.Config, 'output'>;
-type HeyApiClientLegacyXhrPlugin = DefinePlugin<UserConfig$15>;
-//#endregion
-//#region src/plugins/@hey-api/schemas/api.d.ts
-type SelectorType$13 = 'ref';
-type IApi$13 = {
-  /**
-   * @param type Selector type.
-   * @param value Depends on `type`:
-   *  - `ref`: `$ref` JSON pointer
-   * @returns Selector array
-   */
-  selector: (type: SelectorType$13, value?: string) => Selector;
-};
-//#endregion
-//#region src/plugins/@hey-api/schemas/types.d.ts
-type UserConfig$14 = Plugin.Name<'@hey-api/schemas'> & Plugin.Hooks & {
-  /**
-   * Should the exports from the generated files be re-exported in the index
-   * barrel file?
-   *
-   * @default false
-   */
-  exportFromIndex?: boolean;
-  /**
-   * Customise the schema name. By default, `{{name}}Schema` is used. `name` is a
-   * valid JavaScript/TypeScript identifier, e.g. if your schema name is
-   * "Foo-Bar", `name` value would be "FooBar".
-   *
-   * @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);
-  /**
-   * Choose schema type to generate. Select 'form' if you don't want
-   * descriptions to reduce bundle size and you plan to use schemas
-   * for form validation
-   *
-   * @default 'json'
-   */
-  type?: 'form' | 'json';
-};
-type HeyApiSchemasPlugin = DefinePlugin<UserConfig$14, UserConfig$14, IApi$13>;
-declare namespace module_d_exports {
-  export { ImportExportItem, createCallExpression, createConstVariable, createExportAllDeclaration, createNamedExportDeclarations, createNamedImportDeclarations };
-}
-/**
- * Create export all declaration. Example: `export * from './y'`.
- * @param module - module containing exports
- * @returns ts.ExportDeclaration
- */
-declare const createExportAllDeclaration: ({
-  module,
-  shouldAppendJs
-}: {
-  module: string;
-  shouldAppendJs?: boolean;
-}) => ts.ExportDeclaration;
-type ImportExportItem = ImportExportItemObject | string;
-declare const createCallExpression: ({
-  functionName,
-  parameters,
-  types
-}: {
-  functionName: string | ts.PropertyAccessExpression | ts.PropertyAccessChain | ts.ElementAccessExpression | ts.Expression;
-  parameters?: Array<string | ts.Expression | undefined>;
-  types?: ReadonlyArray<ts.TypeNode>;
-}) => ts.CallExpression;
-/**
- * Create a named export declaration. Example: `export { X } from './y'`.
- * @param exports - named imports to export
- * @param module - module containing exports
- * @returns ts.ExportDeclaration
- */
-declare const createNamedExportDeclarations: ({
-  exports,
-  module
-}: {
-  exports: Array<ImportExportItem> | ImportExportItem;
-  module: string;
-}) => ts.ExportDeclaration;
-/**
- * Create a const variable. Optionally, it can use const assertion or export
- * statement. Example: `export x = {} as const`.
- * @param assertion use const assertion?
- * @param exportConst export created variable?
- * @param expression expression for the variable.
- * @param name name of the variable.
- * @returns ts.VariableStatement
- */
-declare const createConstVariable: ({
-  assertion,
-  comment,
-  destructure,
-  exportConst,
-  expression,
-  name,
-  typeName
-}: {
-  assertion?: "const" | ts.TypeNode;
-  comment?: Comments;
-  destructure?: boolean;
-  exportConst?: boolean;
-  expression: ts.Expression;
-  name: string | ts.TypeReferenceNode;
-  typeName?: string | ts.IndexedAccessTypeNode | ts.TypeNode;
-}) => ts.VariableStatement;
-/**
- * Create a named import declaration. Example: `import { X } from './y'`.
- * @param imports - named exports to import
- * @param module - module containing imports
- * @returns ts.ImportDeclaration
- */
-declare const createNamedImportDeclarations: ({
-  imports,
-  module
-}: {
-  imports: Array<ImportExportItem> | ImportExportItem;
-  module: string;
-}) => ts.ImportDeclaration;
-//#endregion
-//#region src/tsc/typedef.d.ts
-type Property = {
-  comment?: Comments;
-  isReadOnly?: boolean;
-  isRequired?: boolean;
-  name: string | ts.PropertyName;
-  type: any | ts.TypeNode;
-};
-//#endregion
-//#region src/tsc/index.d.ts
-declare const tsc: {
-  anonymousFunction: ({
-    async,
-    comment,
-    multiLine,
-    parameters,
-    returnType,
-    statements,
-    types: types_d_exports
-  }: {
-    async?: boolean;
-    comment?: Comments;
-    multiLine?: boolean;
-    parameters?: FunctionParameter[];
-    returnType?: string | typescript0.TypeNode;
-    statements?: ReadonlyArray<typescript0.Statement>;
-    types?: FunctionTypeParameter[];
-  }) => typescript0.FunctionExpression;
-  arrayLiteralExpression: <T>({
-    elements,
-    multiLine
-  }: {
-    elements: T[];
-    multiLine?: boolean;
-  }) => typescript0.ArrayLiteralExpression;
-  arrowFunction: ({
-    async,
-    comment,
-    multiLine,
-    parameters,
-    returnType,
-    statements,
-    types: types_d_exports
-  }: {
-    async?: boolean;
-    comment?: Comments;
-    multiLine?: boolean;
-    parameters?: ReadonlyArray<FunctionParameter>;
-    returnType?: string | typescript0.TypeNode;
-    statements?: typescript0.Statement[] | typescript0.Expression;
-    types?: FunctionTypeParameter[];
-  }) => typescript0.ArrowFunction;
-  asExpression: ({
-    expression,
-    type
-  }: {
-    expression: typescript0.Expression;
-    type: typescript0.TypeNode;
-  }) => typescript0.AsExpression;
-  assignment: ({
-    left,
-    right
-  }: {
-    left: typescript0.Expression;
-    right: typescript0.Expression;
-  }) => typescript0.AssignmentExpression<typescript0.EqualsToken>;
-  awaitExpression: ({
-    expression
-  }: {
-    expression: typescript0.Expression;
-  }) => typescript0.AwaitExpression;
-  binaryExpression: ({
-    left,
-    operator,
-    right
-  }: {
-    left: typescript0.Expression;
-    operator?: "=" | "===" | "!==" | "in" | "??";
-    right: typescript0.Expression | string;
-  }) => typescript0.BinaryExpression;
-  block: ({
-    multiLine,
-    statements
-  }: {
-    multiLine?: boolean;
-    statements: ReadonlyArray<typescript0.Statement>;
-  }) => typescript0.Block;
-  callExpression: ({
-    functionName,
-    parameters,
-    types: types_d_exports
-  }: {
-    functionName: string | typescript0.PropertyAccessExpression | typescript0.PropertyAccessChain | typescript0.ElementAccessExpression | typescript0.Expression;
-    parameters?: Array<string | typescript0.Expression | undefined>;
-    types?: ReadonlyArray<typescript0.TypeNode>;
-  }) => typescript0.CallExpression;
-  classDeclaration: ({
-    decorator,
-    exportClass,
-    extendedClasses,
-    name,
-    nodes
-  }: {
-    decorator?: {
-      args: any[];
-      name: string;
-    };
-    exportClass?: boolean;
-    extendedClasses?: ReadonlyArray<string>;
-    name: string;
-    nodes: ReadonlyArray<typescript0.ClassElement>;
-  }) => typescript0.ClassDeclaration;
-  conditionalExpression: ({
-    condition,
-    whenFalse,
-    whenTrue
-  }: {
-    condition: typescript0.Expression;
-    whenFalse: typescript0.Expression;
-    whenTrue: typescript0.Expression;
-  }) => typescript0.ConditionalExpression;
-  constVariable: ({
-    assertion,
-    comment,
-    destructure,
-    exportConst,
-    expression,
-    name,
-    typeName
-  }: {
-    assertion?: "const" | typescript0.TypeNode;
-    comment?: Comments;
-    destructure?: boolean;
-    exportConst?: boolean;
-    expression: typescript0.Expression;
-    name: string | typescript0.TypeReferenceNode;
-    typeName?: string | typescript0.IndexedAccessTypeNode | typescript0.TypeNode;
-  }) => typescript0.VariableStatement;
-  constructorDeclaration: ({
-    accessLevel,
-    comment,
-    multiLine,
-    parameters,
-    statements
-  }: {
-    accessLevel?: AccessLevel;
-    comment?: Comments;
-    multiLine?: boolean;
-    parameters?: FunctionParameter[];
-    statements?: typescript0.Statement[];
-  }) => typescript0.ConstructorDeclaration;
-  enumDeclaration: <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 | typescript0.TypeReferenceNode;
-    obj: T;
-  }) => typescript0.EnumDeclaration;
-  exportAllDeclaration: ({
-    module: module_d_exports,
-    shouldAppendJs
-  }: {
-    module: string;
-    shouldAppendJs?: boolean;
-  }) => typescript0.ExportDeclaration;
-  exportNamedDeclaration: ({
-    exports,
-    module: module_d_exports
-  }: {
-    exports: Array<ImportExportItem> | ImportExportItem;
-    module: string;
-  }) => typescript0.ExportDeclaration;
-  expressionToStatement: ({
-    expression
-  }: {
-    expression: typescript0.Expression;
-  }) => typescript0.ExpressionStatement;
-  forOfStatement: ({
-    awaitModifier,
-    expression,
-    initializer,
-    statement
-  }: {
-    awaitModifier?: typescript0.AwaitKeyword;
-    expression: typescript0.Expression;
-    initializer: typescript0.ForInitializer;
-    statement: typescript0.Statement;
-  }) => typescript0.ForOfStatement;
-  functionTypeNode: ({
-    parameters,
-    returnType,
-    typeParameters
-  }: {
-    parameters?: typescript0.ParameterDeclaration[];
-    returnType: typescript0.TypeNode;
-    typeParameters?: typescript0.TypeParameterDeclaration[];
-  }) => typescript0.FunctionTypeNode;
-  getAccessorDeclaration: ({
-    name,
-    returnType,
-    statements
-  }: {
-    name: string | typescript0.PropertyName;
-    returnType?: string | typescript0.Identifier;
-    statements: ReadonlyArray<typescript0.Statement>;
-  }) => typescript0.GetAccessorDeclaration;
-  identifier: ({
-    text
-  }: {
-    text: string;
-  }) => typescript0.Identifier;
-  ifStatement: ({
-    elseStatement,
-    expression,
-    thenStatement
-  }: {
-    elseStatement?: typescript0.Statement;
-    expression: typescript0.Expression;
-    thenStatement: typescript0.Statement;
-  }) => typescript0.IfStatement;
-  indexedAccessTypeNode: ({
-    indexType,
-    objectType
-  }: {
-    indexType: typescript0.TypeNode;
-    objectType: typescript0.TypeNode;
-  }) => typescript0.IndexedAccessTypeNode;
-  isTsNode: (node: any) => node is typescript0.Expression;
-  keywordTypeNode: ({
-    keyword
-  }: {
-    keyword: Extract<SyntaxKindKeyword, "any" | "boolean" | "never" | "number" | "string" | "undefined" | "unknown" | "void">;
-  }) => typescript0.KeywordTypeNode<typescript0.SyntaxKind.VoidKeyword | typescript0.SyntaxKind.AnyKeyword | typescript0.SyntaxKind.BooleanKeyword | typescript0.SyntaxKind.NeverKeyword | typescript0.SyntaxKind.NumberKeyword | typescript0.SyntaxKind.StringKeyword | typescript0.SyntaxKind.UndefinedKeyword | typescript0.SyntaxKind.UnknownKeyword>;
-  literalTypeNode: ({
-    literal
-  }: {
-    literal: typescript0.LiteralTypeNode["literal"];
-  }) => typescript0.LiteralTypeNode;
-  mappedTypeNode: ({
-    members,
-    nameType,
-    questionToken,
-    readonlyToken,
-    type,
-    typeParameter
-  }: {
-    members?: typescript0.NodeArray<typescript0.TypeElement>;
-    nameType?: typescript0.TypeNode;
-    questionToken?: typescript0.QuestionToken | typescript0.PlusToken | typescript0.MinusToken;
-    readonlyToken?: typescript0.ReadonlyKeyword | typescript0.PlusToken | typescript0.MinusToken;
-    type?: typescript0.TypeNode;
-    typeParameter: typescript0.TypeParameterDeclaration;
-  }) => typescript0.MappedTypeNode;
-  methodDeclaration: ({
-    accessLevel,
-    comment,
-    isStatic,
-    multiLine,
-    name,
-    parameters,
-    returnType,
-    statements,
-    types: types_d_exports
-  }: {
-    accessLevel?: AccessLevel;
-    comment?: Comments;
-    isStatic?: boolean;
-    multiLine?: boolean;
-    name: string;
-    parameters?: ReadonlyArray<FunctionParameter>;
-    returnType?: string | typescript0.TypeNode;
-    statements?: typescript0.Statement[];
-    types?: FunctionTypeParameter[];
-  }) => typescript0.MethodDeclaration;
-  namedImportDeclarations: ({
-    imports,
-    module: module_d_exports
-  }: {
-    imports: Array<ImportExportItem> | ImportExportItem;
-    module: string;
-  }) => typescript0.ImportDeclaration;
-  namespaceDeclaration: ({
-    name,
-    statements
-  }: {
-    name: string;
-    statements: Array<typescript0.Statement>;
-  }) => typescript0.ModuleDeclaration;
-  newExpression: ({
-    argumentsArray,
-    expression,
-    typeArguments
-  }: {
-    argumentsArray?: Array<typescript0.Expression>;
-    expression: typescript0.Expression;
-    typeArguments?: Array<typescript0.TypeNode>;
-  }) => typescript0.NewExpression;
-  nodeToString: typeof tsNodeToString;
-  null: () => typescript0.NullLiteral;
-  objectExpression: <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;
-  }) => typescript0.ObjectLiteralExpression;
-  ots: {
-    boolean: (value: boolean) => typescript0.TrueLiteral | typescript0.FalseLiteral;
-    export: ({
-      alias,
-      asType,
-      name
-    }: ImportExportItemObject) => typescript0.ExportSpecifier;
-    import: ({
-      alias,
-      asType,
-      name
-    }: ImportExportItemObject) => typescript0.ImportSpecifier;
-    number: (value: number) => typescript0.NumericLiteral | typescript0.PrefixUnaryExpression;
-    string: (value: string, unescape?: boolean) => typescript0.Identifier | typescript0.StringLiteral;
-  };
-  parameterDeclaration: ({
-    initializer,
-    modifiers,
-    name,
-    required,
-    type
-  }: {
-    initializer?: typescript0.Expression;
-    modifiers?: ReadonlyArray<typescript0.ModifierLike>;
-    name: string | typescript0.BindingName;
-    required?: boolean;
-    type?: typescript0.TypeNode;
-  }) => typescript0.ParameterDeclaration;
-  propertyAccessExpression: ({
-    expression,
-    isOptional,
-    name
-  }: {
-    expression: string | typescript0.Expression;
-    isOptional?: boolean;
-    name: string | number | typescript0.MemberName;
-  }) => typescript0.PropertyAccessChain | typescript0.PropertyAccessExpression | typescript0.ElementAccessExpression;
-  propertyAccessExpressions: ({
-    expressions
-  }: {
-    expressions: Array<string | typescript0.Expression | typescript0.MemberName>;
-  }) => typescript0.PropertyAccessExpression;
-  propertyAssignment: ({
-    initializer,
-    name
-  }: {
-    initializer: typescript0.Expression;
-    name: string | typescript0.PropertyName;
-  }) => typescript0.PropertyAssignment;
-  propertyDeclaration: ({
-    initializer,
-    modifier,
-    name,
-    type
-  }: {
-    initializer?: typescript0.Expression;
-    modifier?: "async" | AccessLevel | "export" | "readonly" | "static";
-    name: string | typescript0.PropertyName;
-    type?: typescript0.TypeNode;
-  }) => typescript0.PropertyDeclaration;
-  regularExpressionLiteral: ({
-    flags,
-    text
-  }: {
-    flags?: ReadonlyArray<"g" | "i" | "m" | "s" | "u" | "y">;
-    text: string;
-  }) => typescript0.RegularExpressionLiteral;
-  returnFunctionCall: ({
-    args,
-    name,
-    types: types_d_exports
-  }: {
-    args: any[];
-    name: string | typescript0.Expression;
-    types?: ReadonlyArray<string | typescript0.StringLiteral>;
-  }) => typescript0.ReturnStatement;
-  returnStatement: ({
-    expression
-  }: {
-    expression?: typescript0.Expression;
-  }) => typescript0.ReturnStatement;
-  returnVariable: ({
-    expression
-  }: {
-    expression: string | typescript0.Expression;
-  }) => typescript0.ReturnStatement;
-  safeAccessExpression: (path: string[]) => typescript0.Expression;
-  stringLiteral: ({
-    isSingleQuote,
-    text
-  }: {
-    isSingleQuote?: boolean;
-    text: string;
-  }) => typescript0.StringLiteral;
-  templateLiteralType: ({
-    value
-  }: {
-    value: ReadonlyArray<string | typescript0.TypeNode>;
-  }) => typescript0.TemplateLiteralTypeNode;
-  this: () => typescript0.ThisExpression;
-  transformArrayMap: ({
-    path,
-    transformExpression
-  }: {
-    path: string[];
-    transformExpression: typescript0.Expression;
-  }) => typescript0.IfStatement;
-  transformArrayMutation: ({
-    path,
-    transformerName
-  }: {
-    path: string[];
-    transformerName: string;
-  }) => typescript0.Statement;
-  transformDateMutation: ({
-    path
-  }: {
-    path: string[];
-  }) => typescript0.Statement;
-  transformFunctionMutation: ({
-    path,
-    transformerName
-  }: {
-    path: string[];
-    transformerName: string;
-  }) => typescript0.IfStatement[];
-  transformNewDate: ({
-    parameterName
-  }: {
-    parameterName: string;
-  }) => typescript0.NewExpression;
-  typeAliasDeclaration: ({
-    comment,
-    exportType,
-    name,
-    type,
-    typeParameters
-  }: {
-    comment?: Comments;
-    exportType?: boolean;
-    name: string | typescript0.TypeReferenceNode;
-    type: string | typescript0.TypeNode | typescript0.Identifier;
-    typeParameters?: FunctionTypeParameter[];
-  }) => typescript0.TypeAliasDeclaration;
-  typeArrayNode: (types: ReadonlyArray<any | typescript0.TypeNode> | typescript0.TypeNode | typescript0.Identifier | string, isNullable?: boolean) => typescript0.TypeNode;
-  typeInterfaceNode: ({
-    indexKey,
-    indexProperty,
-    isNullable,
-    properties,
-    useLegacyResolution
-  }: {
-    indexKey?: typescript0.TypeReferenceNode;
-    indexProperty?: Property;
-    isNullable?: boolean;
-    properties: Property[];
-    useLegacyResolution: boolean;
-  }) => typescript0.TypeNode;
-  typeIntersectionNode: ({
-    isNullable,
-    types: types_d_exports
-  }: {
-    isNullable?: boolean;
-    types: (any | typescript0.TypeNode)[];
-  }) => typescript0.TypeNode;
-  typeNode: (base: any | typescript0.TypeNode, args?: (any | typescript0.TypeNode)[]) => typescript0.TypeNode;
-  typeOfExpression: ({
-    text
-  }: {
-    text: string | typescript0.Identifier;
-  }) => typescript0.TypeOfExpression;
-  typeOperatorNode: ({
-    operator,
-    type
-  }: {
-    operator: "keyof" | "readonly" | "unique";
-    type: typescript0.TypeNode;
-  }) => typescript0.TypeOperatorNode;
-  typeParameterDeclaration: ({
-    constraint,
-    defaultType,
-    modifiers,
-    name
-  }: {
-    constraint?: typescript0.TypeNode;
-    defaultType?: typescript0.TypeNode;
-    modifiers?: Array<typescript0.Modifier>;
-    name: string | typescript0.Identifier;
-  }) => typescript0.TypeParameterDeclaration;
-  typeParenthesizedNode: ({
-    type
-  }: {
-    type: typescript0.TypeNode;
-  }) => typescript0.ParenthesizedTypeNode;
-  typeRecordNode: (keys: (any | typescript0.TypeNode)[], values: (any | typescript0.TypeNode)[], isNullable?: boolean, useLegacyResolution?: boolean) => typescript0.TypeNode;
-  typeReferenceNode: ({
-    typeArguments,
-    typeName
-  }: {
-    typeArguments?: typescript0.TypeNode[];
-    typeName: string | typescript0.EntityName;
-  }) => typescript0.TypeReferenceNode;
-  typeTupleNode: ({
-    isNullable,
-    types: types_d_exports
-  }: {
-    isNullable?: boolean;
-    types: Array<any | typescript0.TypeNode>;
-  }) => typescript0.TypeNode;
-  typeUnionNode: ({
-    isNullable,
-    types: types_d_exports
-  }: {
-    isNullable?: boolean;
-    types: ReadonlyArray<any | typescript0.TypeNode>;
-  }) => typescript0.TypeNode;
-  valueToExpression: <T = unknown>({
-    identifiers,
-    isValueAccess,
-    shorthand,
-    unescape,
-    value
-  }: {
-    identifiers?: string[];
-    isValueAccess?: boolean;
-    shorthand?: boolean;
-    unescape?: boolean;
-    value: T;
-  }) => typescript0.Expression | undefined;
+    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/plugins/@hey-api/client-angular/api.d.ts
+type SelectorType$14 = 'client';
+type IApi$14 = {
+  /**
+   * @param type Selector type.
+   * @param value Depends on `type`:
+   *  - `client`: never
+   * @returns Selector array
+   */
+  selector: (type: SelectorType$14, value?: string) => Selector;
 };
-/** @deprecated use tsc */
-declare const compiler: {
-  anonymousFunction: ({
-    async,
-    comment,
-    multiLine,
-    parameters,
-    returnType,
-    statements,
-    types: types_d_exports
-  }: {
-    async?: boolean;
-    comment?: Comments;
-    multiLine?: boolean;
-    parameters?: FunctionParameter[];
-    returnType?: string | typescript0.TypeNode;
-    statements?: ReadonlyArray<typescript0.Statement>;
-    types?: FunctionTypeParameter[];
-  }) => typescript0.FunctionExpression;
-  arrayLiteralExpression: <T>({
-    elements,
-    multiLine
-  }: {
-    elements: T[];
-    multiLine?: boolean;
-  }) => typescript0.ArrayLiteralExpression;
-  arrowFunction: ({
-    async,
-    comment,
-    multiLine,
-    parameters,
-    returnType,
-    statements,
-    types: types_d_exports
-  }: {
-    async?: boolean;
-    comment?: Comments;
-    multiLine?: boolean;
-    parameters?: ReadonlyArray<FunctionParameter>;
-    returnType?: string | typescript0.TypeNode;
-    statements?: typescript0.Statement[] | typescript0.Expression;
-    types?: FunctionTypeParameter[];
-  }) => typescript0.ArrowFunction;
-  asExpression: ({
-    expression,
-    type
-  }: {
-    expression: typescript0.Expression;
-    type: typescript0.TypeNode;
-  }) => typescript0.AsExpression;
-  assignment: ({
-    left,
-    right
-  }: {
-    left: typescript0.Expression;
-    right: typescript0.Expression;
-  }) => typescript0.AssignmentExpression<typescript0.EqualsToken>;
-  awaitExpression: ({
-    expression
-  }: {
-    expression: typescript0.Expression;
-  }) => typescript0.AwaitExpression;
-  binaryExpression: ({
-    left,
-    operator,
-    right
-  }: {
-    left: typescript0.Expression;
-    operator?: "=" | "===" | "!==" | "in" | "??";
-    right: typescript0.Expression | string;
-  }) => typescript0.BinaryExpression;
-  block: ({
-    multiLine,
-    statements
-  }: {
-    multiLine?: boolean;
-    statements: ReadonlyArray<typescript0.Statement>;
-  }) => typescript0.Block;
-  callExpression: ({
-    functionName,
-    parameters,
-    types: types_d_exports
-  }: {
-    functionName: string | typescript0.PropertyAccessExpression | typescript0.PropertyAccessChain | typescript0.ElementAccessExpression | typescript0.Expression;
-    parameters?: Array<string | typescript0.Expression | undefined>;
-    types?: ReadonlyArray<typescript0.TypeNode>;
-  }) => typescript0.CallExpression;
-  classDeclaration: ({
-    decorator,
-    exportClass,
-    extendedClasses,
-    name,
-    nodes
-  }: {
-    decorator?: {
-      args: any[];
-      name: string;
-    };
-    exportClass?: boolean;
-    extendedClasses?: ReadonlyArray<string>;
-    name: string;
-    nodes: ReadonlyArray<typescript0.ClassElement>;
-  }) => typescript0.ClassDeclaration;
-  conditionalExpression: ({
-    condition,
-    whenFalse,
-    whenTrue
-  }: {
-    condition: typescript0.Expression;
-    whenFalse: typescript0.Expression;
-    whenTrue: typescript0.Expression;
-  }) => typescript0.ConditionalExpression;
-  constVariable: ({
-    assertion,
-    comment,
-    destructure,
-    exportConst,
-    expression,
-    name,
-    typeName
-  }: {
-    assertion?: "const" | typescript0.TypeNode;
-    comment?: Comments;
-    destructure?: boolean;
-    exportConst?: boolean;
-    expression: typescript0.Expression;
-    name: string | typescript0.TypeReferenceNode;
-    typeName?: string | typescript0.IndexedAccessTypeNode | typescript0.TypeNode;
-  }) => typescript0.VariableStatement;
-  constructorDeclaration: ({
-    accessLevel,
-    comment,
-    multiLine,
-    parameters,
-    statements
-  }: {
-    accessLevel?: AccessLevel;
-    comment?: Comments;
-    multiLine?: boolean;
-    parameters?: FunctionParameter[];
-    statements?: typescript0.Statement[];
-  }) => typescript0.ConstructorDeclaration;
-  enumDeclaration: <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 | typescript0.TypeReferenceNode;
-    obj: T;
-  }) => typescript0.EnumDeclaration;
-  exportAllDeclaration: ({
-    module: module_d_exports,
-    shouldAppendJs
-  }: {
-    module: string;
-    shouldAppendJs?: boolean;
-  }) => typescript0.ExportDeclaration;
-  exportNamedDeclaration: ({
-    exports,
-    module: module_d_exports
-  }: {
-    exports: Array<ImportExportItem> | ImportExportItem;
-    module: string;
-  }) => typescript0.ExportDeclaration;
-  expressionToStatement: ({
-    expression
-  }: {
-    expression: typescript0.Expression;
-  }) => typescript0.ExpressionStatement;
-  forOfStatement: ({
-    awaitModifier,
-    expression,
-    initializer,
-    statement
-  }: {
-    awaitModifier?: typescript0.AwaitKeyword;
-    expression: typescript0.Expression;
-    initializer: typescript0.ForInitializer;
-    statement: typescript0.Statement;
-  }) => typescript0.ForOfStatement;
-  functionTypeNode: ({
-    parameters,
-    returnType,
-    typeParameters
-  }: {
-    parameters?: typescript0.ParameterDeclaration[];
-    returnType: typescript0.TypeNode;
-    typeParameters?: typescript0.TypeParameterDeclaration[];
-  }) => typescript0.FunctionTypeNode;
-  getAccessorDeclaration: ({
-    name,
-    returnType,
-    statements
-  }: {
-    name: string | typescript0.PropertyName;
-    returnType?: string | typescript0.Identifier;
-    statements: ReadonlyArray<typescript0.Statement>;
-  }) => typescript0.GetAccessorDeclaration;
-  identifier: ({
-    text
-  }: {
-    text: string;
-  }) => typescript0.Identifier;
-  ifStatement: ({
-    elseStatement,
-    expression,
-    thenStatement
-  }: {
-    elseStatement?: typescript0.Statement;
-    expression: typescript0.Expression;
-    thenStatement: typescript0.Statement;
-  }) => typescript0.IfStatement;
-  indexedAccessTypeNode: ({
-    indexType,
-    objectType
-  }: {
-    indexType: typescript0.TypeNode;
-    objectType: typescript0.TypeNode;
-  }) => typescript0.IndexedAccessTypeNode;
-  isTsNode: (node: any) => node is typescript0.Expression;
-  keywordTypeNode: ({
-    keyword
-  }: {
-    keyword: Extract<SyntaxKindKeyword, "any" | "boolean" | "never" | "number" | "string" | "undefined" | "unknown" | "void">;
-  }) => typescript0.KeywordTypeNode<typescript0.SyntaxKind.VoidKeyword | typescript0.SyntaxKind.AnyKeyword | typescript0.SyntaxKind.BooleanKeyword | typescript0.SyntaxKind.NeverKeyword | typescript0.SyntaxKind.NumberKeyword | typescript0.SyntaxKind.StringKeyword | typescript0.SyntaxKind.UndefinedKeyword | typescript0.SyntaxKind.UnknownKeyword>;
-  literalTypeNode: ({
-    literal
-  }: {
-    literal: typescript0.LiteralTypeNode["literal"];
-  }) => typescript0.LiteralTypeNode;
-  mappedTypeNode: ({
-    members,
-    nameType,
-    questionToken,
-    readonlyToken,
-    type,
-    typeParameter
-  }: {
-    members?: typescript0.NodeArray<typescript0.TypeElement>;
-    nameType?: typescript0.TypeNode;
-    questionToken?: typescript0.QuestionToken | typescript0.PlusToken | typescript0.MinusToken;
-    readonlyToken?: typescript0.ReadonlyKeyword | typescript0.PlusToken | typescript0.MinusToken;
-    type?: typescript0.TypeNode;
-    typeParameter: typescript0.TypeParameterDeclaration;
-  }) => typescript0.MappedTypeNode;
-  methodDeclaration: ({
-    accessLevel,
-    comment,
-    isStatic,
-    multiLine,
-    name,
-    parameters,
-    returnType,
-    statements,
-    types: types_d_exports
-  }: {
-    accessLevel?: AccessLevel;
-    comment?: Comments;
-    isStatic?: boolean;
-    multiLine?: boolean;
-    name: string;
-    parameters?: ReadonlyArray<FunctionParameter>;
-    returnType?: string | typescript0.TypeNode;
-    statements?: typescript0.Statement[];
-    types?: FunctionTypeParameter[];
-  }) => typescript0.MethodDeclaration;
-  namedImportDeclarations: ({
-    imports,
-    module: module_d_exports
-  }: {
-    imports: Array<ImportExportItem> | ImportExportItem;
-    module: string;
-  }) => typescript0.ImportDeclaration;
-  namespaceDeclaration: ({
-    name,
-    statements
-  }: {
-    name: string;
-    statements: Array<typescript0.Statement>;
-  }) => typescript0.ModuleDeclaration;
-  newExpression: ({
-    argumentsArray,
-    expression,
-    typeArguments
-  }: {
-    argumentsArray?: Array<typescript0.Expression>;
-    expression: typescript0.Expression;
-    typeArguments?: Array<typescript0.TypeNode>;
-  }) => typescript0.NewExpression;
-  nodeToString: typeof tsNodeToString;
-  null: () => typescript0.NullLiteral;
-  objectExpression: <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;
-  }) => typescript0.ObjectLiteralExpression;
-  ots: {
-    boolean: (value: boolean) => typescript0.TrueLiteral | typescript0.FalseLiteral;
-    export: ({
-      alias,
-      asType,
-      name
-    }: ImportExportItemObject) => typescript0.ExportSpecifier;
-    import: ({
-      alias,
-      asType,
-      name
-    }: ImportExportItemObject) => typescript0.ImportSpecifier;
-    number: (value: number) => typescript0.NumericLiteral | typescript0.PrefixUnaryExpression;
-    string: (value: string, unescape?: boolean) => typescript0.Identifier | typescript0.StringLiteral;
-  };
-  parameterDeclaration: ({
-    initializer,
-    modifiers,
-    name,
-    required,
-    type
-  }: {
-    initializer?: typescript0.Expression;
-    modifiers?: ReadonlyArray<typescript0.ModifierLike>;
-    name: string | typescript0.BindingName;
-    required?: boolean;
-    type?: typescript0.TypeNode;
-  }) => typescript0.ParameterDeclaration;
-  propertyAccessExpression: ({
-    expression,
-    isOptional,
-    name
-  }: {
-    expression: string | typescript0.Expression;
-    isOptional?: boolean;
-    name: string | number | typescript0.MemberName;
-  }) => typescript0.PropertyAccessChain | typescript0.PropertyAccessExpression | typescript0.ElementAccessExpression;
-  propertyAccessExpressions: ({
-    expressions
-  }: {
-    expressions: Array<string | typescript0.Expression | typescript0.MemberName>;
-  }) => typescript0.PropertyAccessExpression;
-  propertyAssignment: ({
-    initializer,
-    name
-  }: {
-    initializer: typescript0.Expression;
-    name: string | typescript0.PropertyName;
-  }) => typescript0.PropertyAssignment;
-  propertyDeclaration: ({
-    initializer,
-    modifier,
-    name,
-    type
-  }: {
-    initializer?: typescript0.Expression;
-    modifier?: "async" | AccessLevel | "export" | "readonly" | "static";
-    name: string | typescript0.PropertyName;
-    type?: typescript0.TypeNode;
-  }) => typescript0.PropertyDeclaration;
-  regularExpressionLiteral: ({
-    flags,
-    text
-  }: {
-    flags?: ReadonlyArray<"g" | "i" | "m" | "s" | "u" | "y">;
-    text: string;
-  }) => typescript0.RegularExpressionLiteral;
-  returnFunctionCall: ({
-    args,
-    name,
-    types: types_d_exports
-  }: {
-    args: any[];
-    name: string | typescript0.Expression;
-    types?: ReadonlyArray<string | typescript0.StringLiteral>;
-  }) => typescript0.ReturnStatement;
-  returnStatement: ({
-    expression
-  }: {
-    expression?: typescript0.Expression;
-  }) => typescript0.ReturnStatement;
-  returnVariable: ({
-    expression
-  }: {
-    expression: string | typescript0.Expression;
-  }) => typescript0.ReturnStatement;
-  safeAccessExpression: (path: string[]) => typescript0.Expression;
-  stringLiteral: ({
-    isSingleQuote,
-    text
-  }: {
-    isSingleQuote?: boolean;
-    text: string;
-  }) => typescript0.StringLiteral;
-  templateLiteralType: ({
-    value
-  }: {
-    value: ReadonlyArray<string | typescript0.TypeNode>;
-  }) => typescript0.TemplateLiteralTypeNode;
-  this: () => typescript0.ThisExpression;
-  transformArrayMap: ({
-    path,
-    transformExpression
-  }: {
-    path: string[];
-    transformExpression: typescript0.Expression;
-  }) => typescript0.IfStatement;
-  transformArrayMutation: ({
-    path,
-    transformerName
-  }: {
-    path: string[];
-    transformerName: string;
-  }) => typescript0.Statement;
-  transformDateMutation: ({
-    path
-  }: {
-    path: string[];
-  }) => typescript0.Statement;
-  transformFunctionMutation: ({
-    path,
-    transformerName
-  }: {
-    path: string[];
-    transformerName: string;
-  }) => typescript0.IfStatement[];
-  transformNewDate: ({
-    parameterName
-  }: {
-    parameterName: string;
-  }) => typescript0.NewExpression;
-  typeAliasDeclaration: ({
-    comment,
-    exportType,
-    name,
-    type,
-    typeParameters
-  }: {
-    comment?: Comments;
-    exportType?: boolean;
-    name: string | typescript0.TypeReferenceNode;
-    type: string | typescript0.TypeNode | typescript0.Identifier;
-    typeParameters?: FunctionTypeParameter[];
-  }) => typescript0.TypeAliasDeclaration;
-  typeArrayNode: (types: ReadonlyArray<any | typescript0.TypeNode> | typescript0.TypeNode | typescript0.Identifier | string, isNullable?: boolean) => typescript0.TypeNode;
-  typeInterfaceNode: ({
-    indexKey,
-    indexProperty,
-    isNullable,
-    properties,
-    useLegacyResolution
-  }: {
-    indexKey?: typescript0.TypeReferenceNode;
-    indexProperty?: Property;
-    isNullable?: boolean;
-    properties: Property[];
-    useLegacyResolution: boolean;
-  }) => typescript0.TypeNode;
-  typeIntersectionNode: ({
-    isNullable,
-    types: types_d_exports
-  }: {
-    isNullable?: boolean;
-    types: (any | typescript0.TypeNode)[];
-  }) => typescript0.TypeNode;
-  typeNode: (base: any | typescript0.TypeNode, args?: (any | typescript0.TypeNode)[]) => typescript0.TypeNode;
-  typeOfExpression: ({
-    text
-  }: {
-    text: string | typescript0.Identifier;
-  }) => typescript0.TypeOfExpression;
-  typeOperatorNode: ({
-    operator,
-    type
-  }: {
-    operator: "keyof" | "readonly" | "unique";
-    type: typescript0.TypeNode;
-  }) => typescript0.TypeOperatorNode;
-  typeParameterDeclaration: ({
-    constraint,
-    defaultType,
-    modifiers,
-    name
-  }: {
-    constraint?: typescript0.TypeNode;
-    defaultType?: typescript0.TypeNode;
-    modifiers?: Array<typescript0.Modifier>;
-    name: string | typescript0.Identifier;
-  }) => typescript0.TypeParameterDeclaration;
-  typeParenthesizedNode: ({
-    type
-  }: {
-    type: typescript0.TypeNode;
-  }) => typescript0.ParenthesizedTypeNode;
-  typeRecordNode: (keys: (any | typescript0.TypeNode)[], values: (any | typescript0.TypeNode)[], isNullable?: boolean, useLegacyResolution?: boolean) => typescript0.TypeNode;
-  typeReferenceNode: ({
-    typeArguments,
-    typeName
-  }: {
-    typeArguments?: typescript0.TypeNode[];
-    typeName: string | typescript0.EntityName;
-  }) => typescript0.TypeReferenceNode;
-  typeTupleNode: ({
-    isNullable,
-    types: types_d_exports
-  }: {
-    isNullable?: boolean;
-    types: Array<any | typescript0.TypeNode>;
-  }) => typescript0.TypeNode;
-  typeUnionNode: ({
-    isNullable,
-    types: types_d_exports
-  }: {
-    isNullable?: boolean;
-    types: ReadonlyArray<any | typescript0.TypeNode>;
-  }) => typescript0.TypeNode;
-  valueToExpression: <T = unknown>({
-    identifiers,
-    isValueAccess,
-    shorthand,
-    unescape,
-    value
-  }: {
-    identifiers?: string[];
-    isValueAccess?: boolean;
-    shorthand?: boolean;
-    unescape?: boolean;
-    value: T;
-  }) => typescript0.Expression | undefined;
+//#endregion
+//#region src/plugins/@hey-api/client-angular/types.d.ts
+type UserConfig$20 = 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$20, UserConfig$20, IApi$14>;
 //#endregion
-//#region src/plugins/@hey-api/sdk/comment.d.ts
-declare const createOperationComment: ({
-  operation
-}: {
-  operation: IR$1.OperationObject;
-}) => Comments | undefined;
+//#region src/plugins/@hey-api/legacy-angular/types.d.ts
+type UserConfig$19 = Plugin.Name<'legacy/angular'> & Pick<Client.Config, 'output'>;
+type HeyApiClientLegacyAngularPlugin = DefinePlugin<UserConfig$19>;
+//#endregion
+//#region src/plugins/@hey-api/legacy-axios/types.d.ts
+type UserConfig$18 = Plugin.Name<'legacy/axios'> & Pick<Client.Config, 'output'>;
+type HeyApiClientLegacyAxiosPlugin = DefinePlugin<UserConfig$18>;
+//#endregion
+//#region src/plugins/@hey-api/legacy-fetch/types.d.ts
+type UserConfig$17 = Plugin.Name<'legacy/fetch'> & Pick<Client.Config, 'output'>;
+type HeyApiClientLegacyFetchPlugin = DefinePlugin<UserConfig$17>;
+//#endregion
+//#region src/plugins/@hey-api/legacy-node/types.d.ts
+type UserConfig$16 = Plugin.Name<'legacy/node'> & Pick<Client.Config, 'output'>;
+type HeyApiClientLegacyNodePlugin = DefinePlugin<UserConfig$16>;
+//#endregion
+//#region src/plugins/@hey-api/legacy-xhr/types.d.ts
+type UserConfig$15 = Plugin.Name<'legacy/xhr'> & Pick<Client.Config, 'output'>;
+type HeyApiClientLegacyXhrPlugin = DefinePlugin<UserConfig$15>;
+//#endregion
+//#region src/plugins/@hey-api/schemas/api.d.ts
+type SelectorType$13 = 'ref';
+type IApi$13 = {
+  /**
+   * @param type Selector type.
+   * @param value Depends on `type`:
+   *  - `ref`: `$ref` JSON pointer
+   * @returns Selector array
+   */
+  selector: (type: SelectorType$13, value?: string) => Selector;
+};
+//#endregion
+//#region src/plugins/@hey-api/schemas/types.d.ts
+type UserConfig$14 = Plugin.Name<'@hey-api/schemas'> & Plugin.Hooks & {
+  /**
+   * Should the exports from the generated files be re-exported in the index
+   * barrel file?
+   *
+   * @default false
+   */
+  exportFromIndex?: boolean;
+  /**
+   * Customise the schema name. By default, `{{name}}Schema` is used. `name` is a
+   * valid JavaScript/TypeScript identifier, e.g. if your schema name is
+   * "Foo-Bar", `name` value would be "FooBar".
+   *
+   * @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);
+  /**
+   * Choose schema type to generate. Select 'form' if you don't want
+   * descriptions to reduce bundle size and you plan to use schemas
+   * for form validation
+   *
+   * @default 'json'
+   */
+  type?: 'form' | 'json';
+};
+type HeyApiSchemasPlugin = DefinePlugin<UserConfig$14, UserConfig$14, IApi$13>;
 //#endregion
 //#region src/plugins/@hey-api/sdk/api.d.ts
 type SelectorType$12 = 'buildClientParams' | 'class' | 'Client' | 'Composable' | 'formDataBodySerializer' | 'function' | 'Injectable' | 'Options' | 'urlSearchParamsBodySerializer';
 type IApi$12 = {
-  createOperationComment: typeof createOperationComment;
   /**
    * @param type Selector type.
    * @param value Depends on `type`:
@@ -10300,19 +9368,26 @@ type Config$12 = Plugin.Name<'@hey-api/transformers'> & Plugin.Hooks & {
 };
 type HeyApiTransformersPlugin = DefinePlugin<UserConfig$12, Config$12, IApi$11>;
 //#endregion
-//#region src/plugins/@hey-api/typescript/plugin.d.ts
-declare const schemaToType: ({
+//#region src/plugins/@hey-api/typescript/shared/types.d.ts
+type IrSchemaToAstOptions = {
+  plugin: HeyApiTypeScriptPlugin['Instance'];
+  state: ToRefs<PluginState>;
+};
+type PluginState = Pick<Required<SymbolMeta>, 'path'> & Pick<Partial<SymbolMeta>, 'tags'>;
+//#endregion
+//#region src/plugins/@hey-api/typescript/v1/plugin.d.ts
+declare const irSchemaToAst: ({
   plugin,
-  schema
-}: {
-  plugin: HeyApiTypeScriptPlugin["Instance"];
+  schema,
+  state
+}: IrSchemaToAstOptions & {
   schema: IR$1.SchemaObject;
 }) => ts.TypeNode;
 //#endregion
 //#region src/plugins/@hey-api/typescript/api.d.ts
 type SelectorType$10 = 'ClientOptions' | 'data' | 'error' | 'errors' | 'ref' | 'response' | 'responses' | 'TypeID' | 'webhook-payload' | 'webhook-request' | 'Webhooks';
 type IApi$10 = {
-  schemaToType: (args: Parameters<typeof schemaToType>[0]) => ts.TypeNode;
+  schemaToType: (args: Parameters<typeof irSchemaToAst>[0]) => ts.TypeNode;
   /**
    * @param type Selector type.
    * @param value Depends on `type`:
@@ -15847,97 +14922,6 @@ interface IRComponentsObject {
   requestBodies?: Record<string, IRRequestBodyObject>;
   schemas?: Record<string, IRSchemaObject>;
 }
-interface IRHooks {
-  /**
-   * 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
-     * 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
-     * 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
-     * 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;
-  };
-}
 interface IROperationObject {
   body?: IRBodyObject;
   deprecated?: boolean;
@@ -16080,7 +15064,6 @@ declare namespace IR$1 {
   export type BodyObject = IRBodyObject;
   export type ComponentsObject = IRComponentsObject;
   export type Context<Spec extends Record<string, any> = any> = IRContext<Spec>;
-  export type Hooks = IRHooks;
   export type Model = IRModel;
   export type OperationObject = IROperationObject;
   export type ParameterObject = IRParameterObject;
@@ -16119,5 +15102,5 @@ interface WatchValues {
   lastValue?: string;
 }
 //#endregion
-export { StringCase as C, MaybeArray as D, LazyOrAsync as E, OpenApiSchemaObject as S, Logger as T, OpenApiMetaObject as _, ExpressionTransformer as a, OpenApiRequestBodyObject as b, Client as c, Plugin as d, Client$1 as f, OpenApi$1 as g, UserConfig$27 as h, TypeTransformer as i, PluginHandler as l, Config$1 as m, WatchValues as n, compiler as o, parseOpenApiSpec as p, IR$1 as r, tsc as s, LegacyIR as t, DefinePlugin as u, OpenApiOperationObject as v, Input as w, OpenApiResponseObject as x, OpenApiParameterObject as y };
-//# sourceMappingURL=types-DGAzCzMG.d.ts.map
+export { FunctionParameter as A, Input as C, ImportExportItemObject as D, Comments as E, ObjectValue as M, SyntaxKindKeyword as N, tsNodeToString as O, types_d_exports as P, StringCase as S, MaybeArray as T, OpenApiOperationObject as _, ExpressionTransformer as a, OpenApiResponseObject as b, DefinePlugin as c, parseOpenApiSpec as d, Logger as f, OpenApiMetaObject as g, OpenApi$3 as h, TypeTransformer as i, FunctionTypeParameter as j, AccessLevel as k, Plugin as l, UserConfig$27 as m, WatchValues as n, Client as o, Config$1 as p, IR$1 as r, PluginHandler as s, LegacyIR as t, Client$1 as u, OpenApiParameterObject as v, LazyOrAsync as w, OpenApiSchemaObject as x, OpenApiRequestBodyObject as y };
+//# sourceMappingURL=types-yDJUUQN6.d.ts.map