@hey-api/openapi-ts 0.57.1 → 0.59.0

package/dist/index.d.cts

@@ -1,3 +1,29 @@
+import fs from 'node:fs';
+import ts from 'typescript';
+
+interface ImportExportItemObject {
+    alias?: string;
+    asType?: boolean;
+    name: string;
+}
+
+type ExtractWithDiscriminator<T, Discriminator> = T extends Discriminator ? T : never;
+/**
+ * Accepts an array of elements union and attempts to extract only objects.
+ * For example, Array<string | number | { id: string }> would result in
+ * Array<{ id: string }>.
+ */
+type ExtractArrayOfObjects<T, Discriminator> = T extends Array<infer U> ? Array<ExtractWithDiscriminator<U, Discriminator>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<ExtractWithDiscriminator<U, Discriminator>> : never;
+type Files = Record<string, TypeScriptFile>;
+/**
+ * Transforms an array of objects into an optional object map.
+ * For example, Array<{ id: string }> would result in
+ * { [key: string]?: { id: string } }
+ */
+type ArrayOfObjectsToObjectMap<T extends ReadonlyArray<Record<string, any>>, D extends keyof T[number]> = {
+    [K in T[number][D]]?: Extract<T[number], Record<D, K>>;
+};
+
 type PluginNames =
   | '@hey-api/schemas'
   | '@hey-api/sdk'
@@ -11,17 +37,73 @@ type PluginNames =
   | 'fastify'
   | 'zod';
 
-interface PluginName<Name extends PluginNames> {
-  name: Name;
-}
-
-interface CommonConfig {
+interface BaseConfig {
   // eslint-disable-next-line @typescript-eslint/ban-types
   name: PluginNames | (string & {});
   output?: string;
 }
 
-type UserConfig$1<Config extends CommonConfig> = Omit<Config, 'output'>;
+interface Dependencies {
+  /**
+   * Required dependencies will be always processed, regardless of whether
+   * a user defines them in their `plugins` config.
+   */
+  _dependencies?: ReadonlyArray<PluginNames>;
+  /**
+   * Optional dependencies are not processed unless a user explicitly defines
+   * them in their `plugins` config.
+   */
+  _optionalDependencies?: ReadonlyArray<PluginNames>;
+}
+
+/**
+ * Public Plugin API.
+ */
+declare namespace Plugin {
+  export type Config<Config extends BaseConfig> = Config &
+    Dependencies & {
+      _handler: Plugin.Handler<Config>;
+      _handlerLegacy: Plugin.LegacyHandler<Config>;
+    };
+
+  export type DefineConfig<Config extends BaseConfig> = (
+    config?: Plugin.UserConfig<Config>,
+  ) => Plugin.Config<Config>;
+
+  /**
+   * Plugin implementation for experimental parser.
+   */
+  export type Handler<Config extends BaseConfig> = (args: {
+    context: IRContext;
+    plugin: Plugin.Instance<Config>;
+  }) => void;
+
+  export type Instance<Config extends BaseConfig> = Omit<
+    Config,
+    '_dependencies' | '_handler' | '_handlerLegacy' | '_optionalDependencies'
+  > &
+    Pick<Required<Config>, 'output'>;
+
+  /**
+   * Plugin implementation for legacy parser. Use only if you need to support
+   * OpenAPI 2.0 since that isn't supported by the experimental parser yet.
+   */
+  export type LegacyHandler<Config extends BaseConfig> = (args: {
+    client: Client;
+    files: Files;
+    openApi: OpenApi;
+    plugin: Plugin.Instance<Config>;
+  }) => void;
+
+  export interface Name<Name extends PluginNames> {
+    name: Name;
+  }
+
+  /**
+   * Users cannot modify output file path to avoid risk of conflicts.
+   */
+  export type UserConfig<Config extends BaseConfig> = Omit<Config, 'output'>;
+}
 
 interface EnumExtensions {
   /**
@@ -3802,7 +3884,7 @@ interface XMLObject {
   wrapped?: boolean;
 }
 
-interface Config$a extends PluginName<'@hey-api/schemas'> {
+interface Config$b extends Plugin.Name<'@hey-api/schemas'> {
   /**
    * Customise the schema name. By default, `{{name}}Schema` is used. `name` is a
    * valid JavaScript/TypeScript identifier, e.g. if your schema name is
@@ -3833,6 +3915,17 @@ interface Config$a extends PluginName<'@hey-api/schemas'> {
 
 type IRMediaType = 'form-data' | 'json' | 'url-search-params';
 
+interface IR {
+  components?: IRComponentsObject;
+  paths?: IRPathsObject;
+}
+
+interface IRComponentsObject {
+  parameters?: Record<string, IRParameterObject>;
+  requestBodies?: Record<string, IRRequestBodyObject>;
+  schemas?: Record<string, IRSchemaObject>;
+}
+
 interface IRPathsObject {
   [path: `/${string}`]: IRPathItemObject;
 }
@@ -3918,6 +4011,12 @@ interface IRParameterObject
     | 'spaceDelimited';
 }
 
+interface IRRequestBodyObject
+  extends Pick<JsonSchemaDraft2020_12, 'description'> {
+  required?: boolean;
+  schema: IRSchemaObject;
+}
+
 interface IRResponsesObject {
   /**
    * 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.
@@ -4002,7 +4101,7 @@ interface IRSchemaObject
     | 'void';
 }
 
-interface Config$9 extends PluginName<'@hey-api/sdk'> {
+interface Config$a extends Plugin.Name<'@hey-api/sdk'> {
   /**
    * Group operation methods into classes? When enabled, you can
    * select which classes to export with `sdk.include` and/or
@@ -4063,10 +4162,10 @@ interface Config$9 extends PluginName<'@hey-api/sdk'> {
   serviceNameBuilder?: string;
 }
 
-interface Config$8 extends PluginName<'@hey-api/transformers'> {
+interface Config$9 extends Plugin.Name<'@hey-api/transformers'> {
   /**
    * Convert date strings into Date objects?
-   * @default false
+   * @default true
    */
   dates?: boolean;
   /**
@@ -4076,25 +4175,43 @@ interface Config$8 extends PluginName<'@hey-api/transformers'> {
   output?: string;
 }
 
-interface Config$7 extends PluginName<'@hey-api/typescript'> {
+interface Config$8 extends Plugin.Name<'@hey-api/typescript'> {
   /**
    * By default, enums are generated as TypeScript types. In addition to that,
    * you can choose to generate them as JavaScript objects, TypeScript enums,
    * or TypeScript enums contained within namespaces.
+   *
    * @default false
    */
   enums?: 'javascript' | 'typescript' | 'typescript+namespace' | false;
   /**
+   * **This feature works only with the experimental parser**
+   *
+   * Defines casing of the enum keys. By default, we use `SCREAMING_SNAKE_CASE`.
+   * This option has effect only when `enums` is defined.
+   *
+   * @default 'SCREAMING_SNAKE_CASE'
+   */
+  enumsCase?: StringCase;
+  /**
+   * **This feature works only with the experimental parser**
+   *
    * By default, inline enums (enums not defined as reusable components in
    * the input file) are generated as inlined union types. You can set
    * `exportInlineEnums` to `true` to treat inline enums as reusable components.
    * When `true`, the exported enums will follow the style defined in `enums`.
    *
-   * This option works only with the experimental parser.
-   *
    * @default false
    */
   exportInlineEnums?: boolean;
+  /**
+   * **This feature works only with the experimental parser**
+   *
+   * Defines casing of the identifiers. By default, we use `PascalCase`.
+   *
+   * @default 'PascalCase'
+   */
+  identifierCase?: Exclude<StringCase, 'SCREAMING_SNAKE_CASE'>;
   /**
    * Include only types matching regular expression.
    *
@@ -4109,13 +4226,21 @@ interface Config$7 extends PluginName<'@hey-api/typescript'> {
    */
   output?: string;
   /**
+   * **This feature works only with the legacy parser**
+   *
    * Use your preferred naming pattern
+   *
    * @default 'preserve'
+   *
+   * @deprecated
    */
   style?: 'PascalCase' | 'preserve';
   /**
+   * **This feature works only with the legacy parser**
+   *
    * Generate a tree of types containing all operations? It will be named
    * $OpenApiTs.
+   *
    * @default false
    *
    * @deprecated
@@ -4123,8 +4248,8 @@ interface Config$7 extends PluginName<'@hey-api/typescript'> {
   tree?: boolean;
 }
 
-interface Config$6
-  extends PluginName<'@tanstack/angular-query-experimental'> {
+interface Config$7
+  extends Plugin.Name<'@tanstack/angular-query-experimental'> {
   /**
    * Generate {@link https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions `infiniteQueryOptions()`} helpers? These will be generated from GET and POST requests where a pagination parameter is detected.
    * @default true
@@ -4148,7 +4273,7 @@ interface Config$6
   queryOptions?: boolean;
 }
 
-interface Config$5 extends PluginName<'@tanstack/react-query'> {
+interface Config$6 extends Plugin.Name<'@tanstack/react-query'> {
   /**
    * Generate {@link https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions `infiniteQueryOptions()`} helpers? These will be generated from GET and POST requests where a pagination parameter is detected.
    * @default true
@@ -4172,7 +4297,7 @@ interface Config$5 extends PluginName<'@tanstack/react-query'> {
   queryOptions?: boolean;
 }
 
-interface Config$4 extends PluginName<'@tanstack/solid-query'> {
+interface Config$5 extends Plugin.Name<'@tanstack/solid-query'> {
   /**
    * Generate `createInfiniteQuery()` helpers? These will be generated from GET and POST requests where a pagination parameter is detected.
    * @default true
@@ -4196,7 +4321,7 @@ interface Config$4 extends PluginName<'@tanstack/solid-query'> {
   queryOptions?: boolean;
 }
 
-interface Config$3 extends PluginName<'@tanstack/svelte-query'> {
+interface Config$4 extends Plugin.Name<'@tanstack/svelte-query'> {
   /**
    * Generate `createInfiniteQuery()` helpers? These will be generated from GET and POST requests where a pagination parameter is detected.
    * @default true
@@ -4220,7 +4345,7 @@ interface Config$3 extends PluginName<'@tanstack/svelte-query'> {
   queryOptions?: boolean;
 }
 
-interface Config$2 extends PluginName<'@tanstack/vue-query'> {
+interface Config$3 extends Plugin.Name<'@tanstack/vue-query'> {
   /**
    * Generate {@link https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions `infiniteQueryOptions()`} helpers? These will be generated from GET and POST requests where a pagination parameter is detected.
    * @default true
@@ -4244,7 +4369,7 @@ interface Config$2 extends PluginName<'@tanstack/vue-query'> {
   queryOptions?: boolean;
 }
 
-interface Config$1 extends PluginName<'fastify'> {
+interface Config$2 extends Plugin.Name<'fastify'> {
   /**
    * Name of the generated file.
    * @default 'fastify'
@@ -4255,7 +4380,7 @@ interface Config$1 extends PluginName<'fastify'> {
 // import type { IROperationObject, IRSchemaObject } from '../../ir/ir';
 
 
-interface Config extends PluginName<'zod'> {
+interface Config$1 extends Plugin.Name<'zod'> {
   /**
    * Customise the Zod schema name. By default, `z{{name}}` is used,
    * where `name` is a definition name or an operation name.
@@ -4271,16 +4396,18 @@ interface Config extends PluginName<'zod'> {
 /**
  * User-facing plugin types.
  */
-type UserPlugins = UserConfig$1<Config$a> | UserConfig$1<Config$9> | UserConfig$1<Config$8> | UserConfig$1<Config$7> | UserConfig$1<Config$6> | UserConfig$1<Config$5> | UserConfig$1<Config$4> | UserConfig$1<Config$3> | UserConfig$1<Config$2> | UserConfig$1<Config$1> | UserConfig$1<Config>;
+type UserPlugins = Plugin.UserConfig<Config$b> | Plugin.UserConfig<Config$a> | Plugin.UserConfig<Config$9> | Plugin.UserConfig<Config$8> | Plugin.UserConfig<Config$7> | Plugin.UserConfig<Config$6> | Plugin.UserConfig<Config$5> | Plugin.UserConfig<Config$4> | Plugin.UserConfig<Config$3> | Plugin.UserConfig<Config$2> | Plugin.UserConfig<Config$1>;
+/**
+ * Internal plugin types.
+ */
+type ClientPlugins = Plugin.Config<Config$b> | Plugin.Config<Config$a> | Plugin.Config<Config$9> | Plugin.Config<Config$8> | Plugin.Config<Config$7> | Plugin.Config<Config$6> | Plugin.Config<Config$5> | Plugin.Config<Config$4> | Plugin.Config<Config$3> | Plugin.Config<Config$2> | Plugin.Config<Config$1>;
 
 declare const CLIENTS: readonly ["@hey-api/client-axios", "@hey-api/client-fetch", "legacy/angular", "legacy/axios", "legacy/fetch", "legacy/node", "legacy/xhr"];
 type Client$2 = (typeof CLIENTS)[number];
+type Formatters = 'biome' | 'prettier';
+type Linters = 'biome' | 'eslint' | 'oxlint';
+type StringCase = 'camelCase' | 'PascalCase' | 'preserve' | 'snake_case' | 'SCREAMING_SNAKE_CASE';
 interface ClientConfig {
-    /**
-     * Manually set base in OpenAPI config instead of inferring from server value
-     * @deprecated
-     */
-    base?: string;
     /**
      * HTTP client to generate
      */
@@ -4292,6 +4419,7 @@ interface ClientConfig {
          * package and bundled with the rest of the generated output. This is
          * useful if you're repackaging the output, publishing it to other users,
          * and you don't want them to install any dependencies.
+         *
          * @default false
          */
         bundle?: boolean;
@@ -4305,26 +4433,18 @@ interface ClientConfig {
      * config file name, or it's not located in the project root.
      */
     configFile?: string;
-    /**
-     * Run in debug mode?
-     * @default false
-     */
-    debug?: boolean;
     /**
      * Skip writing files to disk?
+     *
      * @default false
      */
     dryRun?: boolean;
     /**
-     * Opt-in to the experimental parser?
+     * Opt in to the experimental parser?
+     *
      * @default false
      */
     experimentalParser?: boolean;
-    /**
-     * Generate core client classes?
-     * @default true
-     */
-    exportCore?: boolean;
     /**
      * Path to the OpenAPI specification. This can be either local or remote path.
      * Both JSON and YAML file formats are supported. You can also pass the parsed
@@ -4334,6 +4454,8 @@ interface ClientConfig {
      */
     input: string | Record<string, unknown> | {
         /**
+         * **This feature works only with the experimental parser**
+         *
          * Prevent parts matching the regular expression from being processed.
          * You can select both operations and components by reference within
          * the bundled input. In case of conflicts, `exclude` takes precedence
@@ -4345,6 +4467,8 @@ interface ClientConfig {
          */
         exclude?: string;
         /**
+         * **This feature works only with the experimental parser**
+         *
          * Process only parts matching the regular expression. You can select both
          * operations and components by reference within the bundled input. In
          * case of conflicts, `exclude` takes precedence over `include`.
@@ -4362,53 +4486,330 @@ interface ClientConfig {
         path: string | Record<string, unknown>;
     };
     /**
-     * Custom client class name. Please note this option is deprecated and
-     * will be removed in favor of clients.
-     * @link https://heyapi.dev/openapi-ts/migrating.html#deprecated-name
-     * @deprecated
+     * The relative location of the logs folder
+     *
+     * @default process.cwd()
      */
-    name?: string;
+    logs?: string | {
+        /**
+         * The logging level to control the verbosity of log output.
+         * Determines which messages are logged based on their severity.
+         *
+         * Available levels (in increasing order of severity):
+         * - `trace`: Detailed debug information, primarily for development.
+         * - `debug`: Diagnostic information useful during debugging.
+         * - `info`: General operational messages that indicate normal application behavior.
+         * - `warn`: Potentially problematic situations that require attention.
+         * - `error`: Errors that prevent some functionality but do not crash the application.
+         * - `fatal`: Critical errors that cause the application to terminate.
+         * - `silent`: Disables all logging.
+         *
+         * Messages with a severity equal to or higher than the specified level will be logged.
+         *
+         * @default 'info'
+         */
+        level?: 'debug' | 'error' | 'fatal' | 'info' | 'silent' | 'trace' | 'warn';
+        /**
+         * The relative location of the logs folder
+         *
+         * @default process.cwd()
+         */
+        path?: string;
+    };
     /**
      * The relative location of the output folder
      */
     output: string | {
+        /**
+         * **This feature works only with the experimental parser**
+         *
+         * Defines casing of the output fields. By default, we preserve `input`
+         * values as data transforms incur a performance penalty at runtime.
+         *
+         * @default undefined
+         */
+        case?: Exclude<StringCase, 'SCREAMING_SNAKE_CASE'>;
+        /**
+         * Clean the `output` folder on every run? If disabled, this folder may
+         * be used to store additional files. The default option is `true` to
+         * reduce the risk of keeping outdated files around when configuration,
+         * input, or package version changes.
+         *
+         * @default true
+         */
+        clean?: boolean;
         /**
          * Process output folder with formatter?
+         *
          * @default false
          */
-        format?: 'biome' | 'prettier' | false;
+        format?: Formatters | false;
         /**
          * Process output folder with linter?
+         *
          * @default false
          */
-        lint?: 'biome' | 'eslint' | 'oxlint' | false;
+        lint?: Linters | false;
         /**
          * The relative location of the output folder
          */
         path: string;
     };
     /**
-     * Plugins are used to generate artifacts from provided input.
+     * Plugins generate artifacts from `input`. By default, we generate SDK
+     * functions and TypeScript interfaces. If you manually define `plugins`,
+     * you need to include the default plugins if you wish to use them.
+     *
+     * @default ['@hey-api/typescript', '@hey-api/sdk']
      */
     plugins?: ReadonlyArray<UserPlugins['name'] | UserPlugins>;
+    /**
+     * Manually set base in OpenAPI config instead of inferring from server value
+     *
+     * @deprecated
+     */
+    base?: string;
+    /**
+     * 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.
+     *
+     * @link https://heyapi.dev/openapi-ts/migrating.html#deprecated-name
+     *
+     * @deprecated
+     */
+    name?: string;
     /**
      * Path to custom request file. Please note this option is deprecated and
      * will be removed in favor of clients.
+     *
      * @link https://heyapi.dev/openapi-ts/migrating.html#deprecated-request
+     *
      * @deprecated
      */
     request?: string;
     /**
      * Use options or arguments functions. Please note this option is deprecated and
      * will be removed in favor of clients.
+     *
      * @link https://heyapi.dev/openapi-ts/migrating.html#deprecated-useoptions
+     *
      * @deprecated
+     *
      * @default true
      */
     useOptions?: boolean;
 }
 interface UserConfig extends ClientConfig {
 }
+type Config = Omit<Required<ClientConfig>, 'base' | 'client' | 'input' | 'logs' | 'name' | 'output' | 'plugins' | 'request'> & Pick<ClientConfig, 'base' | 'name' | 'request'> & {
+    client: Extract<Required<ClientConfig>['client'], object>;
+    input: ExtractWithDiscriminator<ClientConfig['input'], {
+        path: unknown;
+    }>;
+    logs: Extract<Required<ClientConfig['logs']>, object>;
+    output: Extract<ClientConfig['output'], object>;
+    pluginOrder: ReadonlyArray<ClientPlugins['name']>;
+    plugins: ArrayOfObjectsToObjectMap<ExtractArrayOfObjects<ReadonlyArray<ClientPlugins>, {
+        name: string;
+    }>, 'name'>;
+};
+
+interface Identifier {
+    /**
+     * Did this function add a new property to the file's `identifiers` map?
+     */
+    created: boolean;
+    /**
+     * The resolved identifier name. False means the identifier has been blacklisted.
+     */
+    name: string | false;
+}
+type Namespace = Record<string, Pick<Identifier, 'name'> & {
+    /**
+     * Ref to the type in OpenAPI specification.
+     */
+    $ref: string;
+}>;
+interface Namespaces {
+    /**
+     * Type namespace. Types, interfaces, and type aliases exist here.
+     * @example
+     * ```ts
+     * export type Foo = string;
+     * ```
+     */
+    type: Namespace;
+    /**
+     * Value namespace. Variables, functions, classes, and constants exist here.
+     * @example
+     * ```js
+     * export const foo = '';
+     * ```
+     */
+    value: Namespace;
+}
+declare class TypeScriptFile {
+    private _headers;
+    private _identifierCase;
+    private _imports;
+    private _items;
+    private _name;
+    private _path;
+    namespaces: Namespaces;
+    /**
+     * Path relative to the client output root.
+     */
+    constructor({ dir, header, identifierCase, name, }: {
+        dir: string;
+        header?: boolean;
+        identifierCase?: StringCase;
+        name: string;
+    });
+    add(...nodes: Array<ts.Node | string>): void;
+    /**
+     * Prevents a specific identifier from being created. This is useful for
+     * transformers where we know a certain transformer won't be needed, and
+     * we want to avoid attempting to create since we know it won't happen.
+     */
+    blockIdentifier({ $ref, namespace, }: Pick<EnsureUniqueIdentifierData, '$ref'> & {
+        namespace: keyof Namespaces;
+    }): Identifier;
+    identifier({ namespace, ...args }: Omit<EnsureUniqueIdentifierData, 'case' | 'namespace'> & {
+        namespace: keyof Namespaces;
+    }): Identifier;
+    /**
+     * Adds an import to the provided module. Handles duplication, returns added import.
+     */
+    import({ module, ...importedItem }: ImportExportItemObject & {
+        module: string;
+    }): ImportExportItemObject;
+    isEmpty(): boolean;
+    nameWithoutExtension(): string;
+    relativePathToFile({ context, id, }: {
+        context: IRContext;
+        id: string;
+    }): string;
+    remove(options?: Parameters<typeof fs.rmSync>[1]): void;
+    /**
+     * Removes last node form the stack. Works as undo.
+     */
+    removeNode(): void;
+    private _setName;
+    toString(separator?: string): string;
+    write(separator?: string): void;
+}
+interface EnsureUniqueIdentifierData {
+    $ref: string;
+    case: StringCase | undefined;
+    count?: number;
+    create?: boolean;
+    namespace: Namespace;
+    validNameTransformer?: (value: string) => string;
+}
+
+interface ContextFile {
+    /**
+     * Unique file identifier.
+     */
+    id: string;
+    /**
+     * Define casing for identifiers in this file.
+     */
+    identifierCase?: StringCase;
+    /**
+     * Relative file path to the output path.
+     * @example
+     * 'bar/foo.ts'
+     */
+    path: string;
+}
+interface Events {
+    /**
+     * Called after parsing.
+     */
+    after: () => void;
+    /**
+     * Called before parsing.
+     */
+    before: () => void;
+    operation: (args: {
+        method: keyof IRPathItemObject;
+        operation: IROperationObject;
+        path: string;
+    }) => void;
+    parameter: (args: {
+        $ref: string;
+        name: string;
+        parameter: IRParameterObject;
+    }) => void;
+    requestBody: (args: {
+        $ref: string;
+        name: string;
+        requestBody: IRRequestBodyObject;
+    }) => void;
+    schema: (args: {
+        $ref: string;
+        name: string;
+        schema: IRSchemaObject;
+    }) => void;
+}
+declare class IRContext<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;
+    /**
+     * A map of files that will be generated from `spec`.
+     */
+    files: Files;
+    /**
+     * Intermediate representation model obtained from `spec`.
+     */
+    ir: IR;
+    /**
+     * Resolved specification from `input`.
+     */
+    spec: Spec;
+    /**
+     * A map of event listeners.
+     */
+    private listeners;
+    constructor({ config, spec }: {
+        config: Config;
+        spec: Spec;
+    });
+    /**
+     * Notify all event listeners about `event`.
+     */
+    broadcast<T extends keyof Events>(event: T, ...args: Parameters<Events[T]>): Promise<void>;
+    /**
+     * Create and return a new TypeScript file. Also set the current file context
+     * to the newly created file.
+     */
+    createFile(file: ContextFile): TypeScriptFile;
+    /**
+     * Returns a specific file by ID from `files`.
+     */
+    file({ id }: Pick<ContextFile, 'id'>): TypeScriptFile | undefined;
+    resolveIrRef<T>($ref: string): T;
+    /**
+     * Returns a resolved reference from `spec`.
+     */
+    resolveRef<T>($ref: string): T;
+    /**
+     * Register a new `event` listener.
+     */
+    subscribe<T extends keyof Events>(event: T, callbackFn: Events[T]): void;
+}
 
 interface Dictionary<T = unknown> {
     [key: string]: T;
@@ -4424,7 +4825,7 @@ interface OpenApiReference$1 {
 /**
  * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#example-object
  */
-interface OpenApiExample extends OpenApiReference$1 {
+interface OpenApiExample$1 extends OpenApiReference$1 {
     description?: string;
     externalValue?: string;
     summary?: string;
@@ -4520,20 +4921,20 @@ type MediaType = 'application/json';
  */
 interface MediaTypeObject {
     example?: unknown;
-    examples?: Dictionary<OpenApiExample>;
+    examples?: Dictionary<OpenApiExample$1>;
     schema: OpenApiSchema$1;
 }
 /**
  * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-object
  */
-interface OpenApiParameter extends OpenApiReference$1 {
+interface OpenApiParameter$1 extends OpenApiReference$1 {
     allowEmptyValue?: boolean;
     allowReserved?: boolean;
     content?: Record<MediaType, MediaTypeObject>;
     deprecated?: boolean;
     description?: string;
     example?: unknown;
-    examples?: Dictionary<OpenApiExample>;
+    examples?: Dictionary<OpenApiExample$1>;
     explode?: boolean;
     in: 'cookie' | 'formData' | 'header' | 'path' | 'query';
     name: string;
@@ -4633,7 +5034,7 @@ interface Model extends Schema {
     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'] | '';
+    in: OperationParameter['in'] | OpenApiParameter$1['in'] | OperationResponse['in'] | '';
     link: Model | Model[] | null;
     meta?: ModelMeta;
     /**
@@ -4666,10 +5067,62 @@ interface OpenApiExternalDocs {
     url: string;
 }
 
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#contact-object
+ */
+interface OpenApiContact$1 {
+    email?: string;
+    name?: string;
+    url?: string;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#license-object
+ */
+interface OpenApiLicense$1 {
+    name: string;
+    url?: string;
+}
+
+/**
+ * {@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;
+}
+
 interface WithNullableExtension {
     'x-nullable'?: boolean;
 }
 
+/**
+ * {@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;
+}
+
 /**
  * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#reference-object
  */
@@ -4723,6 +5176,431 @@ interface OpenApiSchema extends OpenApiReference, WithEnumExtension, WithNullabl
     xml?: OpenApiXml;
 }
 
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#parameter-object
+ */
+interface OpenApiParameter extends OpenApiReference, 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;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#example-object
+ */
+interface OpenApiExample {
+    [mimetype: string]: unknown;
+}
+
+/**
+ * {@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;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#response-object
+ */
+interface OpenApiResponse$1 extends OpenApiReference {
+    description: string;
+    examples?: OpenApiExample;
+    headers?: Dictionary<OpenApiHeader$1>;
+    schema?: OpenApiSchema & OpenApiReference;
+}
+
+/**
+ * {@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;
+};
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#security-requirement-object
+ */
+interface OpenApiSecurityRequirement$1 {
+    [key: string]: string;
+}
+
+/**
+ * {@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;
+    operationId?: string;
+    parameters?: OpenApiParameter[];
+    produces?: string[];
+    responses: OpenApiResponses$1;
+    schemes?: ('http' | 'https' | 'ws' | 'wss')[];
+    security?: OpenApiSecurityRequirement$1[];
+    summary?: string;
+    tags?: string[];
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#path-item-object
+ */
+interface OpenApiPath$1 extends OpenApiReference {
+    connect?: OpenApiOperation$1;
+    delete?: OpenApiOperation$1;
+    get?: OpenApiOperation$1;
+    head?: OpenApiOperation$1;
+    options?: OpenApiOperation$1;
+    parameters?: OpenApiParameter[];
+    patch?: OpenApiOperation$1;
+    post?: OpenApiOperation$1;
+    put?: OpenApiOperation$1;
+    trace?: OpenApiOperation$1;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#security-scheme-object
+ */
+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';
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#tag-object
+ */
+interface OpenApiTag$1 {
+    description?: string;
+    externalDocs?: OpenApiExternalDocs;
+    name: string;
+}
+
+/**
+ * {@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;
+    host?: string;
+    info: OpenApiInfo$1;
+    parameters?: Dictionary<OpenApiParameter>;
+    paths: Dictionary<OpenApiPath$1>;
+    produces?: string[];
+    responses?: Dictionary<OpenApiResponse$1>;
+    schemes?: string[];
+    security?: OpenApiSecurityRequirement$1[];
+    securityDefinitions?: Dictionary<OpenApiSecurityScheme$1>;
+    swagger: string;
+    tags?: OpenApiTag$1[];
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#header-object
+ */
+interface OpenApiHeader extends OpenApiReference$1 {
+    allowEmptyValue?: boolean;
+    allowReserved?: boolean;
+    deprecated?: boolean;
+    description?: string;
+    example?: unknown;
+    examples?: Dictionary<OpenApiExample$1>;
+    explode?: boolean;
+    required?: boolean;
+    schema?: OpenApiSchema$1;
+    style?: string;
+}
+
+/**
+ * {@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;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#media-type-object
+ */
+interface OpenApiMediaType extends OpenApiReference$1 {
+    encoding?: Dictionary<OpenApiEncoding>;
+    example?: unknown;
+    examples?: Dictionary<OpenApiExample$1>;
+    schema?: OpenApiSchema$1;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#request-body-object
+ */
+interface OpenApiRequestBody extends OpenApiReference$1 {
+    content: Dictionary<OpenApiMediaType>;
+    description?: string;
+    nullable?: boolean;
+    required?: boolean;
+    'x-body-name'?: string;
+}
+
+/**
+ * {@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)[];
+}
+
+/**
+ * {@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>;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#link-object
+ */
+interface OpenApiLink extends OpenApiReference$1 {
+    description?: string;
+    operationId?: string;
+    operationRef?: string;
+    parameters?: Dictionary<unknown>;
+    requestBody?: unknown;
+    server?: OpenApiServer;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#response-object
+ */
+interface OpenApiResponse extends OpenApiReference$1 {
+    content?: Dictionary<OpenApiMediaType>;
+    description: string;
+    headers?: Dictionary<OpenApiHeader>;
+    links?: Dictionary<OpenApiLink>;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#responses-object
+ */
+interface Response {
+    [httpcode: string]: OpenApiResponse;
+}
+type OpenApiResponses = OpenApiReference$1 & Response & {
+    default: OpenApiResponse;
+};
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#security-requirement-object
+ */
+interface OpenApiSecurityRequirement {
+    [name: string]: string;
+}
+
+/**
+ * {@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$1;
+    operationId?: string;
+    parameters?: OpenApiParameter$1[];
+    requestBody?: OpenApiRequestBody;
+    responses: OpenApiResponses;
+    security?: OpenApiSecurityRequirement[];
+    servers?: OpenApiServer[];
+    summary?: string;
+    tags?: string[];
+}
+
+/**
+ * {@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$1[];
+    patch?: OpenApiOperation;
+    post?: OpenApiOperation;
+    put?: OpenApiOperation;
+    servers?: OpenApiServer[];
+    summary?: string;
+    trace?: OpenApiOperation;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#callback-object
+ */
+interface Callback {
+    [key: string]: OpenApiPath;
+}
+type OpenApiCallback = OpenApiReference$1 & Callback;
+
+/**
+ * {@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;
+}
+
+/**
+ * {@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;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#security-scheme-object
+ */
+interface OpenApiSecurityScheme extends OpenApiReference$1 {
+    bearerFormat?: string;
+    description?: string;
+    flows?: OpenApiOAuthFlows;
+    in?: 'query' | 'header' | 'cookie';
+    name?: string;
+    openIdConnectUrl?: string;
+    scheme?: string;
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#components-object
+ */
+interface OpenApiComponents {
+    callbacks?: Dictionary<OpenApiCallback>;
+    examples?: Dictionary<OpenApiExample$1>;
+    headers?: Dictionary<OpenApiHeader>;
+    links?: Dictionary<OpenApiLink>;
+    parameters?: Dictionary<OpenApiParameter$1>;
+    requestBodies?: Dictionary<OpenApiRequestBody>;
+    responses?: Dictionary<OpenApiResponses>;
+    schemas?: Dictionary<OpenApiSchema$1>;
+    securitySchemes?: Dictionary<OpenApiSecurityScheme>;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#contact-object
+ */
+interface OpenApiContact {
+    email?: string;
+    name?: string;
+    url?: string;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#license-object
+ */
+interface OpenApiLicense {
+    name: string;
+    url?: string;
+}
+
+/**
+ * {@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;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#paths-object
+ */
+interface OpenApiPaths {
+    [path: string]: OpenApiPath;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#tag-object
+ */
+interface OpenApiTag {
+    description?: string;
+    externalDocs?: OpenApiExternalDocs$1;
+    name: string;
+}
+
+/**
+ * {@link} https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md
+ */
+interface OpenApi$1 {
+    components?: OpenApiComponents;
+    externalDocs?: OpenApiExternalDocs$1;
+    info: OpenApiInfo;
+    openapi: string;
+    paths: OpenApiPaths;
+    security?: OpenApiSecurityRequirement[];
+    servers?: OpenApiServer[];
+    tags?: OpenApiTag[];
+}
+
+type OpenApi = OpenApi$2 | OpenApi$1;
+
 interface Operation extends Omit<Operation$1, 'tags'> {
     service: string;
 }
@@ -4740,6 +5618,10 @@ interface Client extends Omit<Client$1, 'operations'> {
  * @param userConfig {@link UserConfig} passed to the `createClient()` method
  */
 declare function createClient(userConfig: UserConfig): Promise<ReadonlyArray<Client>>;
+/**
+ * Default plugins used to generate artifacts if plugins aren't specified.
+ */
+declare const defaultPlugins: readonly ["@hey-api/typescript", "@hey-api/sdk"];
 /**
  * Type helper for openapi-ts.config.ts, returns {@link UserConfig} object
  */
@@ -4749,4 +5631,4 @@ declare const _default: {
     defineConfig: (config: UserConfig) => UserConfig;
 };
 
-export { type OpenApiV3_0_X, type OpenApiV3_1_X, type UserConfig, createClient, _default as default, defineConfig };
+export { type OpenApiV3_0_X, type OpenApiV3_1_X, Plugin, type UserConfig, createClient, _default as default, defaultPlugins, defineConfig };