@kubb/plugin-faker 5.0.0-alpha.9 → 5.0.0-beta.3

package/src/printers/printerFaker.ts

@@ -0,0 +1,341 @@
+import { stringify, toRegExpString } from '@internals/utils'
+import { ast } from '@kubb/core'
+import type { PluginFaker, ResolverFaker } from '../types.ts'
+
+/**
+ * Partial printer nodes for Faker generation, mapping schema types to output strings.
+ */
+export type PrinterFakerNodes = ast.PrinterPartial<string, PrinterFakerOptions>
+
+/**
+ * Configuration options for the Faker printer, including resolvers, mappers, and cyclic schema tracking.
+ */
+export type PrinterFakerOptions = {
+  dateParser?: PluginFaker['resolvedOptions']['dateParser']
+  regexGenerator?: PluginFaker['resolvedOptions']['regexGenerator']
+  mapper?: PluginFaker['resolvedOptions']['mapper']
+  resolver: ResolverFaker
+  typeName?: string
+  schemaName?: string
+  nestedInObject?: boolean
+  nodes?: PrinterFakerNodes
+  /**
+   * Names of schemas that participate in a circular dependency chain.
+   * Properties whose schema transitively references one of these are emitted
+   * as lazy getters so that user overrides via the `data` parameter prevent
+   * the recursive faker call from ever executing (avoiding stack overflow).
+   */
+  cyclicSchemas?: ReadonlySet<string>
+}
+
+/**
+ * Factory options for the Faker printer, defining input/output types and configuration.
+ */
+export type PrinterFakerFactory = ast.PrinterFactoryOptions<'faker', PrinterFakerOptions, string, string>
+
+const fakerKeywordMapper = {
+  any: () => 'undefined',
+  unknown: () => 'undefined',
+  void: () => 'undefined',
+  number: (min?: number, max?: number) => {
+    if (max !== undefined && min !== undefined) {
+      return `faker.number.float({ min: ${min}, max: ${max} })`
+    }
+
+    if (max !== undefined) {
+      return `faker.number.float({ max: ${max} })`
+    }
+
+    if (min !== undefined) {
+      return `faker.number.float({ min: ${min} })`
+    }
+
+    return 'faker.number.float()'
+  },
+  integer: (min?: number, max?: number) => {
+    if (max !== undefined && min !== undefined) {
+      return `faker.number.int({ min: ${min}, max: ${max} })`
+    }
+
+    if (max !== undefined) {
+      return `faker.number.int({ max: ${max} })`
+    }
+
+    if (min !== undefined) {
+      return `faker.number.int({ min: ${min} })`
+    }
+
+    return 'faker.number.int()'
+  },
+  bigint: () => 'faker.number.bigInt()',
+  string: (min?: number, max?: number) => {
+    if (max !== undefined && min !== undefined) {
+      return `faker.string.alpha({ length: { min: ${min}, max: ${max} } })`
+    }
+
+    if (max !== undefined) {
+      return `faker.string.alpha({ length: ${max} })`
+    }
+
+    if (min !== undefined) {
+      return `faker.string.alpha({ length: ${min} })`
+    }
+
+    return 'faker.string.alpha()'
+  },
+  boolean: () => 'faker.datatype.boolean()',
+  null: () => 'null',
+  array: (items: string[] = [], min?: number, max?: number) => {
+    if (items.length > 1) {
+      return `faker.helpers.arrayElements([${items.join(', ')}])`
+    }
+
+    const item = items.at(0)
+
+    if (min !== undefined && max !== undefined) {
+      return `faker.helpers.multiple(() => (${item}), { count: { min: ${min}, max: ${max} }})`
+    }
+
+    if (min !== undefined) {
+      return `faker.helpers.multiple(() => (${item}), { count: ${min} })`
+    }
+
+    if (max !== undefined) {
+      return `faker.helpers.multiple(() => (${item}), { count: { min: 0, max: ${max} }})`
+    }
+
+    return `faker.helpers.multiple(() => (${item}))`
+  },
+  tuple: (items: string[] = []) => `[${items.join(', ')}]`,
+  enum: (items: Array<string | number | boolean | undefined> = [], type = 'any') => `faker.helpers.arrayElement<${type}>([${items.join(', ')}])`,
+  union: (items: string[] = []) => `faker.helpers.arrayElement<any>([${items.join(', ')}])`,
+  datetime: () => 'faker.date.anytime().toISOString()',
+  date: (representation: 'date' | 'string' = 'string', parser: PluginFaker['resolvedOptions']['dateParser'] = 'faker') => {
+    if (representation === 'string') {
+      if (parser !== 'faker') {
+        return `${parser}(faker.date.anytime()).format("YYYY-MM-DD")`
+      }
+
+      return 'faker.date.anytime().toISOString().substring(0, 10)'
+    }
+
+    if (parser !== 'faker') {
+      throw new Error(`type '${representation}' and parser '${parser}' can not work together`)
+    }
+
+    return 'faker.date.anytime()'
+  },
+  time: (representation: 'date' | 'string' = 'string', parser: PluginFaker['resolvedOptions']['dateParser'] = 'faker') => {
+    if (representation === 'string') {
+      if (parser !== 'faker') {
+        return `${parser}(faker.date.anytime()).format("HH:mm:ss")`
+      }
+
+      return 'faker.date.anytime().toISOString().substring(11, 19)'
+    }
+
+    if (parser !== 'faker') {
+      throw new Error(`type '${representation}' and parser '${parser}' can not work together`)
+    }
+
+    return 'faker.date.anytime()'
+  },
+  uuid: () => 'faker.string.uuid()',
+  url: () => 'faker.internet.url()',
+  and: (items: string[] = []) => {
+    if (items.length === 0) {
+      return '{}'
+    }
+
+    if (items.length === 1) {
+      return items[0] ?? '{}'
+    }
+
+    return `{...${items.join(', ...')}}`
+  },
+  matches: (value = '', regexGenerator: 'faker' | 'randexp' = 'faker') => {
+    if (regexGenerator === 'randexp') {
+      return `${toRegExpString(value, 'RandExp')}.gen()`
+    }
+
+    return `faker.helpers.fromRegExp("${value}")`
+  },
+  email: () => 'faker.internet.email()',
+  blob: () => 'faker.image.url() as unknown as Blob',
+} as const
+
+function getEnumValues(node: ast.EnumSchemaNode): Array<string | number | boolean | undefined> {
+  if (node.namedEnumValues?.length) {
+    return node.namedEnumValues.map((item) => item.value as string | number | boolean | undefined)
+  }
+
+  return (node.enumValues ?? []) as Array<string | number | boolean | undefined>
+}
+
+function parseEnumValue(value: string | number | boolean | undefined) {
+  if (typeof value === 'string') {
+    return stringify(value)
+  }
+
+  return value
+}
+
+/**
+ * Creates a Faker printer that generates mock data generation code from schema nodes.
+ * Handles circular references gracefully by emitting memoizing getters for cyclic properties.
+ */
+export const printerFaker: (options: PrinterFakerOptions) => ast.Printer<PrinterFakerFactory> = ast.definePrinter<PrinterFakerFactory>((options) => {
+  const printNested = (node: ast.SchemaNode, overrideOptions: Partial<PrinterFakerOptions> = {}): string => {
+    return (
+      printerFaker({
+        ...options,
+        ...overrideOptions,
+        nodes: options.nodes,
+      }).print(node) ?? 'undefined'
+    )
+  }
+
+  return {
+    name: 'faker',
+    options,
+    nodes: {
+      any: () => fakerKeywordMapper.any(),
+      unknown: () => fakerKeywordMapper.unknown(),
+      void: () => fakerKeywordMapper.void(),
+      boolean: () => fakerKeywordMapper.boolean(),
+      null: () => fakerKeywordMapper.null(),
+      string(node) {
+        if (node.pattern) {
+          return fakerKeywordMapper.matches(node.pattern, this.options.regexGenerator)
+        }
+
+        return fakerKeywordMapper.string(node.min, node.max)
+      },
+      email: () => fakerKeywordMapper.email(),
+      url: () => fakerKeywordMapper.url(),
+      uuid: () => fakerKeywordMapper.uuid(),
+      number(node) {
+        return fakerKeywordMapper.number(node.min, node.max)
+      },
+      integer(node) {
+        return fakerKeywordMapper.integer(node.min, node.max)
+      },
+      bigint: () => fakerKeywordMapper.bigint(),
+      blob: () => fakerKeywordMapper.blob(),
+      datetime: () => fakerKeywordMapper.datetime(),
+      date(node) {
+        return fakerKeywordMapper.date(node.representation ?? 'string', this.options.dateParser)
+      },
+      time(node) {
+        return fakerKeywordMapper.time(node.representation ?? 'string', this.options.dateParser)
+      },
+      ref(node) {
+        // Parser-generated refs (with $ref) carry raw schema names that need resolving.
+        // Use the canonical name from the $ref path — node.name may have been overridden
+        // (e.g. by single-member allOf flatten using the property-derived child name).
+        // Inline refs (without $ref) from faker utils already carry resolved helper names.
+        const refName = node.ref ? (ast.extractRefName(node.ref) ?? node.name ?? node.schema?.name) : (node.name ?? node.schema?.name)
+
+        if (!refName) {
+          throw new Error('Name not defined for ref node')
+        }
+
+        if (this.options.schemaName && refName === this.options.schemaName) {
+          return 'undefined as any'
+        }
+
+        // Internal helper refs (for generated response/data helpers) are already
+        // emitted with resolver output and should not be transformed twice.
+        const resolvedName = node.ref ? this.options.resolver.resolveName(refName) : refName
+
+        if (!this.options.nestedInObject) {
+          return `${resolvedName}(data)`
+        }
+
+        return `${resolvedName}()`
+      },
+      enum(node) {
+        return fakerKeywordMapper.enum(getEnumValues(node).map(parseEnumValue), this.options.typeName)
+      },
+      union(node): string {
+        const items: string[] = (node.members ?? [])
+          .map((member) =>
+            printNested(member, {
+              nestedInObject: true,
+            }),
+          )
+          .filter((item): item is string => Boolean(item))
+
+        return fakerKeywordMapper.union(items)
+      },
+      intersection(node): string {
+        const items: string[] = (node.members ?? [])
+          .map((member) =>
+            printNested(member, {
+              nestedInObject: true,
+            }),
+          )
+          .filter((item): item is string => Boolean(item))
+
+        return fakerKeywordMapper.and(items)
+      },
+      array(node): string {
+        const items: string[] = (node.items ?? [])
+          .map((member) =>
+            printNested(member, {
+              typeName: this.options.typeName ? `NonNullable<${this.options.typeName}>[number]` : undefined,
+              nestedInObject: true,
+            }),
+          )
+          .filter((item): item is string => Boolean(item))
+
+        return fakerKeywordMapper.array(items, node.min, node.max)
+      },
+      tuple(node): string {
+        const items: string[] = (node.items ?? [])
+          .map((member, index) =>
+            printNested(member, {
+              typeName: this.options.typeName ? `NonNullable<${this.options.typeName}>[${index}]` : undefined,
+              nestedInObject: true,
+            }),
+          )
+          .filter((item): item is string => Boolean(item))
+
+        return fakerKeywordMapper.tuple(items)
+      },
+      object(node): string {
+        const cyclicSchemas = this.options.cyclicSchemas
+        const properties = (node.properties ?? [])
+          .map((property): string => {
+            if (this.options.mapper && Object.hasOwn(this.options.mapper, property.name)) {
+              return `"${property.name}": ${this.options.mapper[property.name]}`
+            }
+
+            const value: string =
+              printNested(property.schema, {
+                typeName: this.options.typeName ? `NonNullable<${this.options.typeName}>[${JSON.stringify(property.name)}]` : undefined,
+                nestedInObject: true,
+              }) ?? 'undefined'
+
+            // When the property's schema transitively references a schema that is
+            // part of a circular dependency (other than the current schema itself),
+            // emit a memoizing lazy getter. On first access it computes the value,
+            // replaces itself with a plain data property via Object.defineProperty,
+            // and returns the cached value – so every subsequent read is stable.
+            if (cyclicSchemas && ast.containsCircularRef(property.schema, { circularSchemas: cyclicSchemas, excludeName: this.options.schemaName })) {
+              return `get ${property.name}() { const _value = ${value}; Object.defineProperty(this, ${JSON.stringify(property.name)}, { value: _value, configurable: true, writable: true, enumerable: true }); return _value }`
+            }
+
+            return `"${property.name}": ${value}`
+          })
+          .join(',')
+
+        return `{${properties}}`
+      },
+      ...options.nodes,
+    },
+    print(node) {
+      return this.transform(node) ?? null
+    },
+  }
+})

package/src/resolvers/resolverFaker.ts

@@ -0,0 +1,92 @@
+import { createHash } from 'node:crypto'
+import path from 'node:path'
+import { camelCase } from '@internals/utils'
+import { defineResolver, PluginDriver } from '@kubb/core'
+import type { PluginFaker } from '../types.ts'
+
+function isValidStrictIdentifier(name: string): boolean {
+  try {
+    new Function(`"use strict"; const ${name} = 1;`)
+  } catch {
+    return false
+  }
+
+  return true
+}
+
+/**
+ * Naming convention resolver for Faker plugin.
+ *
+ * Provides default naming helpers using camelCase. Prefixes invalid identifiers with `_`.
+ *
+ * @example
+ * `resolverFaker.default('list pets', 'function')  // → 'listPets'`
+ */
+export const resolverFaker = defineResolver<PluginFaker>((ctx) => {
+  return {
+    name: 'default',
+    pluginName: 'plugin-faker',
+    default(name, type) {
+      const resolvedName = camelCase(name, { isFile: type === 'file' })
+
+      if (type === 'file' || isValidStrictIdentifier(resolvedName)) {
+        return resolvedName
+      }
+
+      return `_${resolvedName}`
+    },
+    resolveName(name, type) {
+      return ctx.default(name, type)
+    },
+    resolvePathName(name, type) {
+      return ctx.default(name, type)
+    },
+    resolveFile({ name, extname, tag, path: groupPath }, context) {
+      const pathMode = PluginDriver.getMode(path.resolve(context.root, context.output.path))
+      const baseName = `${pathMode === 'single' ? '' : ctx.resolveName(name, 'file')}${extname}` as `${string}.${string}`
+      const filePath = ctx.resolvePath(
+        {
+          baseName,
+          pathMode,
+          tag,
+          path: groupPath,
+        },
+        context,
+      )
+
+      return {
+        kind: 'File',
+        id: createHash('sha256').update(filePath).digest('hex'),
+        name: path.basename(filePath, extname),
+        path: filePath,
+        baseName,
+        extname,
+        meta: { pluginName: ctx.pluginName },
+        sources: [],
+        imports: [],
+        exports: [],
+      }
+    },
+    resolveParamName(node, param) {
+      return ctx.resolveName(`${node.operationId} ${param.in} ${param.name}`)
+    },
+    resolveDataName(node) {
+      return ctx.resolveName(`${node.operationId} Data`)
+    },
+    resolveResponseStatusName(node, statusCode) {
+      return ctx.resolveName(`${node.operationId} Status ${statusCode}`)
+    },
+    resolveResponseName(node) {
+      return ctx.resolveName(`${node.operationId} Response`)
+    },
+    resolvePathParamsName(node, param) {
+      return ctx.resolveParamName(node, param)
+    },
+    resolveQueryParamsName(node, param) {
+      return ctx.resolveParamName(node, param)
+    },
+    resolveHeaderParamsName(node, param) {
+      return ctx.resolveParamName(node, param)
+    },
+  }
+})

package/src/types.ts

@@ -1,126 +1,172 @@
-import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
+import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
+import type { PrinterFakerNodes } from './printers/printerFaker.ts'
 
-import type { contentType, Oas, SchemaObject } from '@kubb/oas'
-import type { Exclude, Include, Override, ResolvePathOptions, Schema } from '@kubb/plugin-oas'
-import type { Generator } from '@kubb/plugin-oas/generators'
+/**
+ * Resolver for Faker that provides naming methods for mock functions.
+ */
+export type ResolverFaker = Resolver &
+  ast.OperationParamsResolver & {
+    /**
+     * Resolves the faker function name for a schema.
+     *
+     * @example Resolving faker function names
+     * `resolver.resolveName('show pet by id') // -> 'showPetById'`
+     */
+    resolveName(this: ResolverFaker, name: string, type?: 'file' | 'function' | 'type' | 'const'): string
+    /**
+     * Resolves the output file name for a faker module.
+     *
+     * @example Resolving faker file names
+     * `resolver.resolvePathName('show pet by id', 'file') // -> 'showPetById'`
+     */
+    resolvePathName(this: ResolverFaker, name: string, type?: 'file' | 'function' | 'type' | 'const'): string
+    /**
+     * Resolves the faker function name for a request body.
+     *
+     * @example Resolving data function names
+     * `resolver.resolveDataName(node) // -> 'createPetsData'`
+     */
+    resolveDataName(this: ResolverFaker, node: ast.OperationNode): string
+    /**
+     * Resolves the faker function name for a response by status code.
+     *
+     * @example Response status names
+     * `resolver.resolveResponseStatusName(node, 200) // -> 'listPetsStatus200'`
+     */
+    resolveResponseStatusName(this: ResolverFaker, node: ast.OperationNode, statusCode: ast.StatusCode): string
+    /**
+     * Resolves the faker function name for the response union.
+     *
+     * @example Response union names
+     * `resolver.resolveResponseName(node) // -> 'listPetsResponse'`
+     */
+    resolveResponseName(this: ResolverFaker, node: ast.OperationNode): string
+    /**
+     * Resolves the faker function name for path parameters.
+     *
+     * @example Path parameters names
+     * `resolver.resolvePathParamsName(node, param) // -> 'showPetByIdPathPetId'`
+     */
+    resolvePathParamsName(this: ResolverFaker, node: ast.OperationNode, param: ast.ParameterNode): string
+    /**
+     * Resolves the faker function name for query parameters.
+     *
+     * @example Query parameters names
+     * `resolver.resolveQueryParamsName(node, param) // -> 'listPetsQueryLimit'`
+     */
+    resolveQueryParamsName(this: ResolverFaker, node: ast.OperationNode, param: ast.ParameterNode): string
+    /**
+     * Resolves the faker function name for header parameters.
+     *
+     * @example Header parameters names
+     * `resolver.resolveHeaderParamsName(node, param) // -> 'deletePetHeaderApiKey'`
+     */
+    resolveHeaderParamsName(this: ResolverFaker, node: ast.OperationNode, param: ast.ParameterNode): string
+  }
 
 export type Options = {
   /**
-   * Specify the export location for the files and define the behavior of the output
-   * @default { path: 'handlers', barrelType: 'named' }
-   */
-  output?: Output<Oas>
-  /**
-   * Define which contentType should be used.
-   * By default, the first JSON valid mediaType is used
+   * Specify the export location for the files and define the behavior of the output.
+   * @default { path: 'mocks', barrelType: 'named' }
    */
-  contentType?: contentType
+  output?: Output
   /**
    * Group the Faker mocks based on the provided name.
    */
   group?: Group
   /**
-   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+   * Tags, operations, or paths to exclude from generation.
    */
   exclude?: Array<Exclude>
   /**
-   * Array containing include parameters to include tags/operations/methods/paths.
+   * Tags, operations, or paths to include in generation.
    */
   include?: Array<Include>
   /**
-   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+   * Override options for specific tags, operations, or paths.
    */
   override?: Array<Override<ResolvedOptions>>
   /**
-   * Choose to use date or datetime as JavaScript Date instead of string.
-   * - 'string' represents dates as string values.
-   * - 'date' represents dates as JavaScript Date objects.
-   * @default 'string'
-   */
-  dateType?: 'string' | 'date'
-  /**
-   * Choose to use `number` or `bigint` for integer fields with `int64` format.
-   * - 'number' uses the JavaScript `number` type (matches JSON.parse() runtime behavior).
-   * - 'bigint' uses the JavaScript `bigint` type (accurate for values exceeding Number.MAX_SAFE_INTEGER).
-   * @note in v5 of Kubb 'bigint' will become the default to better align with OpenAPI's int64 specification.
-   * @default 'number'
-   */
-  integerType?: 'number' | 'bigint'
-  /**
-   * Which parser should be used when dateType is set to string.
-   * - 'faker' uses faker's built-in date formatting methods.
-   * - 'dayjs' uses dayjs for date formatting with custom patterns.
-   * - 'moment' uses moment for date formatting with custom patterns.
+   * Parser to use when formatting date/time values as strings.
+   *
    * @default 'faker'
    */
   dateParser?: 'faker' | 'dayjs' | 'moment' | (string & {})
   /**
-   * Which type to use when the Swagger/OpenAPI file is not providing more information.
-   * - 'any' allows any value.
-   * - 'unknown' requires type narrowing before use.
-   * - 'void' represents no value.
-   * @default 'any'
+   * Generator to use for RegExp patterns.
+   *
+   * @default 'faker'
    */
-  unknownType?: 'any' | 'unknown' | 'void'
+  regexGenerator?: 'faker' | 'randexp'
   /**
-   * Which type to use for empty schema values.
-   * - 'any' allows any value.
-   * - 'unknown' requires type narrowing before use.
-   * - 'void' represents no value.
-   * @default `unknownType`
+   * Provide per-property faker expressions keyed by property name.
    */
-  emptySchemaType?: 'any' | 'unknown' | 'void'
+  mapper?: Record<string, string>
   /**
-   * Choose which generator to use when using Regexp.
-   * - 'faker' uses faker.helpers.fromRegExp for generating values from regex patterns.
-   * - 'randexp' uses RandExp library for generating values from regex patterns.
-   * @default 'faker'
+   * Locale for generating mock data.
+   * Imports the matching localized `@faker-js/faker` instance so names, addresses,
+   * and phone numbers reflect the target region.
+   *
+   * @default 'en'
+   *
+   * @example German
+   * `locale: 'de'`
+   *
+   * @example Austrian German
+   * `locale: 'de_AT'`
+   *
+   * @see https://fakerjs.dev/api/localization.html
    */
-  regexGenerator?: 'faker' | 'randexp'
-
-  mapper?: Record<string, string>
+  locale?: string
   /**
-   * The use of Seed is intended to allow for consistent values in a test.
+   * Seed faker for deterministic output.
    */
   seed?: number | number[]
   /**
-   * Transform parameter names to a specific casing format.
-   * When set to 'camelcase', parameter names in path, query, and header params will be transformed to camelCase.
-   * This should match the paramsCasing setting used in @kubb/plugin-ts.
-   * @default undefined
+   * Apply casing to parameter names to match your configuration.
    */
   paramsCasing?: 'camelcase'
-  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 baseName(propertyName) and return FakerMeta array
-     * TODO TODO add docs
-     * @beta
-     */
-    schema?: (props: { schema: SchemaObject | null; name: string | null; parentName: string | null }, defaultSchemas: Schema[]) => Schema[] | undefined
-  }
   /**
-   * Define some generators next to the faker generators
+   * Additional generators alongside the default generators.
    */
   generators?: Array<Generator<PluginFaker>>
+  /**
+   * Override naming conventions for function names and types.
+   */
+  resolver?: Partial<ResolverFaker> & ThisType<ResolverFaker>
+  /**
+   * AST visitor to transform generated nodes.
+   */
+  transformer?: ast.Visitor
+  /**
+   * Override individual faker printer node handlers.
+   */
+  printer?: {
+    nodes?: PrinterFakerNodes
+  }
 }
 
 type ResolvedOptions = {
-  output: Output<Oas>
-  group: Options['group']
+  output: Output
+  group: Group | undefined
+  exclude: NonNullable<Options['exclude']>
+  include: Options['include']
   override: NonNullable<Options['override']>
-  dateType: NonNullable<Options['dateType']>
-  integerType: NonNullable<Options['integerType']>
   dateParser: NonNullable<Options['dateParser']>
-  unknownType: NonNullable<Options['unknownType']>
-  emptySchemaType: NonNullable<Options['emptySchemaType']>
-  transformers: NonNullable<Options['transformers']>
-  seed: NonNullable<Options['seed']> | undefined
-  mapper: NonNullable<Options['mapper']>
   regexGenerator: NonNullable<Options['regexGenerator']>
+  mapper: NonNullable<Options['mapper']>
+  seed: NonNullable<Options['seed']> | undefined
+  locale: Options['locale']
   paramsCasing: Options['paramsCasing']
+  printer: Options['printer']
+}
+
+export type PluginFaker = PluginFactoryOptions<'plugin-faker', Options, ResolvedOptions, ResolverFaker>
+
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-faker': PluginFaker
+    }
+  }
 }
-export type PluginFaker = PluginFactoryOptions<'plugin-faker', Options, ResolvedOptions, never, ResolvePathOptions>