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

package/src/components/Faker.tsx

@@ -1,107 +1,153 @@
 import { jsStringEscape } from '@internals/utils'
-import type { Schema } from '@kubb/plugin-oas'
-import { isKeyword, schemaKeywords } from '@kubb/plugin-oas'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
-import * as parserFaker from '../parser.ts'
+import { ast } from '@kubb/core'
+import { functionPrinter } from '@kubb/plugin-ts'
+import { File, Function } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
+import type { PrinterFakerFactory } from '../printers/printerFaker.ts'
 import type { PluginFaker } from '../types.ts'
+import { resolveFakerTypeUsage } from '../utils.ts'
 
 type Props = {
   name: string
   typeName: string
-  tree: Array<Schema>
+  node: ast.SchemaNode
+  printer: ast.Printer<PrinterFakerFactory>
   seed?: PluginFaker['options']['seed']
   description?: string
-  regexGenerator?: PluginFaker['options']['regexGenerator']
-  mapper?: PluginFaker['options']['mapper']
-  dateParser?: PluginFaker['options']['dateParser']
   canOverride: boolean
 }
 
-export function Faker({ tree, description, name, typeName, seed, regexGenerator, canOverride, mapper, dateParser }: Props): FabricReactNode {
-  const fakerText = parserFaker.joinItems(
-    tree
-      .map((schema, _index, siblings) =>
-        parserFaker.parse(
-          { name, schema, parent: undefined, current: schema, siblings },
-          {
-            typeName,
-            rootTypeName: name,
-            regexGenerator,
-            mapper,
-            canOverride,
-            dateParser,
-          },
-        ),
-      )
-      .filter((x): x is string => Boolean(x)),
-  )
-
-  const isArray = fakerText.startsWith('faker.helpers.arrayElements') || fakerText.startsWith('faker.helpers.multiple')
-  const isRefToArray = tree.some((s) => isKeyword(s, schemaKeywords.schema) && s.args.type === 'array')
-  const isObject = fakerText.startsWith('{')
-  const isTuple = fakerText.startsWith('faker.helpers.arrayElement')
-
-  const isSimpleString = name === 'string'
-  const isSimpleInt = name === 'integer'
-  const isSimpleFloat = name === 'float'
+const OBJECT_TYPES = new Set<ast.SchemaNode['type']>(['object', 'intersection'])
+const ARRAY_TYPES = new Set<ast.SchemaNode['type']>(['array'])
+const SCALAR_TYPES = new Set<ast.SchemaNode['type']>([
+  'string',
+  'email',
+  'url',
+  'uuid',
+  'number',
+  'integer',
+  'bigint',
+  'boolean',
+  'date',
+  'time',
+  'datetime',
+  'blob',
+  'enum',
+])
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
+
+export function Faker({ node, description, name, typeName, printer, seed, canOverride }: Props): KubbReactNode {
+  const fakerText = printer.print(node) ?? 'undefined'
+
+  const isArray = ARRAY_TYPES.has(node.type)
+  const isObject = OBJECT_TYPES.has(node.type)
+  const isTuple = node.type === 'tuple'
+  const isScalar = SCALAR_TYPES.has(node.type)
 
   let fakerTextWithOverride = fakerText
+  let useGenericOverride = false
 
   if (canOverride && isObject) {
-    fakerTextWithOverride = `{
-  ...${fakerText},
-  ...data || {}
-}`
+    useGenericOverride = true
   }
 
-  if (canOverride && isTuple) fakerTextWithOverride = `data || ${fakerText}`
+  if (canOverride && isTuple) {
+    fakerTextWithOverride = `data || ${fakerText}`
+  }
 
   if (canOverride && isArray) {
     fakerTextWithOverride = `[
-      ...${fakerText},
-      ...data || []
-    ]`
+  ...${fakerText},
+  ...(data || [])
+]`
   }
 
-  if (canOverride && isSimpleString) fakerTextWithOverride = 'data ?? faker.string.alpha()'
-
-  if (canOverride && isSimpleInt) fakerTextWithOverride = 'data ?? faker.number.int()'
-
-  if (canOverride && isSimpleFloat) fakerTextWithOverride = 'data ?? faker.number.float()'
-
-  let type = `Partial<${typeName}>`
-
-  if (isArray) type = typeName
-  if (isRefToArray) type = typeName
-  if (isSimpleString) type = name
-  if (isSimpleInt || isSimpleFloat) type = 'number'
-
-  const params = FunctionParams.factory({
-    data: {
-      // making a partial out of an array does not make sense
-      type,
-      optional: true,
-    },
-  })
-
-  let returnType = canOverride ? typeName : undefined
+  if (canOverride && isScalar) {
+    fakerTextWithOverride = `data ?? ${fakerText}`
+  }
 
-  if (isSimpleString || isSimpleInt || isSimpleFloat) returnType = type
+  const { dataType, returnType: resolvedReturnType } = resolveFakerTypeUsage(node, typeName, canOverride)
+
+  let functionSignature = ''
+  let functionBody = ''
+
+  if (useGenericOverride) {
+    // Generate function with defaultFakeData structure
+    const jsdoc = description ? `/**\n   * @description ${jsStringEscape(description)}\n   */\n  ` : ''
+    functionSignature = `${jsdoc}export function ${name}(data?: Partial<${typeName}>): Required<${typeName}>`
+
+    const seedCode = seed ? `faker.seed(${JSON.stringify(seed)})\n  ` : ''
+
+    // When the object node has properties that transitively reference a cyclic schema,
+    // the printer emits memoizing getters for those properties. Spreading the object
+    // literal would immediately invoke those getters, triggering recursive faker calls
+    // and causing a stack overflow. Detect this upfront via ast helpers so we can
+    // use Object.defineProperty-based merging instead of spread.
+    const { cyclicSchemas, schemaName } = printer.options
+    const hasGetters =
+      node.type === 'object' &&
+      !!cyclicSchemas &&
+      (node.properties ?? []).some((p) => ast.containsCircularRef(p.schema, { circularSchemas: cyclicSchemas, excludeName: schemaName }))
+
+    if (hasGetters) {
+      functionBody = `{
+  ${seedCode}const defaultFakeData = ${fakerText}
+  if (data) {
+    for (const [key, value] of Object.entries(data)) {
+      Object.defineProperty(defaultFakeData, key, { value, configurable: true, writable: true, enumerable: true })
+    }
+  }
+  return defaultFakeData as Required<${typeName}>
+}`
+    } else {
+      functionBody = `{
+  ${seedCode}const defaultFakeData = ${fakerText}
+  return {
+    ...defaultFakeData,
+    ...(data || {}),
+  } as Required<${typeName}>
+}`
+    }
+  } else {
+    const usesData = /\bdata\b/.test(fakerTextWithOverride)
+    const dataParamName = usesData ? 'data' : '_data'
+    const params = ast.createFunctionParameters({
+      params: [
+        ast.createFunctionParameter({
+          name: dataParamName,
+          type: ast.createParamsType({ variant: 'reference', name: dataType }),
+          optional: true,
+        }),
+      ],
+    })
+    const paramsSignature = declarationPrinter.print(params) ?? ''
+    const returnType = resolvedReturnType
+
+    return (
+      <File.Source name={name} isExportable isIndexable>
+        <Function
+          export
+          name={name}
+          JSDoc={{ comments: description ? [`@description ${jsStringEscape(description)}`] : [] }}
+          params={canOverride ? paramsSignature : undefined}
+          returnType={returnType}
+        >
+          {seed ? (
+            <>
+              {`faker.seed(${JSON.stringify(seed)})`}
+              <br />
+            </>
+          ) : undefined}
+          {`return ${fakerTextWithOverride}`}
+        </Function>
+      </File.Source>
+    )
+  }
 
   return (
     <File.Source name={name} isExportable isIndexable>
-      <Function
-        export
-        name={name}
-        JSDoc={{ comments: [description ? `@description ${jsStringEscape(description)}` : undefined].filter(Boolean) }}
-        params={canOverride ? params.toConstructor() : undefined}
-        returnType={returnType}
-      >
-        {seed ? `faker.seed(${JSON.stringify(seed)})` : undefined}
-        <br />
-        {`return ${fakerTextWithOverride}`}
-      </Function>
+      {functionSignature}
+      {functionBody}
     </File.Source>
   )
 }

package/src/generators/fakerGenerator.tsx

@@ -1,87 +1,221 @@
-import { useMode, usePluginDriver } 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 { applyParamsCasing, getBanner, getFooter, getImports, isParameterSchema } from '@kubb/plugin-oas/utils'
+import { aliasConflictingImports, filterUsedImports, rewriteAliasedImports } from '@internals/utils'
+import { ast, defineGenerator } from '@kubb/core'
 import { pluginTsName } from '@kubb/plugin-ts'
-import { File } from '@kubb/react-fabric'
-import { Faker } from '../components'
-import type { PluginFaker } from '../types'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
+import { Faker } from '../components/Faker.tsx'
+import { printerFaker } from '../printers/printerFaker.ts'
+import type { PluginFaker } from '../types.ts'
+import {
+  buildResponseUnionSchema,
+  canOverrideSchema,
+  localeToFakerImport,
+  resolveParamNameByLocation,
+  resolveSchemaRef,
+  resolveTypeReference,
+} from '../utils.ts'
 
-export const fakerGenerator = createReactGenerator<PluginFaker>({
+export const fakerGenerator = defineGenerator<PluginFaker>({
   name: 'faker',
-  Operation({ operation, generator, plugin }) {
-    const {
-      options,
-      options: { dateParser, regexGenerator, seed, mapper },
-    } = plugin
-    const mode = useMode()
-    const driver = usePluginDriver()
+  renderer: jsxRenderer,
+  schema(node, ctx) {
+    const { adapter, config, resolver, root } = ctx
+    const { output, group, dateParser, regexGenerator, mapper, seed, locale, printer } = ctx.options
+    const pluginTs = ctx.driver.getPlugin(pluginTsName)
 
-    const oas = useOas()
-    const { getSchemas, getFile, getGroup } = useOperationManager(generator)
-    const schemaManager = useSchemaManager()
+    if (!node.name || !pluginTs || !adapter.inputNode) {
+      return
+    }
+
+    const tsResolver = ctx.driver.getResolver(pluginTsName)
 
-    const file = getFile(operation)
-    const schemas = getSchemas(operation)
-    const schemaGenerator = new SchemaGenerator(options, {
-      fabric: generator.context.fabric,
-      oas,
-      plugin,
-      events: generator.context.events,
-      driver,
-      mode,
-      override: options.override,
+    const schemaNode = resolveSchemaRef(node, adapter.inputNode.schemas)
+    const schemaName = schemaNode.name ?? node.name
+    const mode = ctx.getMode(output)
+    const meta = {
+      name: resolver.resolveName(schemaName),
+      file: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }),
+      typeName: tsResolver.resolveTypeName(schemaName),
+      typeFile: tsResolver.resolveFile(
+        { name: schemaName, extname: '.ts' },
+        { root, output: pluginTs.options?.output ?? output, group: pluginTs.options?.group },
+      ),
+    } as const
+    const canOverride = canOverrideSchema(schemaNode)
+    const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : undefined
+    const printerInstance = printerFaker({
+      resolver,
+      schemaName,
+      typeName: meta.typeName,
+      dateParser,
+      regexGenerator,
+      mapper,
+      nodes: printer?.nodes,
+      cyclicSchemas,
+    })
+    const fakerText = printerInstance.print(schemaNode) ?? 'undefined'
+    const typeReference = resolveTypeReference({
+      node: schemaNode,
+      canOverride,
+      name: meta.name,
+      typeName: meta.typeName,
+      filePath: meta.file.path,
+      typeFilePath: meta.typeFile.path,
     })
 
-    const operationSchemas = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response]
-      .flat()
-      .filter((x): x is OperationSchemaType => Boolean(x))
+    const imports = adapter
+      .getImports(schemaNode, (schemaName) => ({
+        name: resolver.resolveName(schemaName),
+        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+      }))
+      .filter((entry) => entry.path !== meta.file.path)
+    const usedImports = filterUsedImports(imports, fakerText)
 
-    const mapOperationSchema = ({ name, schema, description, ...options }: OperationSchemaType) => {
-      // Apply paramsCasing transformation if enabled and this is a parameter schema
-      const shouldTransform = isParameterSchema(name) && plugin.options.paramsCasing
-      const transformedSchema = shouldTransform ? applyParamsCasing(schema, plugin.options.paramsCasing) : schema
+    return (
+      <File
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+      >
+        <File.Import name={locale ? [{ propertyName: localeToFakerImport(locale), name: 'faker' }] : ['faker']} path="@faker-js/faker" />
+        {regexGenerator === 'randexp' && <File.Import name={'RandExp'} path={'randexp'} />}
+        {dateParser !== 'faker' && <File.Import path={dateParser} name={dateParser} />}
+        {typeReference.importPath && <File.Import isTypeOnly root={meta.file.path} path={typeReference.importPath} name={[meta.typeName]} />}
+        {mode === 'split' &&
+          usedImports.map((imp) => <File.Import key={[schemaName, imp.path, imp.name].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
+        <Faker
+          name={meta.name}
+          typeName={typeReference.typeName}
+          description={schemaNode.description}
+          node={schemaNode}
+          printer={printerInstance}
+          seed={seed}
+          canOverride={canOverride}
+        />
+      </File>
+    )
+  },
+  operation(node, ctx) {
+    const { adapter, config, resolver, root } = ctx
+    const { output, group, paramsCasing, dateParser, regexGenerator, mapper, seed, locale, printer } = ctx.options
+    const pluginTs = ctx.driver.getPlugin(pluginTsName)
+
+    if (!pluginTs) {
+      return
+    }
 
-      const tree = schemaGenerator.parse({ schema: transformedSchema, name, parentName: null })
-      const imports = getImports(tree)
-      const group = options.operation ? getGroup(options.operation) : undefined
+    const tsResolver = ctx.driver.getResolver(pluginTsName)
 
-      const faker = {
-        name: schemaManager.getName(name, { type: 'function' }),
-        file: schemaManager.getFile(name),
-      }
+    const params = ast.caseParams(node.parameters, paramsCasing)
+    const paramEntries = params.map((param) => ({
+      param,
+      name: resolveParamNameByLocation(resolver, node, param),
+      typeName: resolveParamNameByLocation(tsResolver, node, param),
+    }))
+    const responseEntries = node.responses.map((response) => ({
+      response,
+      name: resolver.resolveResponseStatusName(node, response.statusCode),
+      typeName: tsResolver.resolveResponseStatusName(node, response.statusCode),
+    }))
+    const dataEntry = node.requestBody?.content?.[0]?.schema
+      ? {
+          schema: {
+            ...node.requestBody.content![0]!.schema!,
+            description: node.requestBody.description ?? node.requestBody.content![0]!.schema!.description,
+          },
+          name: resolver.resolveDataName(node),
+          typeName: tsResolver.resolveDataName(node),
+          description: node.requestBody.description ?? node.requestBody.content![0]!.schema!.description,
+        }
+      : null
+    const responseName = resolver.resolveResponseName(node)
+    const localHelperNames = new Set([
+      ...paramEntries.map((entry) => entry.name),
+      ...responseEntries.map((entry) => entry.name),
+      ...(dataEntry ? [dataEntry.name] : []),
+      responseName,
+    ])
+    const meta = {
+      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
+      typeFile: tsResolver.resolveFile(
+        {
+          name: node.operationId,
+          extname: '.ts',
+          tag: node.tags[0] ?? 'default',
+          path: node.path,
+        },
+        {
+          root,
+          output: pluginTs.options?.output ?? output,
+          group: pluginTs.options?.group,
+        },
+      ),
+    } as const
 
-      const type = {
-        name: schemaManager.getName(name, { type: 'type', pluginName: pluginTsName }),
-        file: schemaManager.getFile(options.operationName || name, { pluginName: pluginTsName, group }),
+    function resolveMockImports(schema: ast.SchemaNode) {
+      return adapter
+        .getImports(schema, (schemaName) => ({
+          name: resolver.resolveName(schemaName),
+          path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+        }))
+        .filter((entry) => entry.path !== meta.file.path)
+    }
+
+    function renderEntry({
+      schema,
+      name,
+      typeName,
+      description,
+      skipImportNames = [],
+    }: {
+      schema: ast.SchemaNode | null
+      name: string
+      typeName: string
+      description?: string
+      skipImportNames?: Array<string>
+    }) {
+      if (!schema) {
+        return null
       }
 
-      const canOverride = tree.some(
-        ({ keyword }) =>
-          keyword === schemaKeywords.array ||
-          keyword === schemaKeywords.and ||
-          keyword === schemaKeywords.object ||
-          keyword === schemaKeywords.union ||
-          keyword === schemaKeywords.tuple ||
-          keyword === schemaKeywords.enum ||
-          keyword === schemaKeywords.ref,
-      )
+      const canOverride = canOverrideSchema(schema)
+      const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : undefined
+      const printerInstance = printerFaker({
+        resolver,
+        schemaName: name,
+        typeName,
+        dateParser,
+        regexGenerator,
+        mapper,
+        nodes: printer?.nodes,
+        cyclicSchemas,
+      })
+      const fakerText = printerInstance.print(schema) ?? 'undefined'
+      const usedImports = filterUsedImports(resolveMockImports(schema), fakerText, skipImportNames)
+      const { imports, aliases } = aliasConflictingImports(usedImports, localHelperNames)
+      const rewrittenFakerText = rewriteAliasedImports(fakerText, aliases)
+      const typeReference = resolveTypeReference({
+        node: schema,
+        canOverride,
+        name,
+        typeName,
+        filePath: meta.file.path,
+        typeFilePath: meta.typeFile.path,
+      })
 
       return (
         <>
-          {canOverride && <File.Import isTypeOnly root={file.path} path={type.file.path} name={[type.name]} />}
+          {typeReference.importPath && <File.Import isTypeOnly root={meta.file.path} path={typeReference.importPath} name={[typeName]} />}
           {imports.map((imp) => (
-            <File.Import key={[imp.path, imp.name, imp.isTypeOnly].join('-')} root={file.path} path={imp.path} name={imp.name} />
+            <File.Import key={[name, imp.path, imp.name].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />
           ))}
           <Faker
-            name={faker.name}
-            typeName={type.name}
+            name={name}
+            typeName={typeReference.typeName}
             description={description}
-            tree={tree}
-            regexGenerator={regexGenerator}
-            dateParser={dateParser}
-            mapper={mapper}
+            node={schema}
+            printer={{ ...printerInstance, print: () => rewrittenFakerText }}
             seed={seed}
             canOverride={canOverride}
           />
@@ -91,79 +225,44 @@ export const fakerGenerator = createReactGenerator<PluginFaker>({
 
     return (
       <File
-        baseName={file.baseName}
-        path={file.path}
-        meta={file.meta}
-        banner={getBanner({ oas, output: plugin.options.output, config: driver.config })}
-        footer={getFooter({ oas, output: plugin.options.output })}
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
       >
-        <File.Import name={['faker']} path="@faker-js/faker" />
+        <File.Import name={locale ? [{ propertyName: localeToFakerImport(locale), name: 'faker' }] : ['faker']} path="@faker-js/faker" />
         {regexGenerator === 'randexp' && <File.Import name={'RandExp'} path={'randexp'} />}
         {dateParser !== 'faker' && <File.Import path={dateParser} name={dateParser} />}
-        {operationSchemas.map(mapOperationSchema)}
-      </File>
-    )
-  },
-  Schema({ schema, plugin }) {
-    const { getName, getFile } = useSchemaManager()
-    const {
-      options: { output, dateParser, regexGenerator, seed, mapper },
-    } = plugin
-    const driver = usePluginDriver()
-    const oas = useOas()
-    const imports = getImports(schema.tree)
-
-    const faker = {
-      name: getName(schema.name, { type: 'function' }),
-      file: getFile(schema.name),
-    }
-
-    const type = {
-      name: getName(schema.name, { type: 'type', pluginName: pluginTsName }),
-      file: getFile(schema.name, { pluginName: pluginTsName }),
-    }
-
-    const canOverride = schema.tree.some(
-      ({ keyword }) =>
-        keyword === schemaKeywords.array ||
-        keyword === schemaKeywords.and ||
-        keyword === schemaKeywords.object ||
-        keyword === schemaKeywords.union ||
-        keyword === schemaKeywords.tuple ||
-        keyword === schemaKeywords.ref ||
-        keyword === schemaKeywords.enum ||
-        keyword === schemaKeywords.string ||
-        keyword === schemaKeywords.integer ||
-        keyword === schemaKeywords.number,
-    )
-
-    return (
-      <File
-        baseName={faker.file.baseName}
-        path={faker.file.path}
-        meta={faker.file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
-      >
-        <File.Import name={['faker']} path="@faker-js/faker" />
-        {regexGenerator === 'randexp' && <File.Import name={'RandExp'} path={'randexp'} />}
-        {dateParser !== 'faker' && <File.Import path={dateParser} name={dateParser} />}
-        <File.Import isTypeOnly root={faker.file.path} path={type.file.path} name={[type.name]} />
-        {imports.map((imp) => (
-          <File.Import key={[imp.path, imp.name, imp.isTypeOnly].join('-')} root={faker.file.path} path={imp.path} name={imp.name} />
-        ))}
-
-        <Faker
-          name={faker.name}
-          typeName={type.name}
-          description={schema.value.description}
-          tree={schema.tree}
-          regexGenerator={regexGenerator}
-          dateParser={dateParser}
-          mapper={mapper}
-          seed={seed}
-          canOverride={canOverride}
-        />
+        {paramEntries.map(({ param, name, typeName }) =>
+          renderEntry({
+            schema: param.schema,
+            name,
+            typeName,
+          }),
+        )}
+        {responseEntries.map(({ response, name, typeName }) =>
+          renderEntry({
+            schema: response.schema,
+            name,
+            typeName,
+            description: response.description,
+          }),
+        )}
+        {dataEntry
+          ? renderEntry({
+              schema: dataEntry.schema,
+              name: dataEntry.name,
+              typeName: dataEntry.typeName,
+              description: dataEntry.description,
+            })
+          : null}
+        {renderEntry({
+          schema: buildResponseUnionSchema(node, resolver),
+          name: responseName,
+          typeName: tsResolver.resolveResponseName(node),
+          skipImportNames: responseEntries.map(({ name }) => name),
+        })}
       </File>
     )
   },

package/src/index.ts

@@ -1,2 +1,7 @@
-export { pluginFaker, pluginFakerName } from './plugin.ts'
-export type { PluginFaker } from './types.ts'
+export { Faker } from './components/Faker.tsx'
+export { fakerGenerator } from './generators/fakerGenerator.tsx'
+export { default, pluginFaker, pluginFakerName } from './plugin.ts'
+export type { PrinterFakerFactory, PrinterFakerNodes, PrinterFakerOptions } from './printers/printerFaker.ts'
+export { printerFaker } from './printers/printerFaker.ts'
+export { resolverFaker } from './resolvers/resolverFaker.ts'
+export type { PluginFaker, ResolverFaker } from './types.ts'