@kubb/plugin-oas 4.5.1 → 4.5.2

package/dist/{createGenerator-BvCDyuKS.d.ts → SchemaMapper-BtvCVaPJ.d.ts}

@@ -1,13 +1,12 @@
-import { h as contentType, i as SchemaKeywordMapper, l as HttpMethod, m as SchemaObject$1, p as Operation$1, t as Schema, u as OasTypes } from "./SchemaMapper-Cj3vjPGs.js";
-import { Fabric, FileManager } from "@kubb/react-fabric";
+import { Fabric } from "@kubb/react-fabric";
 import { KubbFile } from "@kubb/fabric-core/types";
 import { ConsolaInstance, LogLevel } from "consola";
-import { OASDocument, SchemaObject, User } from "oas/types";
-import { Operation } from "oas/operation";
-import { OpenAPIV3 } from "openapi-types";
+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, 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";
 
 //#region ../core/src/BaseGenerator.d.ts
 /**
@@ -75,6 +74,21 @@ type Logger = {
 type PossiblePromise<T> = Promise<T> | T;
 //#endregion
 //#region ../core/src/types.d.ts
+declare global {
+  namespace Kubb {
+    interface PluginContext {}
+  }
+}
+/**
+ * Config used in `kubb.config.ts`
+ *
+ * @example
+ * import { defineConfig } from '@kubb/core'
+ * export default defineConfig({
+ * ...
+ * })
+ */
+
 type InputPath = {
   /**
    * Specify your Swagger/OpenAPI file, either as an absolute path or a path relative to the root.
@@ -229,11 +243,8 @@ type UserPlugin<TOptions 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['context'] extends never ? {
-  context?: never;
-} : {
-  context: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext<TOptions>, 'addFile'>) => TOptions['context'];
-});
+  inject?: (this: PluginContext<TOptions>, context: PluginContext<TOptions>) => TOptions['context'];
+};
 type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>;
 type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
@@ -259,25 +270,26 @@ type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
    * Options set for a specific plugin(see kubb.config.js), passthrough of options.
    */
   options: TOptions['resolvedOptions'];
-} & (TOptions['context'] extends never ? {
-  context?: never;
-} : {
-  context: TOptions['context'];
-});
+  install: (this: PluginContext<TOptions>, context: PluginContext<TOptions>) => PossiblePromise<void>;
+  /**
+   * Define a context that can be used by other plugins, see `PluginManager' where we convert from `UserPlugin` to `Plugin`(used when calling `definePlugin`).
+   */
+  inject: (this: PluginContext<TOptions>, context: PluginContext<TOptions>) => TOptions['context'];
+};
 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>, Config: Config) => PossiblePromise<void>;
+  install?: (this: PluginContext<TOptions>, context: PluginContext<TOptions>) => 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>, baseName: KubbFile.BaseName, mode?: KubbFile.Mode, options?: TOptions['resolvePathOptions']) => KubbFile.OptionalPath;
+  resolvePath?: (this: PluginContext<TOptions>, baseName: KubbFile.BaseName, mode?: KubbFile.Mode, options?: TOptions['resolvePathOptions']) => KubbFile.Path;
   /**
    * Resolve to a name based on a string.
    * Useful when converting to PascalCase or camelCase.
@@ -285,11 +297,6 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
    * @example ('pet') => 'Pet'
    */
   resolveName?: (this: PluginContext<TOptions>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
-  /**
-   * End of the plugin lifecycle.
-   * @type hookParallel
-   */
-  buildEnd?: (this: PluginContext<TOptions>) => PossiblePromise<void>;
 };
 type PluginLifecycleHooks = keyof PluginLifecycle;
 type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H]>;
@@ -316,24 +323,15 @@ type ResolveNameParams = {
 type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   fabric: Fabric;
   config: Config;
-  /**
-   * @deprecated
-   */
-  fileManager: FileManager;
   pluginManager: PluginManager;
-  addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.ResolvedFile>>;
-  resolvePath: (params: ResolvePathParams<TOptions['resolvePathOptions']>) => KubbFile.OptionalPath;
-  resolveName: (params: ResolveNameParams) => string;
+  addFile: (...file: Array<KubbFile.File>) => Promise<void>;
   logger: Logger;
-  /**
-   * All plugins
-   */
-  plugins: Plugin[];
+  mode: KubbFile.Mode;
   /**
    * Current plugin
    */
   plugin: Plugin<TOptions>;
-};
+} & Kubb.PluginContext;
 /**
  * Specify the export location for the files and define the behavior of the output
  */
@@ -386,7 +384,7 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
   result: Result;
   plugin: Plugin;
 };
-type Options$3 = {
+type Options$1 = {
   fabric: Fabric;
   logger: Logger;
   /**
@@ -408,13 +406,14 @@ type GetFileProps<TOptions = object> = {
 };
 declare class PluginManager {
   #private;
-  readonly plugins: Set<Plugin<PluginFactoryOptions<string, object, object, any, object>>>;
   readonly events: EventEmitter<Events>;
   readonly config: Config;
   readonly executed: Array<Executer>;
   readonly logger: Logger;
-  readonly options: Options$3;
-  constructor(config: Config, options: Options$3);
+  readonly options: Options$1;
+  constructor(config: Config, options: Options$1);
+  getContext<TOptions extends PluginFactoryOptions>(plugin: Plugin<TOptions>): PluginContext<TOptions> & Record<string, any>;
+  get plugins(): Array<Plugin>;
   getFile<TOptions = object>({
     name,
     mode,
@@ -424,7 +423,7 @@ declare class PluginManager {
   }: GetFileProps<TOptions>): KubbFile.File<{
     pluginKey: Plugin['key'];
   }>;
-  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => KubbFile.OptionalPath;
+  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => KubbFile.Path;
   resolveName: (params: ResolveNameParams) => string;
   /**
    * Instead of calling `pluginManager.events.on` you can use `pluginManager.on`. This one also has better types.
@@ -512,17 +511,22 @@ declare class PluginManager {
   }): Promise<void>;
   getPluginByKey(pluginKey: Plugin['key']): Plugin | undefined;
   getPluginsByKey(hookName: keyof PluginWithLifeCycle, pluginKey: Plugin['key']): Plugin[];
-  static getDependedPlugins<T1 extends PluginFactoryOptions, T2 extends PluginFactoryOptions = never, T3 extends PluginFactoryOptions = never, TOutput = (T3 extends never ? (T2 extends never ? [T1: Plugin<T1>] : [T1: Plugin<T1>, T2: Plugin<T2>]) : [T1: Plugin<T1>, T2: Plugin<T2>, T3: Plugin<T3>])>(plugins: Array<Plugin>, dependedPluginNames: string | string[]): TOutput;
-  static get hooks(): readonly ["buildStart", "resolvePath", "resolveName", "buildEnd"];
 }
 //#endregion
-//#region ../core/src/FileManager.d.ts
+//#region ../core/src/utils/getBarrelFiles.d.ts
 type FileMetaBase = {
   pluginKey?: Plugin['key'];
 };
 //#endregion
+//#region ../oas/src/types.d.ts
+type contentType = 'application/json' | (string & {});
+type SchemaObject$1 = OasTypes.SchemaObject & {
+  'x-nullable'?: boolean;
+  $ref?: string;
+};
+//#endregion
 //#region ../oas/src/Oas.d.ts
-type Options$2 = {
+type Options = {
   contentType?: contentType;
   discriminator?: 'strict' | 'inherit';
 };
@@ -536,8 +540,8 @@ declare class Oas<const TOAS = unknown> extends BaseOas {
     oas: TOAS | OASDocument | string;
     user?: User;
   });
-  setOptions(options: Options$2): void;
-  get options(): Options$2;
+  setOptions(options: Options): void;
+  get options(): Options;
   get($ref: string): any;
   getKey($ref: string): string | undefined;
   set($ref: string, value: unknown): false | undefined;
@@ -549,312 +553,290 @@ declare class Oas<const TOAS = unknown> extends BaseOas {
   valdiate(): Promise<oas_normalize_lib_types0.ValidationResult>;
 }
 //#endregion
-//#region src/types.d.ts
-type ResolvePathOptions = {
-  pluginKey?: Plugin['key'];
-  group?: {
-    tag?: string;
-    path?: string;
+//#region ../oas/src/utils.d.ts
+declare function isOptional(schema?: SchemaObject): boolean;
+//#endregion
+//#region src/SchemaMapper.d.ts
+type SchemaKeywordMapper = {
+  object: {
+    keyword: 'object';
+    args: {
+      properties: {
+        [x: string]: Schema[];
+      };
+      additionalProperties: Schema[];
+      strict?: boolean;
+    };
   };
-  type?: ResolveNameParams['type'];
-};
-type API = {
-  getOas: () => Promise<Oas>;
-  getBaseURL: () => Promise<string | undefined>;
-};
-type Options$1 = {
-  /**
-   * Validate your input(see kubb.config) based on '@readme/openapi-parser'.
-   * @default true
-   */
-  validate?: boolean;
-  /**
-   * Specify the export location for the files and define the behavior of the output
-   * @default { path: 'schemas', barrelType: 'named' }
-   */
-  output?: Output<Oas>;
-  /**
-   * Group the JSON files based on the provided name.
-   */
-  group?: Group;
-  /**
-   * Which server to use from the array of `servers.url[serverIndex]`
-   * @example
-   * - `0` will return `http://petstore.swagger.io/api`
-   * - `1` will return `http://localhost:3000`
-   */
-  serverIndex?: number;
-  /**
-   * Define which contentType should be used.
-   * By default, the first JSON valid mediaType will be used
-   */
-  contentType?: contentType;
-  /**
-   * Defines how the discriminator value should be interpreted during processing.
-   *
-   * @default 'strict'
-   *
-   * @example
-   * - `inherit`: Replaces the `oneOf` schema with the schema referenced by `discriminator.mapping[key]`.
-   * - `strict`: Uses the `oneOf` schemas as defined, without modification.
-   *
-   * @see https://github.com/kubb-labs/kubb/issues/1736
-   */
-  discriminator?: 'strict' | 'inherit';
-  /**
-   * Override some behaviour of the Oas class instance, see '@kubb/oas'
-   */
-  oasClass?: typeof Oas;
-  /**
-   * Define some generators next to the JSON generation
-   */
-  generators?: Array<Generator<PluginOas>>;
-};
-/**
- * `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 Resolver = {
-  /**
-   * Original name or name resolved by `resolveName({ name: operation?.getOperationId() as string, pluginName })`
-   */
-  name: string;
-  baseName: KubbFile.BaseName;
-  path: KubbFile.Path;
-};
-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;
+  url: {
+    keyword: 'url';
   };
-  queryParams?: OperationSchema & {
-    keysToOmit?: never;
+  readOnly: {
+    keyword: 'readOnly';
   };
-  headerParams?: OperationSchema & {
-    keysToOmit?: never;
+  writeOnly: {
+    keyword: 'writeOnly';
   };
-  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>;
-};
-type ResolvedOptions = Options$1 & {
-  output: Output<Oas>;
-};
-type PluginOas = PluginFactoryOptions<'plugin-oas', Options$1, ResolvedOptions, API, ResolvePathOptions>;
-//#endregion
-//#region src/OperationGenerator.d.ts
-type OperationMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>;
-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 src/SchemaGenerator.d.ts
-type GetSchemaGeneratorOptions<T extends SchemaGenerator<any, any, any>> = T extends SchemaGenerator<infer Options, any, any> ? Options : never;
-type SchemaMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>;
-type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
-  fabric: Fabric;
-  oas: Oas;
-  pluginManager: PluginManager;
-  /**
-   * Current plugin
-   */
-  plugin: Plugin<TPluginOptions>;
-  mode: KubbFile.Mode;
-  include?: Array<'schemas' | 'responses' | 'requestBodies'>;
-  override: Array<Override<TOptions>> | undefined;
-  contentType?: contentType;
-  output?: string;
-};
-type SchemaGeneratorOptions = {
-  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
-  unknownType: 'any' | 'unknown' | 'void';
-  emptySchemaType: 'any' | 'unknown' | 'void';
-  enumType?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal';
-  enumSuffix?: string;
-  usedEnumNames?: Record<string, number>;
-  mapper?: Record<string, string>;
-  typed?: boolean;
-  transformers: {
-    /**
-     * Customize the names based on the type that is provided by the plugin.
-     */
-    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
-    /**
-     * Receive schema and name(propertName) and return FakerMeta array
-     * TODO TODO add docs
-     * @beta
-     */
-    schema?: (schemaProps: SchemaProps$1, defaultSchemas: Schema[]) => Schema[] | undefined;
+  uuid: {
+    keyword: 'uuid';
+  };
+  email: {
+    keyword: 'email';
+  };
+  firstName: {
+    keyword: 'firstName';
+  };
+  lastName: {
+    keyword: 'lastName';
+  };
+  phone: {
+    keyword: 'phone';
+  };
+  password: {
+    keyword: 'password';
+  };
+  date: {
+    keyword: 'date';
+    args: {
+      type?: 'date' | 'string';
+    };
+  };
+  time: {
+    keyword: 'time';
+    args: {
+      type?: 'date' | 'string';
+    };
+  };
+  datetime: {
+    keyword: 'datetime';
+    args: {
+      offset?: boolean;
+      local?: boolean;
+    };
+  };
+  tuple: {
+    keyword: 'tuple';
+    args: {
+      items: Schema[];
+      min?: number;
+      max?: number;
+      rest?: Schema;
+    };
+  };
+  array: {
+    keyword: 'array';
+    args: {
+      items: Schema[];
+      min?: number;
+      max?: number;
+      unique?: boolean;
+    };
+  };
+  enum: {
+    keyword: 'enum';
+    args: {
+      name: string;
+      typeName: string;
+      asConst: boolean;
+      items: Array<{
+        name: string | number;
+        format: 'string' | 'number' | 'boolean';
+        value?: string | number | boolean;
+      }>;
+    };
+  };
+  and: {
+    keyword: 'and';
+    args: Schema[];
+  };
+  const: {
+    keyword: 'const';
+    args: {
+      name: string | number;
+      format: 'string' | 'number' | 'boolean';
+      value?: string | number | boolean;
+    };
+  };
+  union: {
+    keyword: 'union';
+    args: Schema[];
+  };
+  ref: {
+    keyword: 'ref';
+    args: {
+      name: string;
+      $ref: string;
+      /**
+       * Full qualified path.
+       */
+      path: KubbFile.Path;
+      /**
+       * When true `File.Import` will be used.
+       * When false a reference will be used inside the current file.
+       */
+      isImportable: boolean;
+    };
+  };
+  matches: {
+    keyword: 'matches';
+    args?: string;
+  };
+  boolean: {
+    keyword: 'boolean';
+  };
+  default: {
+    keyword: 'default';
+    args: string | number | boolean;
+  };
+  string: {
+    keyword: 'string';
+  };
+  integer: {
+    keyword: 'integer';
+  };
+  number: {
+    keyword: 'number';
+  };
+  max: {
+    keyword: 'max';
+    args: number;
+  };
+  min: {
+    keyword: 'min';
+    args: number;
+  };
+  exclusiveMaximum: {
+    keyword: 'exclusiveMaximum';
+    args: number;
+  };
+  exclusiveMinimum: {
+    keyword: 'exclusiveMinimum';
+    args: number;
+  };
+  describe: {
+    keyword: 'describe';
+    args: string;
+  };
+  example: {
+    keyword: 'example';
+    args: string;
+  };
+  deprecated: {
+    keyword: 'deprecated';
+  };
+  optional: {
+    keyword: 'optional';
+  };
+  undefined: {
+    keyword: 'undefined';
+  };
+  nullish: {
+    keyword: 'nullish';
+  };
+  nullable: {
+    keyword: 'nullable';
+  };
+  null: {
+    keyword: 'null';
+  };
+  any: {
+    keyword: 'any';
+  };
+  unknown: {
+    keyword: 'unknown';
+  };
+  void: {
+    keyword: 'void';
+  };
+  blob: {
+    keyword: 'blob';
   };
-};
-type SchemaGeneratorBuildOptions = Omit<OperationSchema, 'name' | 'schema'>;
-type SchemaProps$1 = {
-  schemaObject?: SchemaObject$1;
-  name?: string;
-  parentName?: string;
-};
-declare class SchemaGenerator<TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TOptions, Context<TOptions, TPluginOptions>> {
-  #private;
-  refs: Refs;
-  /**
-   * Creates a type node from a given schema.
-   * Delegates to getBaseTypeFromSchema internally and
-   * optionally adds a union with null.
-   */
-  parse(props: SchemaProps$1): Schema[];
-  static deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): Array<SchemaKeywordMapper[T]>;
-  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<KubbFile.File<TFileMeta>>>;
-}
-//#endregion
-//#region src/generators/createReactGenerator.d.ts
-type UserGenerator$1<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$1<TOptions>): ReactGenerator<TOptions>;
-//#endregion
-//#region src/generators/types.d.ts
-type OperationsProps<TOptions extends PluginFactoryOptions> = {
-  config: Config;
-  generator: Omit<OperationGenerator<TOptions>, 'build'>;
-  plugin: Plugin<TOptions>;
-  operations: Array<Operation$1>;
-};
-type OperationProps<TOptions extends PluginFactoryOptions> = {
-  config: Config;
-  generator: Omit<OperationGenerator<TOptions>, 'build'>;
-  plugin: Plugin<TOptions>;
-  operation: Operation$1;
-};
-type SchemaProps<TOptions extends PluginFactoryOptions> = {
-  config: Config;
-  generator: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>;
-  plugin: Plugin<TOptions>;
   schema: {
-    name: string;
-    tree: Array<Schema>;
-    value: SchemaObject$1;
+    keyword: 'schema';
+    args: {
+      type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object';
+      format?: string;
+    };
+  };
+  name: {
+    keyword: 'name';
+    args: string;
+  };
+  catchall: {
+    keyword: 'catchall';
+  };
+  interface: {
+    keyword: 'interface';
   };
 };
-type Generator<TOptions extends PluginFactoryOptions> = CoreGenerator<TOptions> | ReactGenerator<TOptions>;
-//#endregion
-//#region src/generators/createGenerator.d.ts
-type UserGenerator<TOptions extends PluginFactoryOptions> = {
-  name: string;
-  operations?: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>;
-  operation?: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>;
-  schema?: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>;
-};
-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<TOptions>) => Promise<KubbFile.File[]>;
+declare const schemaKeywords: {
+  any: "any";
+  unknown: "unknown";
+  number: "number";
+  integer: "integer";
+  string: "string";
+  boolean: "boolean";
+  undefined: "undefined";
+  nullable: "nullable";
+  null: "null";
+  nullish: "nullish";
+  array: "array";
+  tuple: "tuple";
+  enum: "enum";
+  union: "union";
+  datetime: "datetime";
+  date: "date";
+  email: "email";
+  uuid: "uuid";
+  url: "url";
+  void: "void";
+  default: "default";
+  const: "const";
+  and: "and";
+  describe: "describe";
+  min: "min";
+  max: "max";
+  exclusiveMinimum: "exclusiveMinimum";
+  exclusiveMaximum: "exclusiveMaximum";
+  optional: "optional";
+  readOnly: "readOnly";
+  writeOnly: "writeOnly";
+  object: "object";
+  ref: "ref";
+  matches: "matches";
+  firstName: "firstName";
+  lastName: "lastName";
+  password: "password";
+  phone: "phone";
+  blob: "blob";
+  deprecated: "deprecated";
+  example: "example";
+  schema: "schema";
+  catchall: "catchall";
+  time: "time";
+  name: "name";
+  interface: "interface";
+};
+type SchemaKeyword = keyof SchemaKeywordMapper;
+type SchemaMapper<T = string | null | undefined> = { [K in keyof SchemaKeywordMapper]: (() => T | undefined) | undefined };
+type SchemaKeywordBase<T> = {
+  keyword: SchemaKeyword;
+  args: T;
+};
+type Schema = {
+  keyword: string;
+} | SchemaKeywordMapper[keyof SchemaKeywordMapper];
+type SchemaTree = {
+  schema: SchemaObject$1;
+  parent: Schema | undefined;
+  current: Schema;
+  siblings: Schema[];
+  /**
+   * this will be equal to the key of a property(object)
+   */
+  name?: string;
 };
-declare function createGenerator<TOptions extends PluginFactoryOptions>(generator: UserGenerator<TOptions>): CoreGenerator<TOptions>;
+declare function isKeyword<T extends Schema, K extends keyof SchemaKeywordMapper>(meta: T, keyword: K): meta is Extract<T, SchemaKeywordMapper[K]>;
 //#endregion
-export { PluginFactoryOptions as A, ResolvePathOptions as C, Config as D, FileMetaBase as E, UserPluginWithLifeCycle as M, Output as O, Refs as S, Oas as T, OperationSchemas as _, createReactGenerator as a, PluginOas as b, SchemaGeneratorBuildOptions as c, OperationGenerator as d, OperationMethodResult as f, OperationSchema as g, Include as h, ReactGenerator as i, ResolveNameParams as j, Plugin as k, SchemaGeneratorOptions as l, Exclude$1 as m, createGenerator as n, GetSchemaGeneratorOptions as o, API as p, Generator as r, SchemaGenerator as s, CoreGenerator as t, SchemaMethodResult as u, Options$1 as v, Resolver as w, Ref as x, Override as y };
-//# sourceMappingURL=createGenerator-BvCDyuKS.d.ts.map
+export { Plugin as C, BaseGenerator as D, UserPluginWithLifeCycle as E, Output as S, ResolveNameParams as T, contentType as _, SchemaMapper as a, Config as b, schemaKeywords as c, HttpMethod as d, OasTypes as f, SchemaObject$1 as g, Operation$1 as h, SchemaKeywordMapper as i, isOptional as l, OpenAPIV3_1 as m, SchemaKeyword as n, SchemaTree as o, OpenAPIV3$1 as p, SchemaKeywordBase as r, isKeyword as s, Schema as t, Oas as u, FileMetaBase as v, PluginFactoryOptions as w, Group as x, PluginManager as y };
+//# sourceMappingURL=SchemaMapper-BtvCVaPJ.d.ts.map