@hey-api/shared 0.1.2 → 0.2.1

package/dist/index.d.mts

@@ -3,8 +3,8 @@ import ts from "typescript";
 import * as semver from "semver";
 import { RangeOptions, SemVer } from "semver";
 import { getResolvedInput } from "@hey-api/json-schema-ref-parser";
+import { IProject, Logger, NameConflictResolver, Node, Project, Ref, RenderContext, StructureLocation, Symbol, SymbolIdentifier, SymbolIn, SymbolMeta } from "@hey-api/codegen-core";
 import { AnyString, MaybeArray, MaybeFunc, MaybePromise } from "@hey-api/types";
-import { IProject, Logger, NameConflictResolver, Node, Project, RenderContext, StructureLocation, Symbol, SymbolIdentifier, SymbolIn, SymbolMeta } from "@hey-api/codegen-core";
 
 //#region src/cli.d.ts
 declare function printCliIntro(initialDir: string, showLogo?: boolean): void;
@@ -2965,6 +2965,40 @@ declare namespace IR {
   type WebhookObject = IRWebhookObject;
 }
 //#endregion
+//#region src/ir/schema-processor.d.ts
+interface SchemaProcessor {
+  /** Current inherited context (set by withContext) */
+  readonly context: {
+    readonly anchor: string | undefined;
+    readonly tags: ReadonlyArray<string> | undefined;
+  };
+  /** Check if pointer was already emitted */
+  hasEmitted: (path: ReadonlyArray<string | number>) => boolean;
+  /** Mark pointer as emitted. Returns false if already emitted. */
+  markEmitted: (path: ReadonlyArray<string | number>) => boolean;
+  /** Execute with inherited context for nested extractions */
+  withContext: <T>(ctx: {
+    anchor?: string;
+    tags?: ReadonlyArray<string>;
+  }, fn: () => T) => T;
+}
+interface SchemaProcessorContext {
+  meta: {
+    resource: string;
+    resourceId: string;
+    role?: string;
+  };
+  namingAnchor?: string;
+  path: ReadonlyArray<string | number>;
+  schema: IR.SchemaObject;
+  tags?: ReadonlyArray<string>;
+}
+interface SchemaProcessorResult<Context$1 extends SchemaProcessorContext = SchemaProcessorContext> {
+  process: (ctx: Context$1) => void;
+}
+type SchemaExtractor<Context$1 extends SchemaProcessorContext = SchemaProcessorContext> = (ctx: Context$1) => IR.SchemaObject;
+declare function createSchemaProcessor(): SchemaProcessor;
+//#endregion
 //#region src/openApi/shared/utils/graph.d.ts
 /**
  * Represents the possible access scopes for OpenAPI nodes.
@@ -3224,14 +3258,17 @@ type WalkEvents = BaseEvent & ({
   path: string;
   type: Extract<IrTopLevelKind, 'operation'>;
 } | {
+  /** Name of the parameter (e.g., "id" for a parameter defined as "#/components/parameters/id"). */
   name: string;
   parameter: IR.ParameterObject;
   type: Extract<IrTopLevelKind, 'parameter'>;
 } | {
+  /** Name of the request body (e.g., "CreateUserRequest" for a request body defined as "#/components/requestBodies/CreateUserRequest"). */
   name: string;
   requestBody: IR.RequestBodyObject;
   type: Extract<IrTopLevelKind, 'requestBody'>;
 } | {
+  /** Name of the schema (e.g., "User" for a schema defined as "#/components/schemas/User"). */
   name: string;
   schema: IR.SchemaObject;
   type: Extract<IrTopLevelKind, 'schema'>;
@@ -3528,6 +3565,28 @@ type Hooks = {
      */
     isQuery?: (operation: IROperationObject) => boolean | undefined;
   };
+  schemas?: {
+    /**
+     * Whether to extract the given schema into a separate symbol.
+     *
+     * This affects how schemas are processed and output.
+     *
+     * **Default behavior:** No schemas are extracted.
+     *
+     * @param ctx - The processing context for the schema.
+     * @returns true to extract the schema, false to keep it inline, or undefined to fallback to default behavior.
+     * @example
+     * ```ts
+     * shouldExtract: (ctx) => {
+     *   if (ctx.meta.resource === 'requestBody') {
+     *     return true;
+     *   }
+     *   return; // fallback to default behavior
+     * }
+     * ```
+     */
+    shouldExtract?: (ctx: SchemaProcessorContext) => boolean;
+  };
   /**
    * Hooks specifically for overriding symbols behavior.
    *
@@ -3647,6 +3706,7 @@ type DefinePlugin<Config extends PluginBaseConfig = PluginBaseConfig, ResolvedCo
   Handler: (args: {
     plugin: PluginInstance<Plugin.Types<Config, ResolvedConfig, Api>>;
   }) => void;
+  /** The plugin instance. */
   Instance: PluginInstance<Plugin.Types<Config, ResolvedConfig, Api>>;
   Types: Plugin.Types<Config, ResolvedConfig, Api>;
 };
@@ -6831,7 +6891,42 @@ declare namespace OpenApiSchemaObject {
 }
 //#endregion
 //#region src/config/parser/patch.d.ts
-type Patch = {
+type PatchInputFn = (spec: OpenApi.V2_0_X | OpenApi.V3_0_X | OpenApi.V3_1_X) => void | Promise<void>;
+type Patch = PatchInputFn | {
+  /**
+   * Patch the raw OpenAPI spec object in place. Called before all other
+   * patch callbacks. Useful for bulk/structural transformations such as
+   * adding new component definitions or modifying many operations at once.
+   *
+   * @param spec The OpenAPI spec object for the current version.
+   *
+   * @example
+   * ```ts
+   * input: (spec) => {
+   *   // Create new component parameters
+   *   if (!spec.components) spec.components = {};
+   *   if (!spec.components.parameters) spec.components.parameters = {};
+   *   spec.components.parameters.MyParam = {
+   *     in: 'query',
+   *     name: 'myParam',
+   *     schema: { type: 'string' }
+   *   };
+   *
+   *   // Inject parameters into operations
+   *   for (const [path, pathItem] of Object.entries(spec.paths ?? {})) {
+   *     if (pathItem?.get) {
+   *       if (!Array.isArray(pathItem.get.parameters)) {
+   *         pathItem.get.parameters = [];
+   *       }
+   *       pathItem.get.parameters.push({
+   *         $ref: '#/components/parameters/MyParam'
+   *       });
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  input?: PatchInputFn;
   /**
    * Patch the OpenAPI meta object in place. Useful for modifying general metadata such as title, description, version, or custom fields before further processing.
    *
@@ -6839,16 +6934,51 @@ type Patch = {
    */
   meta?: (meta: OpenApiMetaObject.V2_0_X | OpenApiMetaObject.V3_0_X | OpenApiMetaObject.V3_1_X) => void;
   /**
-   * Patch OpenAPI operations in place. The key is the operation method and operation path, and the function receives the operation object to modify directly.
+   * Patch OpenAPI operations in place. Each function receives the operation
+   * object to be modified in place. Common use cases include injecting
+   * `operationId` for specs that don't have them, adding `x-*` extensions,
+   * setting `deprecated` based on path patterns, or injecting `security`
+   * requirements globally.
+   *
+   * Can be:
+   * - `Record<string, fn>`: Patch specific operations by `"METHOD /path"` key
+   * - `function`: Bulk callback receives `(method, path, operation)` for every operation
+   *
+   * Both patterns support async functions for operations like fetching data
+   * from external sources or performing I/O.
    *
    * @example
+   * ```js
+   * // Named operations
    * operations: {
    *   'GET /foo': (operation) => {
-   *     operation.responses['200'].description = 'foo';
+   *     operation.responses['200'].description = 'Success';
+   *   },
+   *   'POST /bar': (operation) => {
+   *     operation.deprecated = true;
+   *   }
+   * }
+   *
+   * // Bulk callback for all operations
+   * operations: (method, path, operation) => {
+   *   if (!operation.operationId) {
+   *     operation.operationId = method + buildOperationName(path);
    *   }
    * }
+   *
+   * // Async example - inject operationId based on path patterns
+   * operations: async (method, path, operation) => {
+   *   if (operation.operationId) return;
+   *
+   *   const segments = path.split('/').filter(Boolean);
+   *   const parts = segments
+   *     .map((seg) => seg.startsWith('{') ? 'ById' : seg)
+   *     .join('');
+   *   operation.operationId = method + parts;
+   * }
+   * ```
    */
-  operations?: Record<string, (operation: OpenApiOperationObject.V2_0_X | OpenApiOperationObject.V3_0_X | OpenApiOperationObject.V3_1_X) => void>;
+  operations?: Record<string, (operation: OpenApiOperationObject.V2_0_X | OpenApiOperationObject.V3_0_X | OpenApiOperationObject.V3_1_X) => void | Promise<void>> | ((method: string, path: string, operation: OpenApiOperationObject.V2_0_X | OpenApiOperationObject.V3_0_X | OpenApiOperationObject.V3_1_X) => void | Promise<void>);
   /**
    * Patch OpenAPI parameters in place. The key is the parameter name, and the function receives the parameter object to modify directly.
    *
@@ -6887,8 +7017,16 @@ type Patch = {
    * use cases include fixing incorrect data types, removing unwanted
    * properties, adding missing fields, or standardizing date/time formats.
    *
+   * Can be:
+   * - `Record<string, fn>`: Patch specific named schemas
+   * - `function`: Bulk callback receives `(name, schema)` for every schema
+   *
+   * Both patterns support async functions for operations like fetching data
+   * from external sources or performing I/O.
+   *
    * @example
    * ```js
+   * // Named schemas
    * schemas: {
    *   Foo: (schema) => {
    *     // convert date-time format to timestamp
@@ -6908,9 +7046,26 @@ type Patch = {
    *     delete schema.properties.internalField;
    *   }
    * }
+   *
+   * // Bulk callback for all schemas
+   * schemas: (name, schema) => {
+   *   const match = name.match(/_v(\d+)_(\d+)_(\d+)_/);
+   *   if (match) {
+   *     schema.description = (schema.description || '') +
+   *       `\n@version ${match[1]}.${match[2]}.${match[3]}`;
+   *   }
+   * }
+   *
+   * // Async example - fetch metadata from external source
+   * schemas: async (name, schema) => {
+   *   const metadata = await fetchSchemaMetadata(name);
+   *   if (metadata) {
+   *     schema.description = `${schema.description}\n\n${metadata.notes}`;
+   *   }
+   * }
    * ```
    */
-  schemas?: Record<string, (schema: OpenApiSchemaObject.V2_0_X | OpenApiSchemaObject.V3_0_X | OpenApiSchemaObject.V3_1_X) => void>;
+  schemas?: Record<string, (schema: OpenApiSchemaObject.V2_0_X | OpenApiSchemaObject.V3_0_X | OpenApiSchemaObject.V3_1_X) => void | Promise<void>> | ((name: string, schema: OpenApiSchemaObject.V2_0_X | OpenApiSchemaObject.V3_0_X | OpenApiSchemaObject.V3_1_X) => void | Promise<void>);
   /**
    * Patch the OpenAPI version string. The function receives the current version and should return the new version string.
    * Useful for normalizing or overriding the version value before further processing.
@@ -7086,6 +7241,21 @@ type UserParser = {
         name?: NameTransformer;
       };
     };
+    /**
+     * Sometimes your schema names are auto-generated or follow a naming convention
+     * that produces verbose or awkward type names. You can rename schema component
+     * keys throughout the specification, automatically updating all `$ref` pointers.
+     *
+     * @example
+     * ```ts
+     * {
+     *   schemaName: (name) => name.replace(/_v\d+_\d+_\d+_/, '_')
+     * }
+     * ```
+     *
+     * @default undefined
+     */
+    schemaName?: NameTransformer;
   };
   /**
    * **This is an experimental feature.**
@@ -7189,6 +7359,13 @@ type Parser = {
        */
       responses: NamingOptions;
     };
+    /**
+     * Rename schema component keys and automatically update all `$ref` pointers
+     * throughout the specification.
+     *
+     * @default undefined
+     */
+    schemaName?: NameTransformer;
   };
   /**
    * **This is an experimental feature.**
@@ -7845,6 +8022,105 @@ declare function deduplicateSchema<T extends IR.SchemaObject>({
   schema: T;
 }): T;
 //#endregion
+//#region src/plugins/shared/types/schema.d.ts
+type SchemaWithType<T extends Required<IR.SchemaObject>['type'] = Required<IR.SchemaObject>['type']> = Omit<IR.SchemaObject, 'type'> & {
+  type: Extract<Required<IR.SchemaObject>['type'], T>;
+};
+//#endregion
+//#region src/ir/schema-walker.d.ts
+/**
+ * Context passed to all visitor methods.
+ */
+interface SchemaVisitorContext<TPlugin = unknown> {
+  /** Current path in the schema tree. */
+  path: Ref<ReadonlyArray<string | number>>;
+  /** The plugin instance. */
+  plugin: TPlugin;
+}
+/**
+ * The walk function signature. Fully generic over TResult.
+ */
+type Walker<TResult, TPlugin = unknown> = (schema: IR.SchemaObject, ctx: SchemaVisitorContext<TPlugin>) => TResult;
+/**
+ * The visitor interface. Plugins define their own TResult type.
+ *
+ * The walker handles orchestration (dispatch, deduplication, path tracking).
+ * Result shape and semantics are entirely plugin-defined.
+ */
+interface SchemaVisitor<TResult, TPlugin = unknown> {
+  /**
+   * Apply modifiers to a result.
+   */
+  applyModifiers(result: TResult, ctx: SchemaVisitorContext<TPlugin>, context?: {
+    /** Is this property optional? */
+    optional?: boolean;
+  }): unknown;
+  array(schema: SchemaWithType<'array'>, ctx: SchemaVisitorContext<TPlugin>, walk: Walker<TResult, TPlugin>): TResult;
+  boolean(schema: SchemaWithType<'boolean'>, ctx: SchemaVisitorContext<TPlugin>): TResult;
+  enum(schema: SchemaWithType<'enum'>, ctx: SchemaVisitorContext<TPlugin>, walk: Walker<TResult, TPlugin>): TResult;
+  integer(schema: SchemaWithType<'integer'>, ctx: SchemaVisitorContext<TPlugin>): TResult;
+  /**
+   * Called before any dispatch logic. Return a result to short-circuit,
+   * or undefined to continue normal dispatch.
+   */
+  intercept?(schema: IR.SchemaObject, ctx: SchemaVisitorContext<TPlugin>, walk: Walker<TResult, TPlugin>): TResult | undefined;
+  /**
+   * Handle intersection types. Receives already-walked child results.
+   */
+  intersection(items: Array<TResult>, schemas: ReadonlyArray<IR.SchemaObject>, parentSchema: IR.SchemaObject, ctx: SchemaVisitorContext<TPlugin>): TResult;
+  never(schema: SchemaWithType<'never'>, ctx: SchemaVisitorContext<TPlugin>): TResult;
+  null(schema: SchemaWithType<'null'>, ctx: SchemaVisitorContext<TPlugin>): TResult;
+  number(schema: SchemaWithType<'number'>, ctx: SchemaVisitorContext<TPlugin>): TResult;
+  object(schema: SchemaWithType<'object'>, ctx: SchemaVisitorContext<TPlugin>, walk: Walker<TResult, TPlugin>): TResult;
+  /**
+   * Called after each typed schema visitor returns.
+   */
+  postProcess?(result: TResult, schema: IR.SchemaObject, ctx: SchemaVisitorContext<TPlugin>): TResult;
+  /**
+   * Handle $ref to another schema.
+   */
+  reference($ref: string, schema: IR.SchemaObject, ctx: SchemaVisitorContext<TPlugin>): TResult;
+  string(schema: SchemaWithType<'string'>, ctx: SchemaVisitorContext<TPlugin>): TResult;
+  tuple(schema: SchemaWithType<'tuple'>, ctx: SchemaVisitorContext<TPlugin>, walk: Walker<TResult, TPlugin>): TResult;
+  undefined(schema: SchemaWithType<'undefined'>, ctx: SchemaVisitorContext<TPlugin>): TResult;
+  /**
+   * Handle union types. Receives already-walked child results.
+   */
+  union(items: Array<TResult>, schemas: ReadonlyArray<IR.SchemaObject>, parentSchema: IR.SchemaObject, ctx: SchemaVisitorContext<TPlugin>): TResult;
+  unknown(schema: SchemaWithType<'unknown'>, ctx: SchemaVisitorContext<TPlugin>): TResult;
+  void(schema: SchemaWithType<'void'>, ctx: SchemaVisitorContext<TPlugin>): TResult;
+}
+/**
+ * Create a schema walker from a visitor.
+ *
+ * The walker handles:
+ * - Dispatch order ($ref → type → items → fallback)
+ * - Deduplication of union/intersection schemas
+ * - Path tracking for child schemas
+ */
+declare function createSchemaWalker<TResult, TPlugin = unknown>(visitor: SchemaVisitor<TResult, TPlugin>): Walker<TResult, TPlugin>;
+/**
+ * Helper to create a child context with an extended path.
+ */
+declare function childContext<TPlugin>(ctx: SchemaVisitorContext<TPlugin>, ...segments: ReadonlyArray<string | number>): SchemaVisitorContext<TPlugin>;
+//#endregion
+//#region src/ir/utils.d.ts
+/**
+ * Simply adds `items` to the schema. Also handles setting the logical operator
+ * and avoids setting it for a single item or tuples.
+ */
+declare function addItemsToSchema({
+  items,
+  logicalOperator,
+  mutateSchemaOneItem,
+  schema
+}: {
+  items: Array<IR.SchemaObject>;
+  logicalOperator?: IR.SchemaObject['logicalOperator'];
+  mutateSchemaOneItem?: boolean;
+  schema: IR.SchemaObject;
+}): IR.SchemaObject;
+//#endregion
 //#region src/openApi/index.d.ts
 /**
  * @internal
@@ -8009,12 +8285,7 @@ declare function patchOpenApiSpec({
 }: {
   patchOptions: Patch | undefined;
   spec: unknown;
-}): void;
-//#endregion
-//#region src/plugins/shared/types/schema.d.ts
-type SchemaWithType<T extends Required<IR.SchemaObject>['type'] = Required<IR.SchemaObject>['type']> = Omit<IR.SchemaObject, 'type'> & {
-  type: Extract<Required<IR.SchemaObject>['type'], T>;
-};
+}): Promise<void>;
 //#endregion
 //#region src/plugins/shared/utils/config.d.ts
 declare const definePluginConfig: <T extends Plugin.Types>(defaultConfig: Plugin.Config<T>) => (userConfig?: Omit<T["config"], "name">) => Omit<Plugin.Config<T>, "name"> & {
@@ -8131,6 +8402,32 @@ declare class MinHeap {
   private sinkDown;
 }
 //#endregion
+//#region src/utils/path.d.ts
+interface PathToNameOptions {
+  /**
+   * When provided, replaces the root semantic segments with this anchor.
+   * Structural suffixes are still derived from path.
+   */
+  anchor?: string;
+}
+/**
+ * Derives a composite name from a path.
+ *
+ * Examples:
+ *   .../User                                    → 'User'
+ *   .../User/properties/address                 → 'UserAddress'
+ *   .../User/properties/properties              → 'UserProperties'
+ *   .../User/properties/address/properties/city → 'UserAddressCity'
+ *   .../Pet/additionalProperties                → 'PetValue'
+ *   .../Order/properties/items/items/0          → 'OrderItems'
+ *   paths//event/get/properties/query           → 'EventGetQuery'
+ *
+ * With anchor:
+ *   paths//event/get/properties/query, { anchor: 'event.subscribe' }
+ *                                               → 'event.subscribe-Query'
+ */
+declare function pathToName(path: ReadonlyArray<string | number>, options?: PathToNameOptions): string;
+//#endregion
 //#region src/utils/ref.d.ts
 /**
  * Returns the reusable component name from `$ref`.
@@ -8181,7 +8478,7 @@ declare function normalizeJsonPointer(pointer: string): string;
  */
 declare function pathToJsonPointer(path: ReadonlyArray<string | number>): string;
 /**
- * Checks if a $ref points to a top-level component (not a deep path reference).
+ * Checks if a $ref or path points to a top-level component (not a deep path reference).
  *
  * Top-level component references:
  * - OpenAPI 3.x: #/components/{type}/{name} (3 segments)
@@ -8190,10 +8487,10 @@ declare function pathToJsonPointer(path: ReadonlyArray<string | number>): string
  * Deep path references (4+ segments for 3.x, 3+ for 2.0) should be inlined
  * because they don't have corresponding registered symbols.
  *
- * @param $ref - The $ref string to check
+ * @param refOrPath - The $ref string or path array to check
  * @returns true if the ref points to a top-level component, false otherwise
  */
-declare function isTopLevelComponentRef($ref: string): boolean;
+declare function isTopLevelComponent(refOrPath: string | ReadonlyArray<string | number>): boolean;
 declare function resolveRef<T>({
   $ref,
   spec
@@ -8211,5 +8508,5 @@ interface Url {
 }
 declare function parseUrl(value: string): Url;
 //#endregion
-export { type AnyConfig, type AnyPluginName, type BaseConfig, type BaseOutput, type BaseUserConfig, type BaseUserOutput, type Casing, type CodeSampleObject, type CommentsOption, ConfigError, ConfigValidationError, Context, type DefinePlugin, type Dependency, type EnumExtensions, type FeatureToggle, type Filters, HeyApiError, type Hooks, type IR, type IndexExportOption, type Input, IntentContext, JobError, type LinguistLanguages, type Logs, MinHeap, type NameTransformer, type NamingConfig, type NamingOptions, type NamingRule, type OpenApi, type OpenApiMetaObject, type OpenApiOperationObject, type OpenApiParameterObject, type OpenApiRequestBodyObject, type OpenApiResponseObject, type OpenApiSchemaObject, type OpenApiV2_0_X, type OpenApiV2_0_XTypes, type OpenApiV3_0_X, type OpenApiV3_0_XTypes, type OpenApiV3_1_X, type OpenApiV3_1_XTypes, OperationPath, type OperationPathStrategy, OperationStrategy, type OperationStructureStrategy, type OperationsStrategy, type OutputHeader, type Parser, type Patch, type Plugin, type PluginConfigMap, type PluginContext, PluginInstance, type PluginInstanceTypes, type PluginNames, type PostProcessor, type SchemaWithType, type SourceConfig, type UserCommentsOption, type UserIndexExportOption, type UserInput, type UserParser, type UserPostProcessor, type UserSourceConfig, type UserWatch, type ValueToObject, type Watch, type WatchValues, applyNaming, buildGraph, checkNodeVersion, compileInputPath, createOperationKey, debugTools, deduplicateSchema, defaultPaginationKeywords, definePluginConfig, dependencyFactory, encodeJsonPointerSegment, ensureDirSync, escapeComment, findPackageJson, findTsConfigPath, getInput, getLogs, getParser, getSpec, hasOperationDataRequired, hasParameterGroupObjectRequired, hasParametersObjectRequired, heyApiRegistryBaseUrl, inputToApiRegistry, isTopLevelComponentRef, jsonPointerToPath, loadPackageJson, loadTsConfig, logCrashReport, logInputPaths, mappers, normalizeJsonPointer, openGitHubIssueWithCrashReport, operationPagination, operationResponsesMap, parameterWithPagination, parseOpenApiSpec, parseUrl, parseV2_0_X, parseV3_0_X, parseV3_1_X, patchOpenApiSpec, pathToJsonPointer, postprocessOutput, printCliIntro, printCrashReport, refToName, resolveNaming, resolveRef, resolveSource, satisfies, shouldReportCrash, statusCodeToGroup, toCase, utils, valueToObject };
+export { type AnyConfig, type AnyPluginName, type BaseConfig, type BaseOutput, type BaseUserConfig, type BaseUserOutput, type Casing, type CodeSampleObject, type CommentsOption, ConfigError, ConfigValidationError, Context, type DefinePlugin, type Dependency, type EnumExtensions, type FeatureToggle, type Filters, HeyApiError, type Hooks, type IR, type IndexExportOption, type Input, IntentContext, JobError, type LinguistLanguages, type Logs, MinHeap, type NameTransformer, type NamingConfig, type NamingOptions, type NamingRule, type OpenApi, type OpenApiMetaObject, type OpenApiOperationObject, type OpenApiParameterObject, type OpenApiRequestBodyObject, type OpenApiResponseObject, type OpenApiSchemaObject, type OpenApiV2_0_X, type OpenApiV2_0_XTypes, type OpenApiV3_0_X, type OpenApiV3_0_XTypes, type OpenApiV3_1_X, type OpenApiV3_1_XTypes, OperationPath, type OperationPathStrategy, OperationStrategy, type OperationStructureStrategy, type OperationsStrategy, type OutputHeader, type Parser, type Patch, type Plugin, type PluginConfigMap, type PluginContext, PluginInstance, type PluginInstanceTypes, type PluginNames, type PostProcessor, type SchemaExtractor, type SchemaProcessor, type SchemaProcessorContext, type SchemaProcessorResult, type SchemaVisitor, type SchemaVisitorContext, type SchemaWithType, type SourceConfig, type UserCommentsOption, type UserIndexExportOption, type UserInput, type UserParser, type UserPostProcessor, type UserSourceConfig, type UserWatch, type ValueToObject, type Walker, type Watch, type WatchValues, addItemsToSchema, applyNaming, buildGraph, checkNodeVersion, childContext, compileInputPath, createOperationKey, createSchemaProcessor, createSchemaWalker, debugTools, deduplicateSchema, defaultPaginationKeywords, definePluginConfig, dependencyFactory, encodeJsonPointerSegment, ensureDirSync, escapeComment, findPackageJson, findTsConfigPath, getInput, getLogs, getParser, getSpec, hasOperationDataRequired, hasParameterGroupObjectRequired, hasParametersObjectRequired, heyApiRegistryBaseUrl, inputToApiRegistry, isTopLevelComponent, jsonPointerToPath, loadPackageJson, loadTsConfig, logCrashReport, logInputPaths, mappers, normalizeJsonPointer, openGitHubIssueWithCrashReport, operationPagination, operationResponsesMap, parameterWithPagination, parseOpenApiSpec, parseUrl, parseV2_0_X, parseV3_0_X, parseV3_1_X, patchOpenApiSpec, pathToJsonPointer, pathToName, postprocessOutput, printCliIntro, printCrashReport, refToName, resolveNaming, resolveRef, resolveSource, satisfies, shouldReportCrash, statusCodeToGroup, toCase, utils, valueToObject };
 //# sourceMappingURL=index.d.mts.map