@kubb/plugin-oas 4.3.1 → 4.4.0

package/dist/{OperationGenerator-XkW6FZJh.d.cts → OperationGenerator-CJTAer7l.d.cts}

@@ -5,11 +5,10 @@ import { Operation, Operation as Operation$1 } from "oas/operation";
 import { OpenAPIV3, OpenAPIV3 as OpenAPIV3$1, OpenAPIV3_1 } from "openapi-types";
 import * as oas_normalize_lib_types0 from "oas-normalize/lib/types";
 import BaseOas from "oas";
+import { KubbNode } from "@kubb/react-fabric/types";
+import { Fabric, FileManager } from "@kubb/react-fabric";
 import { ConsolaInstance, LogLevel } from "consola";
-import { FileManager } from "@kubb/fabric-core";
 
-//#region rolldown:runtime
-//#endregion
 //#region ../oas/src/types.d.ts
 type contentType = 'application/json' | (string & {});
 type SchemaObject$1 = OasTypes.SchemaObject & {
@@ -44,19 +43,18 @@ declare class Oas<const TOAS = unknown> extends BaseOas {
   getParametersSchema(operation: Operation, inKey: 'path' | 'query' | 'header'): SchemaObject | null;
   valdiate(): Promise<oas_normalize_lib_types0.ValidationResult>;
 }
-import * as import___kubb_react_fabric_types from "@kubb/react-fabric/types";
 //#endregion
 //#region ../core/src/BaseGenerator.d.ts
 /**
  * Abstract class that contains the building blocks for plugins to create their own Generator
  * @link idea based on https://github.com/colinhacks/zod/blob/master/src/types.ts#L137
  */
-declare abstract class BaseGenerator<TOptions$1 = unknown, TContext = unknown> {
+declare abstract class BaseGenerator<TOptions = unknown, TContext = unknown> {
   #private;
-  constructor(options?: TOptions$1, context?: TContext);
-  get options(): TOptions$1;
+  constructor(options?: TOptions, context?: TContext);
+  get options(): TOptions;
   get context(): TContext;
-  set options(options: TOptions$1);
+  set options(options: TOptions);
   abstract build(...params: unknown[]): unknown;
 }
 //#endregion
@@ -109,7 +107,7 @@ type Logger = {
 };
 //#endregion
 //#region ../core/src/utils/types.d.ts
-type PossiblePromise<T$1> = Promise<T$1> | T$1;
+type PossiblePromise<T> = Promise<T> | T;
 //#endregion
 //#region ../core/src/types.d.ts
 type InputPath = {
@@ -222,11 +220,11 @@ TName extends string = string,
 /**
  * Options of the plugin.
  */
-TOptions$1 extends object = object,
+TOptions extends object = object,
 /**
  * Options of the plugin that can be used later on, see `options` inside your plugin config.
  */
-TResolvedOptions extends object = TOptions$1,
+TResolvedOptions extends object = TOptions,
 /**
  * Context that you want to expose to other plugins.
  */
@@ -240,23 +238,23 @@ TResolvePathOptions extends object = object> = {
    * Same behaviour like what has been done with `QueryKey` in `@tanstack/react-query`
    */
   key: PluginKey<TName | string>;
-  options: TOptions$1;
+  options: TOptions;
   resolvedOptions: TResolvedOptions;
   context: TContext;
   resolvePathOptions: TResolvePathOptions;
 };
 type PluginKey<TName> = [name: TName, identifier?: string | number];
-type UserPlugin<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = {
+type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Unique name used for the plugin
    * The name of the plugin follows the format scope:foo-bar or foo-bar, adding scope: can avoid naming conflicts with other plugins.
    * @example @kubb/typescript
    */
-  name: TOptions$1['name'];
+  name: TOptions['name'];
   /**
    * Options set for a specific plugin(see kubb.config.js), passthrough of options.
    */
-  options: TOptions$1['resolvedOptions'];
+  options: TOptions['resolvedOptions'];
   /**
    * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
    * Can be used to validate dependent plugins.
@@ -266,23 +264,23 @@ type UserPlugin<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions>
    * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin will be executed before these plugins.
    */
   post?: Array<string>;
-} & (TOptions$1['context'] extends never ? {
+} & (TOptions['context'] extends never ? {
   context?: never;
 } : {
-  context: (this: TOptions$1['name'] extends 'core' ? null : Omit<PluginContext<TOptions$1>, 'addFile'>) => TOptions$1['context'];
+  context: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext<TOptions>, 'addFile'>) => TOptions['context'];
 });
-type UserPluginWithLifeCycle<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions$1> & PluginLifecycle<TOptions$1>;
-type Plugin<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = {
+type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>;
+type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Unique name used for the plugin
    * @example @kubb/typescript
    */
-  name: TOptions$1['name'];
+  name: TOptions['name'];
   /**
    * Internal key used when a developer uses more than one of the same plugin
    * @private
    */
-  key: TOptions$1['key'];
+  key: TOptions['key'];
   /**
    * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
    * Can be used to validate dependent plugins.
@@ -295,49 +293,49 @@ type Plugin<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Options set for a specific plugin(see kubb.config.js), passthrough of options.
    */
-  options: TOptions$1['resolvedOptions'];
-} & (TOptions$1['context'] extends never ? {
+  options: TOptions['resolvedOptions'];
+} & (TOptions['context'] extends never ? {
   context?: never;
 } : {
-  context: TOptions$1['context'];
+  context: TOptions['context'];
 });
-type PluginWithLifeCycle<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = Plugin<TOptions$1> & PluginLifecycle<TOptions$1>;
-type PluginLifecycle<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = {
+type PluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = Plugin<TOptions> & PluginLifecycle<TOptions>;
+type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Start of the lifecycle of a plugin.
    * @type hookParallel
    */
-  buildStart?: (this: PluginContext<TOptions$1>, Config: Config) => PossiblePromise<void>;
+  buildStart?: (this: PluginContext<TOptions>, Config: Config) => PossiblePromise<void>;
   /**
    * Resolve to a Path based on a baseName(example: `./Pet.ts`) and directory(example: `./models`).
    * Options can als be included.
    * @type hookFirst
    * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
    */
-  resolvePath?: (this: PluginContext<TOptions$1>, baseName: BaseName, mode?: Mode, options?: TOptions$1['resolvePathOptions']) => OptionalPath;
+  resolvePath?: (this: PluginContext<TOptions>, baseName: BaseName, mode?: Mode, options?: TOptions['resolvePathOptions']) => OptionalPath;
   /**
    * Resolve to a name based on a string.
    * Useful when converting to PascalCase or camelCase.
    * @type hookFirst
    * @example ('pet') => 'Pet'
    */
-  resolveName?: (this: PluginContext<TOptions$1>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+  resolveName?: (this: PluginContext<TOptions>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
   /**
    * End of the plugin lifecycle.
    * @type hookParallel
    */
-  buildEnd?: (this: PluginContext<TOptions$1>) => PossiblePromise<void>;
+  buildEnd?: (this: PluginContext<TOptions>) => PossiblePromise<void>;
 };
 type PluginLifecycleHooks = keyof PluginLifecycle;
-type PluginParameter<H$1 extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H$1]>;
-type ResolvePathParams<TOptions$1 = object> = {
+type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H]>;
+type ResolvePathParams<TOptions = object> = {
   pluginKey?: Plugin['key'];
   baseName: BaseName;
   mode?: Mode;
   /**
    * Options to be passed to 'resolvePath' 3th parameter
    */
-  options?: TOptions$1;
+  options?: TOptions;
 };
 type ResolveNameParams = {
   name: string;
@@ -350,7 +348,8 @@ type ResolveNameParams = {
    */
   type?: 'file' | 'function' | 'type' | 'const';
 };
-type PluginContext<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = {
+type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+  fabric: Fabric;
   config: Config;
   /**
    * @deprecated
@@ -358,7 +357,7 @@ type PluginContext<TOptions$1 extends PluginFactoryOptions = PluginFactoryOption
   fileManager: FileManager;
   pluginManager: PluginManager;
   addFile: (...file: Array<File>) => Promise<Array<ResolvedFile>>;
-  resolvePath: (params: ResolvePathParams<TOptions$1['resolvePathOptions']>) => OptionalPath;
+  resolvePath: (params: ResolvePathParams<TOptions['resolvePathOptions']>) => OptionalPath;
   resolveName: (params: ResolveNameParams) => string;
   logger: Logger;
   /**
@@ -368,12 +367,12 @@ type PluginContext<TOptions$1 extends PluginFactoryOptions = PluginFactoryOption
   /**
    * Current plugin
    */
-  plugin: Plugin<TOptions$1>;
+  plugin: Plugin<TOptions>;
 };
 /**
  * Specify the export location for the files and define the behavior of the output
  */
-type Output<TOptions$1> = {
+type Output<TOptions> = {
   /**
    * Path to the output folder or file that will contain the generated code
    */
@@ -386,11 +385,11 @@ type Output<TOptions$1> = {
   /**
    * Add a banner text in the beginning of every file
    */
-  banner?: string | ((options: TOptions$1) => string);
+  banner?: string | ((options: TOptions) => string);
   /**
    * Add a footer text in the beginning of every file
    */
-  footer?: string | ((options: TOptions$1) => string);
+  footer?: string | ((options: TOptions) => string);
 };
 type GroupContext = {
   group: string;
@@ -409,20 +408,21 @@ type Group = {
 //#region ../core/src/PluginManager.d.ts
 type RequiredPluginLifecycle = Required<PluginLifecycle>;
 type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookSeq';
-type Executer<H$1 extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
   message: string;
   strategy: Strategy;
-  hookName: H$1;
+  hookName: H;
   plugin: Plugin;
   parameters?: unknown[] | undefined;
   output?: unknown;
 };
-type ParseResult<H$1 extends PluginLifecycleHooks> = RequiredPluginLifecycle[H$1];
-type SafeParseResult<H$1 extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H$1>>> = {
+type ParseResult<H extends PluginLifecycleHooks> = RequiredPluginLifecycle[H];
+type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
   result: Result;
   plugin: Plugin;
 };
 type Options$2 = {
+  fabric: Fabric;
   logger: Logger;
   /**
    * @default Number.POSITIVE_INFINITY
@@ -434,20 +434,16 @@ type Events = {
   executed: [executer: Executer];
   error: [error: Error];
 };
-type GetFileProps<TOptions$1 = object> = {
+type GetFileProps<TOptions = object> = {
   name: string;
   mode?: Mode;
   extname: Extname;
   pluginKey: Plugin['key'];
-  options?: TOptions$1;
+  options?: TOptions;
 };
 declare class PluginManager {
   #private;
   readonly plugins: Set<Plugin<PluginFactoryOptions<string, object, object, any, object>>>;
-  /**
-   * @deprecated do not use from pluginManager
-   */
-  readonly fileManager: FileManager;
   readonly events: EventEmitter<Events>;
   readonly config: Config;
   readonly executed: Array<Executer>;
@@ -560,6 +556,45 @@ type FileMetaBase = {
   pluginKey?: Plugin['key'];
 };
 //#endregion
+//#region src/generators/createGenerator.d.ts
+type UserGenerator$1<TOptions extends PluginFactoryOptions> = {
+  name: string;
+  operations?: (props: OperationsProps<TOptions>) => Promise<File[]>;
+  operation?: (props: OperationProps<TOptions>) => Promise<File[]>;
+  schema?: (props: SchemaProps<TOptions>) => Promise<File[]>;
+};
+type CoreGenerator<TOptions extends PluginFactoryOptions> = {
+  name: string;
+  type: 'core';
+  operations: (props: OperationsProps<TOptions>) => Promise<File[]>;
+  operation: (props: OperationProps<TOptions>) => Promise<File[]>;
+  schema: (props: SchemaProps<TOptions>) => Promise<File[]>;
+};
+declare function createGenerator<TOptions extends PluginFactoryOptions>(generator: UserGenerator$1<TOptions>): CoreGenerator<TOptions>;
+//#endregion
+//#region src/generators/createReactGenerator.d.ts
+type UserGenerator<TOptions extends PluginFactoryOptions> = {
+  name: string;
+  Operations?: (props: OperationsProps<TOptions>) => KubbNode;
+  Operation?: (props: OperationProps<TOptions>) => KubbNode;
+  Schema?: (props: SchemaProps<TOptions>) => KubbNode;
+};
+type ReactGenerator<TOptions extends PluginFactoryOptions> = {
+  name: string;
+  type: 'react';
+  Operations: (props: OperationsProps<TOptions>) => KubbNode;
+  Operation: (props: OperationProps<TOptions>) => KubbNode;
+  Schema: (props: SchemaProps<TOptions>) => KubbNode;
+};
+/****
+ * Creates a generator that uses React component functions to generate files for OpenAPI operations and schemas.
+ *
+ * The returned generator exposes async methods for generating files from operations, a single operation, or a schema, using the corresponding React components if provided. If a component is not defined, the method returns an empty array.
+ *
+ * @returns A generator object with async methods for operations, operation, and schema file generation.
+ */
+declare function createReactGenerator<TOptions extends PluginFactoryOptions>(generator: UserGenerator<TOptions>): ReactGenerator<TOptions>;
+//#endregion
 //#region src/types.d.ts
 type ResolvePathOptions = {
   pluginKey?: Plugin['key'];
@@ -704,18 +739,22 @@ type ByContentType = {
 };
 type Exclude$1 = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
 type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
-type Override<TOptions$1> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName | ByContentType) & {
-  options: Partial<TOptions$1>;
+type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName | ByContentType) & {
+  options: Partial<TOptions>;
 };
 type ResolvedOptions = Options$1 & {
   output: Output<Oas>;
 };
 type PluginOas = PluginFactoryOptions<'plugin-oas', Options$1, ResolvedOptions, API, ResolvePathOptions>;
 //#endregion
+//#region src/generators/jsonGenerator.d.ts
+declare const jsonGenerator: CoreGenerator<PluginOas>;
+//#endregion
 //#region src/SchemaGenerator.d.ts
-type GetSchemaGeneratorOptions<T$1 extends SchemaGenerator<any, any, any>> = T$1 extends SchemaGenerator<infer Options, any, any> ? Options : never;
+type GetSchemaGeneratorOptions<T extends SchemaGenerator<any, any, any>> = T extends SchemaGenerator<infer Options, any, any> ? Options : never;
 type SchemaMethodResult<TFileMeta extends FileMetaBase> = Promise<File<TFileMeta> | Array<File<TFileMeta>> | null>;
-type Context$1<TOptions$1, TPluginOptions extends PluginFactoryOptions> = {
+type Context$1<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+  fabric: Fabric;
   oas: Oas;
   pluginManager: PluginManager;
   /**
@@ -724,7 +763,7 @@ type Context$1<TOptions$1, TPluginOptions extends PluginFactoryOptions> = {
   plugin: Plugin<TPluginOptions>;
   mode: Mode;
   include?: Array<'schemas' | 'responses' | 'requestBodies'>;
-  override: Array<Override<TOptions$1>> | undefined;
+  override: Array<Override<TOptions>> | undefined;
   contentType?: contentType;
   output?: string;
 };
@@ -756,7 +795,7 @@ type SchemaProps$1 = {
   name?: string;
   parentName?: string;
 };
-declare class SchemaGenerator<TOptions$1 extends SchemaGeneratorOptions = SchemaGeneratorOptions, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TOptions$1, Context$1<TOptions$1, TPluginOptions>> {
+declare class SchemaGenerator<TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TOptions, Context$1<TOptions, TPluginOptions>> {
   #private;
   refs: Refs;
   /**
@@ -774,56 +813,89 @@ declare class SchemaGenerator<TOptions$1 extends SchemaGeneratorOptions = Schema
   build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<File<TFileMeta>>>;
 }
 //#endregion
-//#region src/generator.d.ts
-type OperationsProps<TOptions$1 extends PluginFactoryOptions> = {
-  instance: Omit<OperationGenerator<TOptions$1>, 'build'>;
-  options: TOptions$1['resolvedOptions'];
+//#region src/generators/utils.d.ts
+type BuildOperationsOptions<TOptions extends PluginFactoryOptions> = {
+  fabric: Fabric;
+  generator: ReactGenerator<any>;
+  /**
+   * @deprecated
+   */
+  instance: Omit<OperationGenerator<TOptions>, 'build'>;
+  options: TOptions['resolvedOptions'];
+};
+declare function buildOperations<TOptions extends PluginFactoryOptions>(operations: Array<Operation$1>, {
+  fabric,
+  options,
+  instance,
+  generator
+}: BuildOperationsOptions<TOptions>): Promise<void>;
+type BuildOperationOptions<TOptions extends PluginFactoryOptions> = BuildOperationsOptions<TOptions>;
+declare function buildOperation<TOptions extends PluginFactoryOptions>(operation: Operation$1, {
+  fabric,
+  options,
+  instance,
+  generator
+}: BuildOperationOptions<TOptions>): Promise<void>;
+type BuildSchemaOptions<TOptions extends PluginFactoryOptions> = {
+  fabric: Fabric;
+  generator: ReactGenerator<any>;
+  /**
+   * @deprecated
+   */
+  instance: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>;
+  options: TOptions['resolvedOptions'];
+};
+declare function buildSchema<TOptions extends PluginFactoryOptions>(schema: {
+  name: string;
+  tree: Array<Schema>;
+  value: SchemaObject$1;
+}, {
+  fabric,
+  options,
+  instance,
+  generator
+}: BuildSchemaOptions<TOptions>): Promise<void>;
+//#endregion
+//#region src/plugin.d.ts
+declare const pluginOasName = "plugin-oas";
+declare const pluginOas: (options?: Options$1 | undefined) => UserPluginWithLifeCycle<PluginOas>;
+//#endregion
+//#region src/generators/types.d.ts
+type OperationsProps<TOptions extends PluginFactoryOptions> = {
+  /**
+   * @deprecated
+   */
+  instance: Omit<OperationGenerator<TOptions>, 'build'>;
+  options: TOptions['resolvedOptions'];
   operations: Array<Operation$1>;
 };
-type OperationProps<TOptions$1 extends PluginFactoryOptions> = {
-  instance: Omit<OperationGenerator<TOptions$1>, 'build'>;
-  options: TOptions$1['resolvedOptions'];
+type OperationProps<TOptions extends PluginFactoryOptions> = {
+  /**
+   * @deprecated
+   */
+  instance: Omit<OperationGenerator<TOptions>, 'build'>;
+  options: TOptions['resolvedOptions'];
   operation: Operation$1;
 };
-type SchemaProps<TOptions$1 extends PluginFactoryOptions> = {
-  instance: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions$1>, 'build'>;
-  options: TOptions$1['resolvedOptions'];
+type SchemaProps<TOptions extends PluginFactoryOptions> = {
+  instance: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>;
+  options: TOptions['resolvedOptions'];
   schema: {
     name: string;
     tree: Array<Schema>;
     value: SchemaObject$1;
   };
 };
-type GeneratorOptions<TOptions$1 extends PluginFactoryOptions> = {
-  name: string;
-  operations?: (this: GeneratorOptions<TOptions$1>, props: OperationsProps<TOptions$1>) => Promise<File[]>;
-  operation?: (this: GeneratorOptions<TOptions$1>, props: OperationProps<TOptions$1>) => Promise<File[]>;
-  schema?: (this: GeneratorOptions<TOptions$1>, props: SchemaProps<TOptions$1>) => Promise<File[]>;
-};
-type Generator<TOptions$1 extends PluginFactoryOptions> = GeneratorOptions<TOptions$1>;
-declare function createGenerator<TOptions$1 extends PluginFactoryOptions>(parseOptions: GeneratorOptions<TOptions$1>): Generator<TOptions$1>;
-type ReactGeneratorOptions<TOptions$1 extends PluginFactoryOptions> = {
-  name: string;
-  Operations?: (this: ReactGeneratorOptions<TOptions$1>, props: OperationsProps<TOptions$1>) => types_d_exports$1.KubbNode;
-  Operation?: (this: ReactGeneratorOptions<TOptions$1>, props: OperationProps<TOptions$1>) => types_d_exports$1.KubbNode;
-  Schema?: (this: ReactGeneratorOptions<TOptions$1>, props: SchemaProps<TOptions$1>) => types_d_exports$1.KubbNode;
-};
-/****
- * Creates a generator that uses React component functions to generate files for OpenAPI operations and schemas.
- *
- * The returned generator exposes async methods for generating files from operations, a single operation, or a schema, using the corresponding React components if provided. If a component is not defined, the method returns an empty array.
- *
- * @returns A generator object with async methods for operations, operation, and schema file generation.
- */
-declare function createReactGenerator<TOptions$1 extends PluginFactoryOptions>(parseOptions: ReactGeneratorOptions<TOptions$1>): Generator<TOptions$1>;
+type Generator<TOptions extends PluginFactoryOptions> = CoreGenerator<TOptions> | ReactGenerator<TOptions>;
 //#endregion
 //#region src/OperationGenerator.d.ts
 type OperationMethodResult<TFileMeta extends FileMetaBase> = Promise<File<TFileMeta> | Array<File<TFileMeta>> | null>;
-type Context<TOptions$1, TPluginOptions extends PluginFactoryOptions> = {
+type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+  fabric: Fabric;
   oas: Oas;
   exclude: Array<Exclude$1> | undefined;
   include: Array<Include> | undefined;
-  override: Array<Override<TOptions$1>> | undefined;
+  override: Array<Override<TOptions>> | undefined;
   contentType: contentType | undefined;
   pluginManager: PluginManager;
   /**
@@ -847,5 +919,5 @@ declare class OperationGenerator<TPluginOptions extends PluginFactoryOptions = P
   build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<File<TFileMeta>>>;
 }
 //#endregion
-export { UserPluginWithLifeCycle as A, ResolvePathOptions as C, Output as D, Config as E, OpenAPIV3$1 as F, OpenAPIV3_1 as I, Operation$1 as L, Oas as M, HttpMethod as N, Plugin as O, OasTypes as P, SchemaObject$1 as R, Refs as S, FileMetaBase as T, OperationSchemas as _, ReactGeneratorOptions as a, PluginOas as b, GetSchemaGeneratorOptions as c, SchemaGeneratorOptions as d, SchemaMethodResult as f, OperationSchema as g, Include as h, GeneratorOptions as i, types_d_exports$1 as j, ResolveNameParams as k, SchemaGenerator as l, Exclude$1 as m, OperationMethodResult as n, createGenerator as o, API as p, Generator as r, createReactGenerator as s, OperationGenerator as t, SchemaGeneratorBuildOptions as u, Options$1 as v, Resolver as w, Ref as x, Override as y, contentType as z };
-//# sourceMappingURL=OperationGenerator-XkW6FZJh.d.cts.map
+export { Config as A, SchemaObject$1 as B, Ref as C, createReactGenerator as D, Resolver as E, HttpMethod as F, OasTypes as I, OpenAPIV3$1 as L, Plugin as M, ResolveNameParams as N, createGenerator as O, Oas as P, OpenAPIV3_1 as R, PluginOas as S, ResolvePathOptions as T, contentType as V, Include as _, pluginOasName as a, Options$1 as b, buildSchema as c, SchemaGeneratorBuildOptions as d, SchemaGeneratorOptions as f, Exclude$1 as g, API as h, pluginOas as i, Output as j, FileMetaBase as k, GetSchemaGeneratorOptions as l, jsonGenerator as m, OperationMethodResult as n, buildOperation as o, SchemaMethodResult as p, Generator as r, buildOperations as s, OperationGenerator as t, SchemaGenerator as u, OperationSchema as v, Refs as w, Override as x, OperationSchemas as y, Operation$1 as z };
+//# sourceMappingURL=OperationGenerator-CJTAer7l.d.cts.map

package/dist/{Schema-CHstINXC.d.ts → Schema-CjraJhJi.d.ts}

@@ -1,5 +1,6 @@
-import { R as SchemaObject, j as types_d_exports } from "./OperationGenerator-ki8g970_.js";
-import { t as Schema } from "./SchemaMapper-qjB3rBph.js";
+import { B as SchemaObject } from "./OperationGenerator-BZPWkxw4.js";
+import { t as Schema } from "./SchemaMapper-CqBW0VOy.js";
+import { Key, KubbNode } from "@kubb/react-fabric/types";
 
 //#region src/components/Schema.d.ts
 type SchemaContextProps = {
@@ -8,11 +9,11 @@ type SchemaContextProps = {
   tree: Array<Schema>;
 };
 type Props = {
-  key?: types_d_exports.Key;
+  key?: Key;
   name: string;
   schemaObject?: SchemaObject;
   tree?: Array<Schema>;
-  children?: types_d_exports.KubbNode;
+  children?: KubbNode;
 };
 /**
  * Provides schema-related context to descendant components.
@@ -28,10 +29,10 @@ declare function Schema$1({
   schemaObject,
   tree,
   children
-}: Props): any;
+}: Props): KubbNode;
 declare namespace Schema$1 {
   var Context;
 }
 //#endregion
 export { SchemaContextProps as n, Schema$1 as t };
-//# sourceMappingURL=Schema-CHstINXC.d.ts.map
+//# sourceMappingURL=Schema-CjraJhJi.d.ts.map

package/dist/{Schema-BXYfUkqN.d.cts → Schema-zcZF0UIp.d.cts}

@@ -1,5 +1,6 @@
-import { R as SchemaObject, j as types_d_exports } from "./OperationGenerator-XkW6FZJh.cjs";
+import { B as SchemaObject } from "./OperationGenerator-CJTAer7l.cjs";
 import { t as Schema } from "./SchemaMapper-MiRB5_Zp.cjs";
+import { Key, KubbNode } from "@kubb/react-fabric/types";
 
 //#region src/components/Schema.d.ts
 type SchemaContextProps = {
@@ -8,11 +9,11 @@ type SchemaContextProps = {
   tree: Array<Schema>;
 };
 type Props = {
-  key?: types_d_exports.Key;
+  key?: Key;
   name: string;
   schemaObject?: SchemaObject;
   tree?: Array<Schema>;
-  children?: types_d_exports.KubbNode;
+  children?: KubbNode;
 };
 /**
  * Provides schema-related context to descendant components.
@@ -28,10 +29,10 @@ declare function Schema$1({
   schemaObject,
   tree,
   children
-}: Props): any;
+}: Props): KubbNode;
 declare namespace Schema$1 {
   var Context;
 }
 //#endregion
 export { SchemaContextProps as n, Schema$1 as t };
-//# sourceMappingURL=Schema-BXYfUkqN.d.cts.map
+//# sourceMappingURL=Schema-zcZF0UIp.d.cts.map

package/dist/{SchemaGenerator-B07tXh1b.js → SchemaGenerator-7wBwdv8G.js}

@@ -1,8 +1,9 @@
-import { n as schemaKeywords, t as isKeyword } from "./SchemaMapper-CM1eXksi.js";
-import { n as getSchemaFactory, t as getSchemas } from "./getSchemas-CvUX0jWa.js";
-import { BaseGenerator } from "@kubb/core";
+import { r as buildSchema } from "./utils-BnkB1ikY.js";
+import { n as schemaKeywords, t as isKeyword } from "./SchemaMapper-Cx4X1al6.js";
+import { n as getSchemaFactory, t as getSchemas } from "./getSchemas-Bdg6n9Qk.js";
 import transformers, { pascalCase } from "@kubb/core/transformers";
 import { isDeepEqual, isNumber, uniqueWith } from "remeda";
+import { BaseGenerator } from "@kubb/core";
 import { getUniqueName } from "@kubb/core/utils";
 import { isDiscriminator, isNullable, isReference } from "@kubb/oas";
 
@@ -908,6 +909,22 @@ var SchemaGenerator = class SchemaGenerator extends BaseGenerator {
 					name,
 					schemaObject
 				});
+				if (generator.type === "react") {
+					await buildSchema({
+						name,
+						value: schemaObject,
+						tree
+					}, {
+						fabric: this.context.fabric,
+						generator,
+						instance: this,
+						options: {
+							...this.options,
+							...options
+						}
+					});
+					return [];
+				}
 				return await generator.schema?.({
 					instance: this,
 					schema: {
@@ -929,4 +946,4 @@ var SchemaGenerator = class SchemaGenerator extends BaseGenerator {
 
 //#endregion
 export { pLimit as n, SchemaGenerator as t };
-//# sourceMappingURL=SchemaGenerator-B07tXh1b.js.map
+//# sourceMappingURL=SchemaGenerator-7wBwdv8G.js.map