@hey-api/openapi-ts 0.72.2 → 0.74.0

package/dist/internal.d.cts

@@ -1,6 +1,6 @@
 import { JSONSchema } from '@hey-api/json-schema-ref-parser';
-import { e as Config, I as IR, W as WatchValues } from './types.d-DtkupL5A.cjs';
-export { i as initConfigs } from './types.d-DtkupL5A.cjs';
+import { e as Config, I as IR, W as WatchValues } from './types.d-jQzOw4mx.cjs';
+export { i as initConfigs } from './types.d-jQzOw4mx.cjs';
 import 'node:fs';
 import 'typescript';
 

package/dist/internal.d.ts

@@ -1,6 +1,6 @@
 import { JSONSchema } from '@hey-api/json-schema-ref-parser';
-import { e as Config, I as IR, W as WatchValues } from './types.d-DtkupL5A.js';
-export { i as initConfigs } from './types.d-DtkupL5A.js';
+import { e as Config, I as IR, W as WatchValues } from './types.d-jQzOw4mx.js';
+export { i as initConfigs } from './types.d-jQzOw4mx.js';
 import 'node:fs';
 import 'typescript';
 

package/dist/internal.js

@@ -1,2 +1,2 @@
-import {createRequire}from'module';export{r as getSpec,F as initConfigs,A as parseOpenApiSpec}from'./chunk-LC3ZVK3Y.js';createRequire(import.meta.url);//# sourceMappingURL=internal.js.map
+import {createRequire}from'module';export{r as getSpec,I as initConfigs,B as parseOpenApiSpec}from'./chunk-WELTPW5K.js';createRequire(import.meta.url);//# sourceMappingURL=internal.js.map
 //# sourceMappingURL=internal.js.map

package/dist/{types.d-DtkupL5A.d.cts → types.d-jQzOw4mx.d.cts}

@@ -3295,6 +3295,48 @@ interface OpenApi$2 {
 
 type OpenApi$1 = OpenApi$3 | OpenApi$2;
 
+interface Operation extends Omit<Operation$1, 'tags'> {
+  service: string;
+}
+
+interface Service extends Pick<Model, '$refs' | 'imports' | 'name'> {
+  operations: Operation[];
+}
+
+interface Client$1 extends Omit<Client$2, 'operations'> {
+  services: Service[];
+}
+
+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>>;
+};
+
 interface JsonSchemaDraft4 extends EnumExtensions {
   /**
    * A schema can reference another schema using the `$ref` keyword. The value of `$ref` is a URI-reference that is resolved against the schema's {@link https://json-schema.org/understanding-json-schema/structuring#base-uri Base URI}. When evaluating a `$ref`, an implementation uses the resolved identifier to retrieve the referenced schema and applies that schema to the {@link https://json-schema.org/learn/glossary#instance instance}.
@@ -6397,52 +6439,41 @@ declare namespace OpenApiSchemaObject {
   export type V3_1_X = OpenApiV3_1_XTypes['SchemaObject'];
 }
 
-interface Operation extends Omit<Operation$1, 'tags'> {
-  service: string;
-}
-
-interface Service extends Pick<Model, '$refs' | 'imports' | 'name'> {
-  operations: Operation[];
-}
-
-interface Client$1 extends Omit<Client$2, 'operations'> {
-  services: Service[];
+declare class PluginInstance<PluginConfig extends BaseConfig = BaseConfig> {
+    config: Plugin.Config<PluginConfig>['config'];
+    context: IR.Context;
+    dependencies: Required<Plugin.Config<PluginConfig>>['dependencies'];
+    private handler;
+    name: Plugin.Config<PluginConfig>['name'];
+    output: Required<PluginConfig>['output'];
+    constructor(props: Pick<Required<Plugin.Config<PluginConfig>>, 'config' | 'dependencies' | 'handler'> & Pick<Required<PluginConfig>, 'output'> & {
+        context: IR.Context<OpenApi.V2_0_X | OpenApi.V3_0_X | OpenApi.V3_1_X>;
+        name: string;
+    });
+    createFile(file: IR.ContextFile): TypeScriptFile;
+    /**
+     * 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 Config['plugins']>(name: T): IR.Context['plugins'][T];
+    /**
+     * Executes plugin's handler function.
+     */
+    run(): Promise<void>;
+    /**
+     * Subscribe to an input parser event.
+     *
+     * @param event Event type from the parser.
+     * @param callbackFn Function to execute on event.
+     * @returns void
+     */
+    subscribe<T extends keyof IR.ContextEvents>(event: T, callbackFn: IR.ContextEvents[T]): void;
 }
 
-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 OmitUnderscoreKeys<T> = {
-  [K in keyof T as K extends `_${string}` ? never : K]: T[K];
-};
-
 type PluginClientNames =
   | '@hey-api/client-axios'
   | '@hey-api/client-fetch'
@@ -6474,12 +6505,38 @@ type AnyPluginName = PluginNames | (string & {});
 
 type PluginTag = 'client' | 'transformer' | 'validator';
 
+type ObjectType<T> =
+  Extract<T, Record<string, any>> extends never
+    ? Record<string, any>
+    : Extract<T, Record<string, any>>;
+
 interface PluginContext {
-  ensureDependency: (name: PluginNames | true) => void;
-  pluginByTag: (
+  pluginByTag: <T extends AnyPluginName | boolean = AnyPluginName>(
     tag: PluginTag,
-    errorMessage?: string,
-  ) => AnyPluginName | undefined;
+    props?: {
+      defaultPlugin?: Exclude<T, boolean>;
+      errorMessage?: string;
+    },
+  ) => Exclude<T, boolean> | undefined;
+  valueToObject: <
+    T extends undefined | string | boolean | number | Record<string, any>,
+  >(args: {
+    defaultValue: ObjectType<T>;
+    mappers: {
+      boolean: T extends boolean
+        ? (value: boolean) => Partial<ObjectType<T>>
+        : never;
+      number: T extends number
+        ? (value: number) => Partial<ObjectType<T>>
+        : never;
+      string: T extends string
+        ? (value: string) => Partial<ObjectType<T>>
+        : never;
+    } extends infer U
+      ? { [K in keyof U as U[K] extends never ? never : K]: U[K] }
+      : never;
+    value: T;
+  }) => ObjectType<T>;
 }
 
 interface BaseConfig {
@@ -6492,42 +6549,63 @@ interface BaseConfig {
   output?: string;
 }
 
-interface Meta<Config extends BaseConfig> {
+interface Meta<
+  Config extends BaseConfig,
+  ResolvedConfig extends BaseConfig = Config,
+> {
   /**
    * Dependency plugins will be always processed, regardless of whether user
    * explicitly defines them in their `plugins` config.
    */
-  _dependencies?: ReadonlyArray<AnyPluginName>;
+  dependencies?: ReadonlyArray<AnyPluginName>;
   /**
-   * Allows overriding config before it's sent to the parser. An example is
-   * defining `validator` as `true` and the plugin figures out which plugin
+   * Resolves static configuration values into their runtime equivalents. For
+   * example, when `validator` is set to `true`, it figures out which plugin
    * should be used for validation.
    */
-  _infer?: (
-    config: Config & Omit<Meta<Config>, '_infer'>,
+  resolveConfig?: (
+    plugin: Omit<Plugin.Config<Config, ResolvedConfig>, 'dependencies'> & {
+      dependencies: Set<AnyPluginName>;
+    },
     context: PluginContext,
   ) => void;
   /**
-   * Optional tags can be used to help with deciding plugin order and inferring
+   * Optional tags can be used to help with deciding plugin order and resolving
    * plugin configuration options.
    */
-  _tags?: ReadonlyArray<PluginTag>;
+  tags?: ReadonlyArray<PluginTag>;
 }
 
 /**
  * Public Plugin API.
  */
 declare namespace Plugin {
-  export type Config<Config extends BaseConfig> = Config &
-    Meta<Config> & {
-      _handler: Plugin.Handler<Config>;
-      _handlerLegacy: Plugin.LegacyHandler<Config>;
-      exportFromIndex?: boolean;
+  export type Config<
+    Config extends BaseConfig,
+    ResolvedConfig extends BaseConfig = Config,
+  > = Pick<Config, 'name' | 'output'> &
+    Meta<Config, ResolvedConfig> & {
+      config: Omit<Config, 'name' | 'output'>;
+      handler: Plugin.Handler<
+        Omit<ResolvedConfig, 'name'> & {
+          name: any;
+        }
+      >;
+      handlerLegacy: Plugin.LegacyHandler<
+        Omit<ResolvedConfig, 'name'> & {
+          name: any;
+        }
+      >;
     };
 
-  export type DefineConfig<Config extends BaseConfig> = (
-    config?: Plugin.UserConfig<Omit<Config, 'name'>>,
-  ) => Omit<Plugin.Config<Config>, 'name'> & {
+  /** @deprecated - use `definePluginConfig()` instead */
+  export type DefineConfig<
+    Config extends BaseConfig,
+    ResolvedConfig extends BaseConfig = Config,
+  > = (config?: Plugin.UserConfig<Omit<Config, 'name'>>) => Omit<
+    Plugin.Config<Config, ResolvedConfig>,
+    'name'
+  > & {
     /**
      * Cast name to `any` so it doesn't throw type error in `plugins` array.
      * We could allow any `string` as plugin `name` in the object syntax, but
@@ -6541,12 +6619,10 @@ declare namespace Plugin {
    * Plugin implementation for experimental parser.
    */
   export type Handler<Config extends BaseConfig, ReturnType = void> = (args: {
-    context: IR.Context<OpenApi.V2_0_X | OpenApi.V3_0_X | OpenApi.V3_1_X>;
     plugin: Plugin.Instance<Config>;
   }) => ReturnType;
 
-  export type Instance<Config extends BaseConfig> = OmitUnderscoreKeys<Config> &
-    Pick<Required<BaseConfig>, 'exportFromIndex' | 'output'>;
+  export type Instance<Config extends BaseConfig> = PluginInstance<Config>;
 
   /**
    * Plugin implementation for legacy parser.
@@ -6597,10 +6673,7 @@ interface Config$j
     Client.Config {}
 
 type PluginHandler<ReturnType = void> = Plugin.Handler<
-  Omit<
-    Config$i | Config$l | Config$k | Config$j,
-    'name'
-  >,
+  Config$i | Config$l | Config$k | Config$j,
   ReturnType
 >;
 
@@ -6624,25 +6697,12 @@ declare namespace Client {
      */
     baseUrl?: string | number | boolean;
     /**
-     * Bundle the client module? Set this to true if don't want to declare it
-     * as a separate dependency. When true, the client module will be generated
-     * from the client 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.
+     * Bundle the client module? When `true`, the client module will be copied
+     * from the client plugin and bundled with the generated output.
      *
-     * @default false
+     * @default true
      */
     bundle?: boolean;
-    /**
-     * **This is an experimental feature.**
-     *
-     * When `bundle` is set to `true`, you can optionally set this option
-     * to `true` to bundle the client source code instead of the `dist` folder.
-     * This will copy the TypeScript files instead of CJS/ESM JavaScript files.
-     *
-     * @default false
-     */
-    bundleSource_EXPERIMENTAL?: boolean;
     /**
      * Should the exports from the generated files be re-exported in the index
      * barrel file?
@@ -6795,10 +6855,10 @@ interface Config$b extends Plugin.Name<'@hey-api/sdk'> {
    * Use an internal client instance to send HTTP requests? This is useful if
    * you don't want to manually pass the client to each SDK function.
    *
-   * Ensure you have declared the selected library as a dependency to avoid
-   * errors. You can customize the selected client output through its plugin.
-   * You can also set `client` to `true` to automatically choose the client
-   * from your defined plugins.
+   * You can customize the selected client output through its plugin. You can
+   * also set `client` to `true` to automatically choose the client from your
+   * defined plugins. If we can't detect a client plugin when using `true`, we
+   * will default to `@hey-api/client-fetch`.
    *
    * @default true
    */
@@ -7293,16 +7353,52 @@ interface Config$2 extends Plugin.Name<'valibot'> {
   output?: string;
 }
 
-// import type { IR } from '../../ir/types';
-
-
 interface Config$1 extends Plugin.Name<'zod'> {
+  /**
+   * The casing convention to use for generated names.
+   *
+   * @default 'camelCase'
+   */
+  case?: StringCase;
   /**
    * Add comments from input to the generated Zod schemas?
    *
    * @default true
    */
   comments?: boolean;
+  /**
+   * Configuration for reusable schema definitions. Controls generation of
+   * shared Zod schemas that can be referenced across requests and responses.
+   *
+   * Can be:
+   * - `boolean`: Shorthand for `{ enabled: boolean }`
+   * - `string`: Shorthand for `{ enabled: true; name: string }`
+   * - `object`: Full configuration object
+   */
+  definitions?:
+    | boolean
+    | string
+    | {
+        /**
+         * The casing convention to use for generated names.
+         *
+         * @default 'camelCase'
+         */
+        case?: StringCase;
+        /**
+         * Whether to generate Zod schemas for reusable definitions.
+         *
+         * @default true
+         */
+        enabled?: boolean;
+        /**
+         * Custom naming pattern for generated schema names. The name variable is
+         * obtained from the schema name.
+         *
+         * @default 'z{{name}}'
+         */
+        name?: string | ((name: string) => string);
+      };
   /**
    * Should the exports from the generated files be re-exported in the index
    * barrel file?
@@ -7318,17 +7414,78 @@ interface Config$1 extends Plugin.Name<'zod'> {
    * @default false
    */
   metadata?: boolean;
-  /**
-   * Customise the Zod schema name. By default, `z{{name}}` is used,
-   * where `name` is a definition name or an operation name.
-   */
-  // nameBuilder?: (model: IR.OperationObject | IR.SchemaObject) => string;
   /**
    * Name of the generated file.
    *
    * @default 'zod'
    */
   output?: string;
+  /**
+   * Configuration for request-specific Zod schemas.
+   * Controls generation of Zod schemas for request bodies, query parameters, path parameters, and headers.
+   *
+   * Can be:
+   * - `boolean`: Shorthand for `{ enabled: boolean }`
+   * - `string`: Shorthand for `{ enabled: true; name: string }`
+   * - `object`: Full configuration object
+   */
+  requests?:
+    | boolean
+    | string
+    | {
+        /**
+         * The casing convention to use for generated names.
+         *
+         * @default 'camelCase'
+         */
+        case?: StringCase;
+        /**
+         * Whether to generate Zod schemas for request definitions.
+         *
+         * @default true
+         */
+        enabled?: boolean;
+        /**
+         * Custom naming pattern for generated schema names. The name variable is
+         * obtained from the operation name.
+         *
+         * @default 'z{{name}}Data'
+         */
+        name?: string | ((name: string) => string);
+      };
+  /**
+   * Configuration for response-specific Zod schemas.
+   * Controls generation of Zod schemas for response bodies, error responses, and status codes.
+   *
+   * Can be:
+   * - `boolean`: Shorthand for `{ enabled: boolean }`
+   * - `string`: Shorthand for `{ enabled: true; name: string }`
+   * - `object`: Full configuration object
+   */
+  responses?:
+    | boolean
+    | string
+    | {
+        /**
+         * The casing convention to use for generated names.
+         *
+         * @default 'camelCase'
+         */
+        case?: StringCase;
+        /**
+         * Whether to generate Zod schemas for response definitions.
+         *
+         * @default true
+         */
+        enabled?: boolean;
+        /**
+         * Custom naming pattern for generated schema names. The name variable is
+         * obtained from the operation name.
+         *
+         * @default 'z{{name}}Response'
+         */
+        name?: string | ((name: string) => string);
+      };
 }
 
 /**
@@ -7978,6 +8135,7 @@ declare class TypeScriptFile {
     get exportFromIndex(): boolean;
     get id(): string;
     identifier(args: Pick<EnsureUniqueIdentifierData, '$ref' | 'count' | 'create' | 'nameTransformer'> & {
+        case?: StringCase;
         namespace: Namespace;
     }): Identifier;
     /**
@@ -8012,10 +8170,18 @@ interface EnsureUniqueIdentifierData {
     /**
      * Transforms name obtained from `$ref` before it's passed to `stringCase()`.
      */
-    nameTransformer?: (name: string) => string;
+    nameTransformer?: ((name: string) => string) | string;
     namespace: Namespace;
 }
 
+type ExtractConfig<T> = T extends {
+    config: infer C;
+} ? C & {
+    name: string;
+} : never;
+type PluginInstanceMap = {
+    [K in keyof Config['plugins']]?: PluginInstance<ExtractConfig<Config['plugins'][K]>>;
+};
 interface ContextFile {
     /**
      * Should the exports from this file be re-exported in the index barrel file?
@@ -8031,6 +8197,7 @@ interface ContextFile {
     identifierCase?: StringCase;
     /**
      * Relative file path to the output path.
+     *
      * @example
      * 'bar/foo.ts'
      */
@@ -8083,6 +8250,12 @@ declare class IRContext<Spec extends Record<string, any> = any> {
      * Intermediate representation model obtained from `spec`.
      */
     ir: IR.Model;
+    /**
+     * A map of registered plugin instances, keyed by plugin name. Plugins are
+     * registered through the `registerPlugin` method and can be accessed by
+     * their configured name from the config.
+     */
+    plugins: PluginInstanceMap;
     /**
      * Resolved specification from `input`.
      */
@@ -8114,6 +8287,18 @@ declare class IRContext<Spec extends Record<string, any> = any> {
      * Returns a specific file by ID from `files`.
      */
     file({ id }: Pick<ContextFile, 'id'>): TypeScriptFile | undefined;
+    /**
+     * Registers a new plugin to the global context.
+     *
+     * @param name Plugin name.
+     * @returns Registered plugin instance.
+     */
+    private registerPlugin;
+    /**
+     * Generator that iterates through plugin order and registers each plugin.
+     * Yields the registered plugin instance for each plugin name.
+     */
+    registerPlugins(): Generator<PluginInstance>;
     resolveIrRef<T>($ref: string): T;
     /**
      * Returns a resolved reference from `spec`.
@@ -8122,7 +8307,7 @@ declare class IRContext<Spec extends Record<string, any> = any> {
     /**
      * Register a new `event` listener.
      */
-    subscribe<T extends keyof Events>(event: T, callbackFn: Events[T], pluginName?: string): void;
+    subscribe<T extends keyof Events>(event: T, callbackFn: Events[T], pluginName: string): void;
 }
 
 type IRMediaType = 'form-data' | 'json' | 'text' | 'url-search-params' | 'octet-stream';
@@ -8338,6 +8523,8 @@ declare namespace IR {
   export type BodyObject = IRBodyObject;
   export type ComponentsObject = IRComponentsObject;
   export type Context<Spec extends Record<string, any> = any> = IRContext<Spec>;
+  export type ContextEvents = Events;
+  export type ContextFile = ContextFile;
   export type Model = IRModel;
   export type OperationObject = IROperationObject;
   export type ParameterObject = IRParameterObject;
@@ -8359,7 +8546,10 @@ declare const defaultPlugins: readonly ["@hey-api/typescript", "@hey-api/sdk"];
 /**
  * @internal
  */
-declare const initConfigs: (userConfig: UserConfig | undefined) => Promise<Config[]>;
+declare const initConfigs: (userConfig: UserConfig | undefined) => Promise<ReadonlyArray<{
+    config: Config;
+    errors: ReadonlyArray<Error>;
+}>>;
 
 declare namespace LegacyIR {
   export type LegacyOperation = Operation;
@@ -8383,4 +8573,4 @@ interface WatchValues {
   lastValue?: string;
 }
 
-export { type Client$1 as C, IR as I, LegacyIR as L, OpenApi as O, type PluginHandler as P, type StringCase as S, type UserConfig as U, type WatchValues as W, OpenApiSchemaObject as a, Client as b, Plugin as c, defaultPlugins as d, type Config as e, initConfigs as i };
+export { type BaseConfig as B, type Client$1 as C, IR as I, LegacyIR as L, OpenApi as O, type PluginHandler as P, type StringCase as S, type UserConfig as U, type WatchValues as W, Plugin as a, OpenApiSchemaObject as b, Client as c, defaultPlugins as d, type Config as e, initConfigs as i };