@kubb/plugin-client 4.3.1 → 4.4.1

package/dist/{types-BPLzP9R9.d.ts → types-DJmtgGu4.d.ts}

@@ -1,14 +1,14 @@
+import { Fabric, FileManager } from "@kubb/react-fabric";
 import * as OasTypes from "oas/types";
 import { HttpMethods as HttpMethod, OASDocument, SchemaObject, User } from "oas/types";
 import { Operation, Operation as Operation$1 } from "oas/operation";
 import { OpenAPIV3 } from "openapi-types";
 import * as oas_normalize_lib_types0 from "oas-normalize/lib/types";
 import BaseOas from "oas";
+import { KubbFile } from "@kubb/fabric-core/types";
 import { ConsolaInstance, LogLevel } from "consola";
-import { FileManager } from "@kubb/fabric-core";
+import { KubbNode } from "@kubb/react-fabric/types";
 
-//#region rolldown:runtime
-//#endregion
 //#region ../oas/src/types.d.ts
 type contentType = 'application/json' | (string & {});
 type SchemaObject$1 = OasTypes.SchemaObject & {
@@ -49,130 +49,15 @@ declare class Oas<const TOAS = unknown> extends BaseOas {
  * 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
-//#region ../core/src/fs/types.d.ts
-type BasePath<T$1 extends string = string> = `${T$1}/`;
-type Import = {
-  /**
-   * Import name to be used
-   * @example ["useState"]
-   * @example "React"
-   */
-  name: string | Array<string | {
-    propertyName: string;
-    name?: string;
-  }>;
-  /**
-   * Path for the import
-   * @example '@kubb/core'
-   */
-  path: string;
-  /**
-   * Add `type` prefix to the import, this will result in: `import type { Type } from './path'`.
-   */
-  isTypeOnly?: boolean;
-  isNameSpace?: boolean;
-  /**
-   * When root is set it will get the path with relative getRelativePath(root, path).
-   */
-  root?: string;
-};
-type Source = {
-  name?: string;
-  value?: string;
-  isTypeOnly?: boolean;
-  /**
-   * Has const or type 'export'
-   * @default false
-   */
-  isExportable?: boolean;
-  /**
-   * When set, barrel generation will add this
-   * @default false
-   */
-  isIndexable?: boolean;
-};
-type Export = {
-  /**
-   * Export name to be used.
-   * @example ["useState"]
-   * @example "React"
-   */
-  name?: string | Array<string>;
-  /**
-   * Path for the import.
-   * @example '@kubb/core'
-   */
-  path: string;
-  /**
-   * Add `type` prefix to the export, this will result in: `export type { Type } from './path'`.
-   */
-  isTypeOnly?: boolean;
-  /**
-   * Make it possible to override the name, this will result in: `export * as aliasName from './path'`.
-   */
-  asAlias?: boolean;
-};
-type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
-type Mode = 'single' | 'split';
-/**
- * Name to be used to dynamicly create the baseName(based on input.path)
- * Based on UNIX basename
- * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
- */
-type BaseName = `${string}.${string}`;
-/**
- * Path will be full qualified path to a specified file
- */
-type Path = string;
-type AdvancedPath<T$1 extends BaseName = BaseName> = `${BasePath}${T$1}`;
-type OptionalPath = Path | undefined | null;
-type File<TMeta extends object = object> = {
-  /**
-   * Name to be used to create the path
-   * Based on UNIX basename, `${name}.extname`
-   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
-   */
-  baseName: BaseName;
-  /**
-   * Path will be full qualified path to a specified file
-   */
-  path: AdvancedPath<BaseName> | Path;
-  sources: Array<Source>;
-  imports?: Array<Import>;
-  exports?: Array<Export>;
-  /**
-   * Use extra meta, this is getting used to generate the barrel/index files.
-   */
-  meta?: TMeta;
-  banner?: string;
-  footer?: string;
-};
-type ResolvedImport = Import;
-type ResolvedExport = Export;
-type ResolvedFile<TMeta extends object = object> = File<TMeta> & {
-  /**
-   * @default object-hash
-   */
-  id: string;
-  /**
-   * Contains the first part of the baseName, generated based on baseName
-   * @link  https://nodejs.org/api/path.html#pathformatpathobject
-   */
-  name: string;
-  extname: Extname;
-  imports: Array<ResolvedImport>;
-  exports: Array<ResolvedExport>;
-};
-//#endregion
 //#region ../core/src/utils/EventEmitter.d.ts
 declare class EventEmitter<TEvents extends Record<string, any>> {
   #private;
@@ -222,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 = {
@@ -296,7 +181,7 @@ type Config<TInput = Input> = {
      * Override the extension to the generated imports and exports, by default each plugin will add an extension
      * @default { '.ts': '.ts'}
      */
-    extension?: Record<Extname, Extname | ''>;
+    extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>;
     /**
      * Specify how `index.ts` files should be created. You can also disable the generation of barrel files here. While each plugin has its own `barrelType` option, this setting controls the creation of the root barrel file, such as` src/gen/index.ts`.
      * @default 'named'
@@ -335,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.
  */
@@ -353,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.
@@ -379,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.
@@ -408,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: KubbFile.BaseName, mode?: KubbFile.Mode, options?: TOptions['resolvePathOptions']) => KubbFile.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;
+  baseName: KubbFile.BaseName;
+  mode?: KubbFile.Mode;
   /**
    * Options to be passed to 'resolvePath' 3th parameter
    */
-  options?: TOptions$1;
+  options?: TOptions;
 };
 type ResolveNameParams = {
   name: string;
@@ -463,15 +348,16 @@ 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
    */
   fileManager: FileManager;
   pluginManager: PluginManager;
-  addFile: (...file: Array<File>) => Promise<Array<ResolvedFile>>;
-  resolvePath: (params: ResolvePathParams<TOptions$1['resolvePathOptions']>) => OptionalPath;
+  addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.ResolvedFile>>;
+  resolvePath: (params: ResolvePathParams<TOptions['resolvePathOptions']>) => KubbFile.OptionalPath;
   resolveName: (params: ResolveNameParams) => string;
   logger: Logger;
   /**
@@ -481,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
    */
@@ -499,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;
@@ -522,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
@@ -547,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;
+  mode?: KubbFile.Mode;
+  extname: KubbFile.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>;
@@ -573,10 +456,10 @@ declare class PluginManager {
     extname,
     pluginKey,
     options
-  }: GetFileProps<TOptions>): File<{
+  }: GetFileProps<TOptions>): KubbFile.File<{
     pluginKey: Plugin['key'];
   }>;
-  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => OptionalPath;
+  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => KubbFile.OptionalPath;
   resolveName: (params: ResolveNameParams) => string;
   /**
    * Instead of calling `pluginManager.events.on` you can use `pluginManager.on`. This one also has better types.
@@ -672,7 +555,170 @@ declare class PluginManager {
 type FileMetaBase = {
   pluginKey?: Plugin['key'];
 };
-import * as import___kubb_react_fabric_types from "@kubb/react-fabric/types";
+//#endregion
+//#region ../plugin-oas/src/generators/createReactGenerator.d.ts
+type ReactGenerator<TOptions extends PluginFactoryOptions> = {
+  name: string;
+  type: 'react';
+  Operations: (props: OperationsProps<TOptions>) => KubbNode;
+  Operation: (props: OperationProps<TOptions>) => KubbNode;
+  Schema: (props: SchemaProps$1<TOptions>) => KubbNode;
+};
+//#endregion
+//#region ../plugin-oas/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 extends PluginFactoryOptions> = {
+  /**
+   * @deprecated
+   */
+  instance: Omit<OperationGenerator<TOptions>, 'build'>;
+  options: TOptions['resolvedOptions'];
+  operation: Operation$1;
+};
+type SchemaProps$1<TOptions extends PluginFactoryOptions> = {
+  instance: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>;
+  options: TOptions['resolvedOptions'];
+  schema: {
+    name: string;
+    tree: Array<Schema>;
+    value: SchemaObject$1;
+  };
+};
+type Generator<TOptions extends PluginFactoryOptions> = CoreGenerator<TOptions> | ReactGenerator<TOptions>;
+//#endregion
+//#region ../plugin-oas/src/generators/createGenerator.d.ts
+type CoreGenerator<TOptions extends PluginFactoryOptions> = {
+  name: string;
+  type: 'core';
+  operations: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>;
+  operation: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>;
+  schema: (props: SchemaProps$1<TOptions>) => Promise<KubbFile.File[]>;
+};
+//#endregion
+//#region ../plugin-oas/src/types.d.ts
+type ResolvePathOptions = {
+  pluginKey?: Plugin['key'];
+  group?: {
+    tag?: string;
+    path?: string;
+  };
+  type?: ResolveNameParams['type'];
+};
+/**
+ * `propertyName` is the ref name + resolved with the nameResolver
+ *  @example import { Pet } from './Pet'
+ *
+ * `originalName` is the original name used(in PascalCase), only used to remove duplicates
+ *
+ * `pluginKey` can be used to override the current plugin being used, handy when you want to import a type/schema out of another plugin
+ * @example import a type(plugin-ts) for a mock file(swagger-faker)
+ */
+type Ref = {
+  propertyName: string;
+  originalName: string;
+  path: KubbFile.OptionalPath;
+  pluginKey?: Plugin['key'];
+};
+type Refs = Record<string, Ref>;
+type OperationSchema = {
+  /**
+   * Converted name, contains already `PathParams`, `QueryParams`, ...
+   */
+  name: string;
+  schema: SchemaObject$1;
+  operation?: Operation$1;
+  /**
+   * OperationName in PascalCase, only being used in OperationGenerator
+   */
+  operationName: string;
+  description?: string;
+  statusCode?: number;
+  keys?: string[];
+  keysToOmit?: string[];
+  withData?: boolean;
+};
+type OperationSchemas = {
+  pathParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  queryParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  headerParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  request?: OperationSchema;
+  response: OperationSchema;
+  responses: Array<OperationSchema>;
+  statusCodes?: Array<OperationSchema>;
+  errors?: Array<OperationSchema>;
+};
+type ByTag = {
+  type: 'tag';
+  pattern: string | RegExp;
+};
+type ByOperationId = {
+  type: 'operationId';
+  pattern: string | RegExp;
+};
+type ByPath = {
+  type: 'path';
+  pattern: string | RegExp;
+};
+type ByMethod = {
+  type: 'method';
+  pattern: HttpMethod | RegExp;
+};
+type BySchemaName = {
+  type: 'schemaName';
+  pattern: string | RegExp;
+};
+type ByContentType = {
+  type: 'contentType';
+  pattern: string | RegExp;
+};
+type Exclude$1 = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
+type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
+type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName | ByContentType) & {
+  options: Partial<TOptions>;
+};
+//#endregion
+//#region ../plugin-oas/src/OperationGenerator.d.ts
+type Context$1<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+  fabric: Fabric;
+  oas: Oas;
+  exclude: Array<Exclude$1> | undefined;
+  include: Array<Include> | undefined;
+  override: Array<Override<TOptions>> | undefined;
+  contentType: contentType | undefined;
+  pluginManager: PluginManager;
+  /**
+   * Current plugin
+   */
+  plugin: Plugin<TPluginOptions>;
+  mode: KubbFile.Mode;
+};
+declare class OperationGenerator<TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TPluginOptions['resolvedOptions'], Context$1<TPluginOptions['resolvedOptions'], TPluginOptions>> {
+  #private;
+  getSchemas(operation: Operation$1, {
+    resolveName
+  }?: {
+    resolveName?: (name: string) => string;
+  }): OperationSchemas;
+  getOperations(): Promise<Array<{
+    path: string;
+    method: HttpMethod;
+    operation: Operation$1;
+  }>>;
+  build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+}
 //#endregion
 //#region ../plugin-oas/src/SchemaMapper.d.ts
 type SchemaKeywordMapper = {
@@ -787,7 +833,7 @@ type SchemaKeywordMapper = {
       /**
        * Full qualified path.
        */
-      path: OptionalPath;
+      path: KubbFile.OptionalPath;
       /**
        * When true `File.Import` will be used.
        * When false a reference will be used inside the current file.
@@ -891,105 +937,18 @@ type Schema = {
   keyword: string;
 } | SchemaKeywordMapper[keyof SchemaKeywordMapper];
 //#endregion
-//#region ../plugin-oas/src/types.d.ts
-type ResolvePathOptions = {
-  pluginKey?: Plugin['key'];
-  group?: {
-    tag?: string;
-    path?: string;
-  };
-  type?: ResolveNameParams['type'];
-};
-/**
- * `propertyName` is the ref name + resolved with the nameResolver
- *  @example import { Pet } from './Pet'
- *
- * `originalName` is the original name used(in PascalCase), only used to remove duplicates
- *
- * `pluginKey` can be used to override the current plugin being used, handy when you want to import a type/schema out of another plugin
- * @example import a type(plugin-ts) for a mock file(swagger-faker)
- */
-type Ref = {
-  propertyName: string;
-  originalName: string;
-  path: OptionalPath;
-  pluginKey?: Plugin['key'];
-};
-type Refs = Record<string, Ref>;
-type OperationSchema = {
-  /**
-   * Converted name, contains already `PathParams`, `QueryParams`, ...
-   */
-  name: string;
-  schema: SchemaObject$1;
-  operation?: Operation$1;
-  /**
-   * OperationName in PascalCase, only being used in OperationGenerator
-   */
-  operationName: string;
-  description?: string;
-  statusCode?: number;
-  keys?: string[];
-  keysToOmit?: string[];
-  withData?: boolean;
-};
-type OperationSchemas = {
-  pathParams?: OperationSchema & {
-    keysToOmit?: never;
-  };
-  queryParams?: OperationSchema & {
-    keysToOmit?: never;
-  };
-  headerParams?: OperationSchema & {
-    keysToOmit?: never;
-  };
-  request?: OperationSchema;
-  response: OperationSchema;
-  responses: Array<OperationSchema>;
-  statusCodes?: Array<OperationSchema>;
-  errors?: Array<OperationSchema>;
-};
-type ByTag = {
-  type: 'tag';
-  pattern: string | RegExp;
-};
-type ByOperationId = {
-  type: 'operationId';
-  pattern: string | RegExp;
-};
-type ByPath = {
-  type: 'path';
-  pattern: string | RegExp;
-};
-type ByMethod = {
-  type: 'method';
-  pattern: HttpMethod | RegExp;
-};
-type BySchemaName = {
-  type: 'schemaName';
-  pattern: string | RegExp;
-};
-type ByContentType = {
-  type: 'contentType';
-  pattern: string | RegExp;
-};
-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>;
-};
-//#endregion
 //#region ../plugin-oas/src/SchemaGenerator.d.ts
-type Context$1<TOptions$1, TPluginOptions extends PluginFactoryOptions> = {
+type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+  fabric: Fabric;
   oas: Oas;
   pluginManager: PluginManager;
   /**
    * Current plugin
    */
   plugin: Plugin<TPluginOptions>;
-  mode: Mode;
+  mode: KubbFile.Mode;
   include?: Array<'schemas' | 'responses' | 'requestBodies'>;
-  override: Array<Override<TOptions$1>> | undefined;
+  override: Array<Override<TOptions>> | undefined;
   contentType?: contentType;
   output?: string;
 };
@@ -1012,15 +971,15 @@ type SchemaGeneratorOptions = {
      * TODO TODO add docs
      * @beta
      */
-    schema?: (schemaProps: SchemaProps$1, defaultSchemas: Schema[]) => Schema[] | undefined;
+    schema?: (schemaProps: SchemaProps, defaultSchemas: Schema[]) => Schema[] | undefined;
   };
 };
-type SchemaProps$1 = {
+type SchemaProps = {
   schemaObject?: SchemaObject$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<TOptions, TPluginOptions>> {
   #private;
   refs: Refs;
   /**
@@ -1028,71 +987,14 @@ declare class SchemaGenerator<TOptions$1 extends SchemaGeneratorOptions = Schema
    * Delegates to getBaseTypeFromSchema internally and
    * optionally adds a union with null.
    */
-  parse(props: SchemaProps$1): Schema[];
+  parse(props: SchemaProps): Schema[];
   deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): Array<SchemaKeywordMapper[T]>;
   find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
   static deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): Array<SchemaKeywordMapper[T]>;
   static findInObject<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
   static find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
   static combineObjects(tree: Schema[] | undefined): Schema[];
-  build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<File<TFileMeta>>>;
-}
-//#endregion
-//#region ../plugin-oas/src/generator.d.ts
-type OperationsProps<TOptions$1 extends PluginFactoryOptions> = {
-  instance: Omit<OperationGenerator<TOptions$1>, 'build'>;
-  options: TOptions$1['resolvedOptions'];
-  operations: Array<Operation$1>;
-};
-type OperationProps<TOptions$1 extends PluginFactoryOptions> = {
-  instance: Omit<OperationGenerator<TOptions$1>, 'build'>;
-  options: TOptions$1['resolvedOptions'];
-  operation: Operation$1;
-};
-type SchemaProps<TOptions$1 extends PluginFactoryOptions> = {
-  instance: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions$1>, 'build'>;
-  options: TOptions$1['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>;
-//#endregion
-//#region ../plugin-oas/src/OperationGenerator.d.ts
-type Context<TOptions$1, TPluginOptions extends PluginFactoryOptions> = {
-  oas: Oas;
-  exclude: Array<Exclude$1> | undefined;
-  include: Array<Include> | undefined;
-  override: Array<Override<TOptions$1>> | undefined;
-  contentType: contentType | undefined;
-  pluginManager: PluginManager;
-  /**
-   * Current plugin
-   */
-  plugin: Plugin<TPluginOptions>;
-  mode: Mode;
-};
-declare class OperationGenerator<TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TPluginOptions['resolvedOptions'], Context<TPluginOptions['resolvedOptions'], TPluginOptions>> {
-  #private;
-  getSchemas(operation: Operation$1, {
-    resolveName
-  }?: {
-    resolveName?: (name: string) => string;
-  }): OperationSchemas;
-  getOperations(): Promise<Array<{
-    path: string;
-    method: HttpMethod;
-    operation: Operation$1;
-  }>>;
-  build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<File<TFileMeta>>>;
+  build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
 }
 //#endregion
 //#region src/types.d.ts
@@ -1210,5 +1112,5 @@ type ResolvedOptions = {
 };
 type PluginClient = PluginFactoryOptions<'plugin-client', Options$1, ResolvedOptions, never, ResolvePathOptions>;
 //#endregion
-export { types_d_exports$1 as a, __reExport as c, OperationSchemas as i, PluginClient as n, UserPluginWithLifeCycle as o, Generator as r, Operation$1 as s, Options$1 as t };
-//# sourceMappingURL=types-BPLzP9R9.d.ts.map
+export { UserPluginWithLifeCycle as a, ReactGenerator as i, PluginClient as n, Operation$1 as o, OperationSchemas as r, Options$1 as t };
+//# sourceMappingURL=types-DJmtgGu4.d.ts.map