@kubb/plugin-ts 4.4.1 → 4.5.0

package/dist/{types-DEsrThze.d.cts → types-BdHzvKY0.d.cts}

@@ -557,170 +557,6 @@ type FileMetaBase = {
   pluginKey?: Plugin['key'];
 };
 //#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: {
@@ -938,8 +774,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;
@@ -972,15 +896,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;
   /**
@@ -988,16 +912,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 = {
   /**
@@ -1110,5 +1104,5 @@ type PluginTs = PluginFactoryOptions<'plugin-ts', Options$1, ResolvedOptions, {
   usedEnumNames: Record<string, number>;
 }, ResolvePathOptions>;
 //#endregion
-export { UserPluginWithLifeCycle as a, ReactGenerator as i, PluginTs as n, OasTypes as o, Schema as r, SchemaObject$1 as s, Options$1 as t };
-//# sourceMappingURL=types-DEsrThze.d.cts.map
+export { UserPluginWithLifeCycle as a, Schema as i, PluginTs as n, OasTypes as o, ReactGenerator as r, SchemaObject$1 as s, Options$1 as t };
+//# sourceMappingURL=types-BdHzvKY0.d.cts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-ts",
-  "version": "4.4.1",
+  "version": "4.5.0",
   "description": "TypeScript code generation plugin for Kubb, transforming OpenAPI schemas into TypeScript interfaces, types, and utility functions.",
   "keywords": [
     "typescript",
@@ -64,19 +64,19 @@
     }
   ],
   "dependencies": {
-    "@kubb/fabric-core": "0.2.10",
-    "@kubb/react-fabric": "0.2.10",
+    "@kubb/fabric-core": "0.2.14",
+    "@kubb/react-fabric": "0.2.14",
     "remeda": "^2.32.0",
     "typescript": "5.9.3",
-    "@kubb/core": "4.4.1",
-    "@kubb/oas": "4.4.1",
-    "@kubb/plugin-oas": "4.4.1"
+    "@kubb/core": "4.5.0",
+    "@kubb/oas": "4.5.0",
+    "@kubb/plugin-oas": "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/Type.tsx

@@ -36,16 +36,11 @@ export function Type({ name, typedName, tree, keysToOmit, schema, optionalType,
     (tree
       .map((current, _index, siblings) =>
         parse(
-          { parent: undefined, current, siblings },
+          { name, schema, parent: undefined, current, siblings },
           {
-            name,
-            typedName,
-            description,
-            keysToOmit,
             optionalType,
             enumType,
             mapper,
-            syntaxType,
           },
         ),
       )

package/src/generators/index.ts

@@ -1,2 +1,2 @@
-export { typeGenerator } from './typeGenerator.tsx'
 export { oasGenerator } from './oasGenerator.tsx'
+export { typeGenerator } from './typeGenerator.tsx'

package/src/generators/oasGenerator.tsx

@@ -1,5 +1,5 @@
-import { usePlugin, usePluginManager } from '@kubb/core/hooks'
-import { createReactGenerator } from '@kubb/plugin-oas'
+import { usePluginManager } from '@kubb/core/hooks'
+import { createReactGenerator } from '@kubb/plugin-oas/generators'
 import { useOas } from '@kubb/plugin-oas/hooks'
 import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
 import { File } from '@kubb/react-fabric'
@@ -8,11 +8,11 @@ import type { PluginTs } from '../types.ts'
 
 export const oasGenerator = createReactGenerator<PluginTs>({
   name: 'oas',
-  Operations() {
+  Operations({ plugin }) {
     const {
       options: { output },
       key: pluginKey,
-    } = usePlugin<PluginTs>()
+    } = plugin
     const pluginManager = usePluginManager()
     const oas = useOas()
 

package/src/generators/typeGenerator.tsx

@@ -1,16 +1,9 @@
 import type { PluginManager } from '@kubb/core'
-import { useMode, usePlugin, usePluginManager } from '@kubb/core/hooks'
+import { useMode, usePluginManager } from '@kubb/core/hooks'
 import transformers from '@kubb/core/transformers'
 import { print } from '@kubb/fabric-core/parsers/typescript'
-import {
-  createReactGenerator,
-  isKeyword,
-  type OperationSchemas,
-  type OperationSchema as OperationSchemaType,
-  SchemaGenerator,
-  schemaKeywords,
-} from '@kubb/plugin-oas'
-import { Oas } from '@kubb/plugin-oas/components'
+import { isKeyword, type OperationSchemas, 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 { File } from '@kubb/react-fabric'
@@ -112,15 +105,17 @@ function printCombinedSchema({ name, schemas, pluginManager }: { name: string; s
 
 export const typeGenerator = createReactGenerator<PluginTs>({
   name: 'typescript',
-  Operation({ operation, options, instance }) {
-    const { mapper, enumType, syntaxType, optionalType } = options
+  Operation({ operation, generator, plugin }) {
+    const {
+      options,
+      options: { mapper, enumType, syntaxType, optionalType },
+    } = plugin
 
-    const plugin = usePlugin<PluginTs>()
     const mode = useMode()
     const pluginManager = usePluginManager()
 
     const oas = useOas()
-    const { getSchemas, getFile, getName, getGroup } = useOperationManager()
+    const { getSchemas, getFile, getName, getGroup } = useOperationManager(generator)
     const schemaManager = useSchemaManager()
 
     const file = getFile(operation)
@@ -128,7 +123,7 @@ export const typeGenerator = createReactGenerator<PluginTs>({
     const type = getName(operation, { type: 'function', pluginKey: [pluginTsName] })
     const combinedSchemaName = operation.method === 'get' ? `${type}Query` : `${type}Mutation`
     const schemaGenerator = new SchemaGenerator(options, {
-      fabric: instance.context.fabric,
+      fabric: generator.context.fabric,
       oas,
       plugin,
       pluginManager,
@@ -152,7 +147,7 @@ export const typeGenerator = createReactGenerator<PluginTs>({
       }
 
       return (
-        <Oas.Schema key={[name, schemaObject.$ref].join('-')} name={name} schemaObject={schemaObject} tree={tree}>
+        <>
           {mode === 'split' &&
             imports.map((imp) => (
               <File.Import key={[name, imp.name, imp.path, imp.isTypeOnly].join('-')} root={file.path} path={imp.path} name={imp.name} isTypeOnly />
@@ -169,7 +164,7 @@ export const typeGenerator = createReactGenerator<PluginTs>({
             keysToOmit={keysToOmit}
             syntaxType={syntaxType}
           />
-        </Oas.Schema>
+        </>
       )
     }
 
@@ -189,11 +184,10 @@ export const typeGenerator = createReactGenerator<PluginTs>({
       </File>
     )
   },
-  Schema({ schema, options }) {
-    const { mapper, enumType, syntaxType, optionalType } = options
+  Schema({ schema, plugin }) {
     const {
-      options: { output },
-    } = usePlugin<PluginTs>()
+      options: { mapper, enumType, syntaxType, optionalType, output },
+    } = plugin
     const mode = useMode()
 
     const oas = useOas()

package/src/parser.ts

@@ -138,9 +138,6 @@ export const typeKeywordMapper = {
 } satisfies SchemaMapper<ts.TypeNode | null | undefined>
 
 type ParserOptions = {
-  name: string
-  typedName?: string
-  description?: string
   /**
    * @default `'questionToken'`
    */
@@ -150,8 +147,6 @@ type ParserOptions = {
    * asPascalConst is deprecated
    */
   enumType: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal'
-  syntaxType: 'type' | 'interface'
-  keysToOmit?: string[]
   mapper?: Record<string, ts.PropertySignature>
 }
 
@@ -166,7 +161,7 @@ type ParserOptions = {
  * @param options - Parsing options controlling output style, property handling, and custom mappers.
  * @returns The generated TypeScript AST node, or `undefined` if the schema keyword is not mapped.
  */
-export function parse({ current, siblings, name }: SchemaTree, options: ParserOptions): ts.Node | null | undefined {
+export function parse({ schema, current, siblings, name }: SchemaTree, options: ParserOptions): ts.Node | null | undefined {
   const value = typeKeywordMapper[current.keyword as keyof typeof typeKeywordMapper]
 
   if (!value) {
@@ -175,19 +170,19 @@ export function parse({ current, siblings, name }: SchemaTree, options: ParserOp
 
   if (isKeyword(current, schemaKeywords.union)) {
     return typeKeywordMapper.union(
-      current.args.map((schema) => parse({ parent: current, name: name, current: schema, siblings }, options)).filter(Boolean) as ts.TypeNode[],
+      current.args.map((it) => parse({ schema, parent: current, name, current: it, siblings }, options)).filter(Boolean) as ts.TypeNode[],
     )
   }
 
   if (isKeyword(current, schemaKeywords.and)) {
     return typeKeywordMapper.and(
-      current.args.map((schema) => parse({ parent: current, name: name, current: schema, siblings }, options)).filter(Boolean) as ts.TypeNode[],
+      current.args.map((it) => parse({ schema, parent: current, name, current: it, siblings }, options)).filter(Boolean) as ts.TypeNode[],
     )
   }
 
   if (isKeyword(current, schemaKeywords.array)) {
     return typeKeywordMapper.array(
-      current.args.items.map((schema) => parse({ parent: current, name: name, current: schema, siblings }, options)).filter(Boolean) as ts.TypeNode[],
+      current.args.items.map((it) => parse({ schema, parent: current, name, current: it, siblings }, options)).filter(Boolean) as ts.TypeNode[],
     )
   }
 
@@ -206,8 +201,8 @@ export function parse({ current, siblings, name }: SchemaTree, options: ParserOp
 
   if (isKeyword(current, schemaKeywords.tuple)) {
     return typeKeywordMapper.tuple(
-      current.args.items.map((schema) => parse({ parent: current, name: name, current: schema, siblings }, options)).filter(Boolean) as ts.TypeNode[],
-      current.args.rest && ((parse({ parent: current, name: name, current: current.args.rest, siblings }, options) ?? undefined) as ts.TypeNode | undefined),
+      current.args.items.map((it) => parse({ schema, parent: current, name, current: it, siblings }, options)).filter(Boolean) as ts.TypeNode[],
+      current.args.rest && ((parse({ schema, parent: current, name, current: current.args.rest, siblings }, options) ?? undefined) as ts.TypeNode | undefined),
       current.args.min,
       current.args.max,
     )
@@ -246,12 +241,13 @@ export function parse({ current, siblings, name }: SchemaTree, options: ParserOp
         const matchesSchema = schemas.find((schema) => schema.keyword === schemaKeywords.matches) as SchemaKeywordMapper['matches'] | undefined
 
         let type = schemas
-          .map((schema) =>
+          .map((it) =>
             parse(
               {
+                schema,
                 parent: current,
-                name: name,
-                current: schema,
+                name,
+                current: it,
                 siblings: schemas,
               },
               options,
@@ -305,7 +301,7 @@ export function parse({ current, siblings, name }: SchemaTree, options: ParserOp
 
     if (current.args?.additionalProperties?.length) {
       additionalProperties = current.args.additionalProperties
-        .map((schema) => parse({ parent: current, name: name, current: schema, siblings }, options))
+        .map((it) => parse({ schema, parent: current, name, current: it, siblings }, options))
         .filter(Boolean)
         .at(0) as ts.TypeNode
 

package/src/types.ts

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