@kubb/plugin-faker 4.4.1 → 4.5.0

package/dist/{types-DRMQqYat.d.cts → types-NHbH6Svj.d.cts}

@@ -556,170 +556,6 @@ declare class Oas<const TOAS = unknown> extends BaseOas {
   valdiate(): Promise<oas_normalize_lib_types0.ValidationResult>;
 }
 //#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 = {
   object: {
@@ -937,8 +773,96 @@ 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: 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/SchemaGenerator.d.ts
-type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+type Context$1<TOptions, TPluginOptions extends PluginFactoryOptions> = {
   fabric: Fabric;
   oas: Oas;
   pluginManager: PluginManager;
@@ -971,15 +895,15 @@ type SchemaGeneratorOptions = {
      * TODO TODO add docs
      * @beta
      */
-    schema?: (schemaProps: SchemaProps, defaultSchemas: Schema[]) => Schema[] | undefined;
+    schema?: (schemaProps: SchemaProps$1, defaultSchemas: Schema[]) => Schema[] | undefined;
   };
 };
-type SchemaProps = {
+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>> {
+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;
   /**
@@ -987,16 +911,86 @@ declare class SchemaGenerator<TOptions extends SchemaGeneratorOptions = SchemaGe
    * Delegates to getBaseTypeFromSchema internally and
    * optionally adds a union with null.
    */
-  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;
+  parse(props: SchemaProps$1): Schema[];
   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<KubbFile.File<TFileMeta>>>;
 }
 //#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<TOptions>) => Promise<KubbFile.File[]>;
+};
+//#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<TOptions>) => KubbNode;
+};
+//#endregion
+//#region ../plugin-oas/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;
+  };
+};
+type Generator<TOptions extends PluginFactoryOptions> = CoreGenerator<TOptions> | ReactGenerator<TOptions>;
+//#endregion
+//#region ../plugin-oas/src/OperationGenerator.d.ts
+type Context<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<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/types.d.ts
 type Options$1 = {
   /**
@@ -1100,5 +1094,5 @@ type ResolvedOptions = {
 };
 type PluginFaker = PluginFactoryOptions<'plugin-faker', Options$1, ResolvedOptions, never, ResolvePathOptions>;
 //#endregion
-export { UserPluginWithLifeCycle as a, ReactGenerator as i, PluginFaker as n, Schema as r, Options$1 as t };
-//# sourceMappingURL=types-DRMQqYat.d.cts.map
+export { UserPluginWithLifeCycle as a, Schema as i, PluginFaker as n, ReactGenerator as r, Options$1 as t };
+//# sourceMappingURL=types-NHbH6Svj.d.cts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-faker",
-  "version": "4.4.1",
+  "version": "4.5.0",
   "description": "Faker.js data generator plugin for Kubb, creating realistic mock data from OpenAPI specifications for development and testing.",
   "keywords": [
     "faker",
@@ -68,17 +68,17 @@
     }
   ],
   "dependencies": {
-    "@kubb/react-fabric": "0.2.10",
-    "@kubb/core": "4.4.1",
-    "@kubb/oas": "4.4.1",
-    "@kubb/plugin-oas": "4.4.1",
-    "@kubb/plugin-ts": "4.4.1"
+    "@kubb/react-fabric": "0.2.14",
+    "@kubb/core": "4.5.0",
+    "@kubb/oas": "4.5.0",
+    "@kubb/plugin-oas": "4.5.0",
+    "@kubb/plugin-ts": "4.5.0"
   },
   "devDependencies": {
-    "@kubb/plugin-oas": "4.4.1"
+    "@kubb/plugin-oas": "4.5.0"
   },
   "peerDependencies": {
-    "@kubb/react-fabric": "0.2.10"
+    "@kubb/react-fabric": "0.2.14"
   },
   "engines": {
     "node": ">=20"

package/src/components/Faker.tsx

@@ -22,11 +22,9 @@ export function Faker({ tree, description, name, typeName, seed, regexGenerator,
     tree
       .map((schema, _index, siblings) =>
         parserFaker.parse(
-          { parent: undefined, current: schema, siblings },
+          { name, schema, parent: undefined, current: schema, siblings },
           {
-            name,
             typeName,
-            seed,
             regexGenerator,
             mapper,
             canOverride,

package/src/generators/__snapshots__/enumNames.ts

@@ -5,5 +5,5 @@
 import { faker } from '@faker-js/faker'
 
 export function enumNamesType() {
-  return faker.helpers.arrayElement<any>([0, 1])
+  return faker.helpers.arrayElement<EnumNamesType>([0, 1])
 }

package/src/generators/__snapshots__/enumVarNames.ts

@@ -5,5 +5,5 @@
 import { faker } from '@faker-js/faker'
 
 export function enumVarNamesType() {
-  return faker.helpers.arrayElement<any>([0, 1])
+  return faker.helpers.arrayElement<EnumVarNamesType>([0, 1])
 }

package/src/generators/fakerGenerator.tsx

@@ -1,30 +1,31 @@
-import { useMode, usePlugin, usePluginManager } from '@kubb/core/hooks'
-import { createReactGenerator, type OperationSchema as OperationSchemaType, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
-import { Oas } from '@kubb/plugin-oas/components'
+import { useMode, usePluginManager } from '@kubb/core/hooks'
+import { type OperationSchema as OperationSchemaType, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
+import { createReactGenerator } from '@kubb/plugin-oas/generators'
 import { useOas, useOperationManager, useSchemaManager } from '@kubb/plugin-oas/hooks'
 import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
 import { pluginTsName } from '@kubb/plugin-ts'
-import { File } from '@kubb/react-fabric'
+import { File, Fragment } from '@kubb/react-fabric'
 import { Faker } from '../components'
 import type { PluginFaker } from '../types'
 
 export const fakerGenerator = createReactGenerator<PluginFaker>({
   name: 'faker',
-  Operation({ operation, options, instance }) {
-    const { dateParser, regexGenerator, seed, mapper } = options
-
-    const plugin = usePlugin<PluginFaker>()
+  Operation({ operation, generator, plugin }) {
+    const {
+      options,
+      options: { dateParser, regexGenerator, seed, mapper },
+    } = plugin
     const mode = useMode()
     const pluginManager = usePluginManager()
 
     const oas = useOas()
-    const { getSchemas, getFile, getGroup } = useOperationManager()
+    const { getSchemas, getFile, getGroup } = useOperationManager(generator)
     const schemaManager = useSchemaManager()
 
     const file = getFile(operation)
     const schemas = getSchemas(operation)
     const schemaGenerator = new SchemaGenerator(options, {
-      fabric: instance.context.fabric,
+      fabric: generator.context.fabric,
       oas,
       plugin,
       pluginManager,
@@ -36,7 +37,7 @@ export const fakerGenerator = createReactGenerator<PluginFaker>({
       .flat()
       .filter(Boolean)
 
-    const mapOperationSchema = ({ name, schema: schemaObject, description, ...options }: OperationSchemaType, i: number) => {
+    const mapOperationSchema = ({ name, schema: schemaObject, description, ...options }: OperationSchemaType) => {
       const tree = schemaGenerator.parse({ schemaObject, name })
       const imports = schemaManager.getImports(tree)
       const group = options.operation ? getGroup(options.operation) : undefined
@@ -61,7 +62,7 @@ export const fakerGenerator = createReactGenerator<PluginFaker>({
       )
 
       return (
-        <Oas.Schema key={i} name={name} schemaObject={schemaObject} tree={tree}>
+        <Fragment>
           {canOverride && <File.Import isTypeOnly root={file.path} path={type.file.path} name={[type.name]} />}
           {imports.map((imp) => (
             <File.Import key={[imp.path, imp.name, imp.isTypeOnly].join('-')} root={file.path} path={imp.path} name={imp.name} />
@@ -77,7 +78,7 @@ export const fakerGenerator = createReactGenerator<PluginFaker>({
             seed={seed}
             canOverride={canOverride}
           />
-        </Oas.Schema>
+        </Fragment>
       )
     }
 
@@ -96,13 +97,11 @@ export const fakerGenerator = createReactGenerator<PluginFaker>({
       </File>
     )
   },
-  Schema({ schema, options }) {
-    const { dateParser, regexGenerator, seed, mapper } = options
-
+  Schema({ schema, plugin }) {
     const { getName, getFile, getImports } = useSchemaManager()
     const {
-      options: { output },
-    } = usePlugin<PluginFaker>()
+      options: { output, dateParser, regexGenerator, seed, mapper },
+    } = plugin
     const pluginManager = usePluginManager()
     const oas = useOas()
     const imports = getImports(schema.tree)

package/src/parser.ts

@@ -179,18 +179,14 @@ export function joinItems(items: string[]): string {
 }
 
 type ParserOptions = {
-  name: string
   typeName?: string
-  description?: string
-
-  seed?: number | number[]
   regexGenerator?: 'faker' | 'randexp'
   canOverride?: boolean
   dateParser?: Options['dateParser']
   mapper?: Record<string, string>
 }
 
-export function parse({ current, parent, name, siblings }: SchemaTree, options: ParserOptions): string | null | undefined {
+export function parse({ schema, current, parent, name, siblings }: SchemaTree, options: ParserOptions): string | null | undefined {
   const value = fakerKeywordMapper[current.keyword as keyof typeof fakerKeywordMapper]
 
   if (!value) {
@@ -203,22 +199,22 @@ export function parse({ current, parent, name, siblings }: SchemaTree, options:
     }
 
     return fakerKeywordMapper.union(
-      current.args.map((schema) => parse({ parent: current, current: schema, siblings }, { ...options, canOverride: false })).filter(Boolean),
+      current.args.map((it) => parse({ schema, parent: current, name, current: it, siblings }, { ...options, canOverride: false })).filter(Boolean),
     )
   }
 
   if (isKeyword(current, schemaKeywords.and)) {
     return fakerKeywordMapper.and(
-      current.args.map((schema) => parse({ parent: current, current: schema, siblings }, { ...options, canOverride: false })).filter(Boolean),
+      current.args.map((it) => parse({ schema, parent: current, current: it, siblings }, { ...options, canOverride: false })).filter(Boolean),
     )
   }
 
   if (isKeyword(current, schemaKeywords.array)) {
     return fakerKeywordMapper.array(
       current.args.items
-        .map((schema) =>
+        .map((it) =>
           parse(
-            { parent: current, current: schema, siblings },
+            { schema, parent: current, current: it, siblings },
             {
               ...options,
               typeName: `NonNullable<${options.typeName}>[number]`,
@@ -295,9 +291,9 @@ export function parse({ current, parent, name, siblings }: SchemaTree, options:
         return `"${name}": ${joinItems(
           schemas
             .sort(schemaKeywordSorter)
-            .map((schema) =>
+            .map((it) =>
               parse(
-                { name, parent: current, current: schema, siblings: schemas },
+                { schema, name, parent: current, current: it, siblings: schemas },
                 {
                   ...options,
                   typeName: `NonNullable<${options.typeName}>[${JSON.stringify(name)}]`,
@@ -316,11 +312,11 @@ export function parse({ current, parent, name, siblings }: SchemaTree, options:
   if (isKeyword(current, schemaKeywords.tuple)) {
     if (Array.isArray(current.args.items)) {
       return fakerKeywordMapper.tuple(
-        current.args.items.map((schema) => parse({ parent: current, current: schema, siblings }, { ...options, canOverride: false })).filter(Boolean),
+        current.args.items.map((it) => parse({ schema, parent: current, current: it, siblings }, { ...options, canOverride: false })).filter(Boolean),
       )
     }
 
-    return parse({ parent: current, current: current.args.items, siblings }, { ...options, canOverride: false })
+    return parse({ schema, parent: current, current: current.args.items, siblings }, { ...options, canOverride: false })
   }
 
   if (isKeyword(current, schemaKeywords.const)) {

package/src/types.ts

@@ -1,7 +1,8 @@
 import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
 
 import type { contentType, Oas, SchemaObject } from '@kubb/oas'
-import type { Exclude, Generator, Include, Override, ResolvePathOptions, Schema } from '@kubb/plugin-oas'
+import type { Exclude, Include, Override, ResolvePathOptions, Schema } from '@kubb/plugin-oas'
+import type { Generator } from '@kubb/plugin-oas/generators'
 
 export type Options = {
   /**