@kubb/plugin-zod 5.0.0-alpha.9 → 5.0.0-beta.100

package/dist/types-CoCoOc2u.d.ts

@@ -1,172 +0,0 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { Group, Output, PluginFactoryOptions, ResolveNameParams } from "@kubb/core";
-import { Exclude, Include, Override, ResolvePathOptions, Schema } from "@kubb/plugin-oas";
-import { Generator as Generator$1 } from "@kubb/plugin-oas/generators";
-import { Oas, SchemaObject, contentType } from "@kubb/oas";
-
-//#region src/types.d.ts
-type Options = {
-  /**
-   * @default 'zod'
-   */
-  output?: Output<Oas>;
-  /**
-   * Define which contentType should be used.
-   * By default, the first JSON valid mediaType is used
-   */
-  contentType?: contentType;
-  /**
-   * Group the Zod schemas based on the provided name.
-   */
-  group?: Group;
-  /**
-   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
-   */
-  exclude?: Array<Exclude>;
-  /**
-   * Array containing include parameters to include tags/operations/methods/paths.
-   */
-  include?: Array<Include>;
-  /**
-   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
-   */
-  override?: Array<Override<ResolvedOptions>>;
-  /**
-   * Path to Zod
-   * It used as `import { z } from '${importPath}'`.
-   * Accepts relative and absolute paths.
-   * Path is used as-is; relative paths are based on the generated file location.
-   * @default 'zod'
-   */
-  importPath?: string;
-  /**
-   * Choose to use date or datetime as JavaScript Date instead of string.
-   * - false falls back to a simple z.string() format.
-   * - 'string' uses z.string().datetime() for datetime validation.
-   * - 'stringOffset' uses z.string().datetime({ offset: true }) for datetime with timezone offset validation.
-   * - 'stringLocal' uses z.string().datetime({ local: true }) for local datetime validation.
-   * - 'date' uses z.date() for JavaScript Date objects.
-   * @default 'string'
-   * @note 'stringOffset' will become the default in Kubb v3.
-   */
-  dateType?: false | 'string' | 'stringOffset' | 'stringLocal' | '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 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'
-   */
-  unknownType?: 'any' | 'unknown' | 'void';
-  /**
-   * Which type to use for empty schema values.
-   * - 'any' allows any value.
-   * - 'unknown' requires type narrowing before use.
-   * - 'void' represents no value.
-   * @default `unknownType`
-   */
-  emptySchemaType?: 'any' | 'unknown' | 'void';
-  /**
-   * Use TypeScript(`@kubb/plugin-ts`) to add type annotation.
-   */
-  typed?: boolean;
-  /**
-   * Return Zod generated schema as type with z.infer<TYPE>
-   */
-  inferred?: boolean;
-  /**
-   * Use of z.coerce.string() instead of z.string()
-   * can also be an object to enable coercion for dates, strings, and numbers
-   */
-  coercion?: boolean | {
-    dates?: boolean;
-    strings?: boolean;
-    numbers?: boolean;
-  };
-  operations?: boolean;
-  mapper?: Record<string, string>;
-  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;
-  };
-  /**
-   * Which version of Zod should be used.
-   * - '3' uses Zod v3.x syntax and features.
-   * - '4' uses Zod v4.x syntax and features.
-   * @default '3'
-   */
-  version?: '3' | '4';
-  /**
-   * Which Zod GUID validator to use for OpenAPI `format: uuid`.
-   * - 'uuid' uses UUID validation.
-   * - 'guid' uses GUID validation (Zod v4 only).
-   * @default 'uuid'
-   */
-  guidType?: 'uuid' | 'guid';
-  /**
-   * Use Zod Mini's functional API for better tree-shaking support.
-   * When enabled, generates functional syntax (e.g., `z.optional(z.string())`) instead of chainable methods (e.g., `z.string().optional()`).
-   * Requires Zod v4 or later. When `mini: true`, `version` is set to '4' and `importPath` will default to 'zod/mini'.
-   * @default false
-   */
-  mini?: boolean;
-  /**
-   * Callback function to wrap the output of the generated zod schema
-   *
-   * This is useful for edge case scenarios where you might leverage something like `z.object({ ... }).openapi({ example: { some: "complex-example" }})`
-   * or `extendApi(z.object({ ... }), { example: { some: "complex-example", ...otherOpenApiProperties }})`
-   * while going from openapi -> zod -> openapi
-   */
-  wrapOutput?: (arg: {
-    output: string;
-    schema: SchemaObject;
-  }) => string | undefined;
-  /**
-   * Define some generators next to the zod generators
-   */
-  generators?: Array<Generator$1<PluginZod>>;
-};
-type ResolvedOptions = {
-  output: Output<Oas>;
-  group: Options['group'];
-  override: NonNullable<Options['override']>;
-  transformers: NonNullable<Options['transformers']>;
-  dateType: NonNullable<Options['dateType']>;
-  integerType: NonNullable<Options['integerType']>;
-  unknownType: NonNullable<Options['unknownType']>;
-  emptySchemaType: NonNullable<Options['emptySchemaType']>;
-  typed: NonNullable<Options['typed']>;
-  inferred: NonNullable<Options['inferred']>;
-  mapper: NonNullable<Options['mapper']>;
-  importPath: NonNullable<Options['importPath']>;
-  coercion: NonNullable<Options['coercion']>;
-  operations: NonNullable<Options['operations']>;
-  wrapOutput: Options['wrapOutput'];
-  version: NonNullable<Options['version']>;
-  guidType: NonNullable<Options['guidType']>;
-  mini: NonNullable<Options['mini']>;
-};
-type PluginZod = PluginFactoryOptions<'plugin-zod', Options, ResolvedOptions, never, ResolvePathOptions>;
-//#endregion
-export { PluginZod as n, Options as t };
-//# sourceMappingURL=types-CoCoOc2u.d.ts.map

package/src/components/Operations.tsx

@@ -1,70 +0,0 @@
-import { stringifyObject } from '@internals/utils'
-import type { HttpMethod, Operation } from '@kubb/oas'
-import type { SchemaNames } from '@kubb/plugin-oas/hooks'
-import { Const, File, Type } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
-
-type Props = {
-  name: string
-  operations: Array<{ operation: Operation; data: SchemaNames }>
-}
-
-export function Operations({ name, operations }: Props): FabricReactNode {
-  const operationsJSON = operations.reduce(
-    (prev, acc) => {
-      prev[`"${acc.operation.getOperationId()}"`] = acc.data
-
-      return prev
-    },
-    {} as Record<string, unknown>,
-  )
-
-  const pathsJSON = operations.reduce(
-    (prev, acc) => {
-      prev[`"${acc.operation.path}"`] = {
-        ...(prev[`"${acc.operation.path}"`] || ({} as Record<HttpMethod, string>)),
-        [acc.operation.method]: `operations["${acc.operation.getOperationId()}"]`,
-      }
-
-      return prev
-    },
-    {} as Record<string, Record<HttpMethod, string>>,
-  )
-
-  return (
-    <>
-      <File.Source name="OperationSchema" isExportable isIndexable>
-        <Type name="OperationSchema" export>{`{
-  readonly request: z.ZodTypeAny | undefined;
-  readonly parameters: {
-        readonly path: z.ZodTypeAny | undefined;
-        readonly query: z.ZodTypeAny | undefined;
-        readonly header: z.ZodTypeAny | undefined;
-  };
-  readonly responses: {
-        readonly [status: number]: z.ZodTypeAny;
-        readonly default: z.ZodTypeAny;
-  };
-  readonly errors: {
-        readonly [status: number]: z.ZodTypeAny;
-  };
-}`}</Type>
-      </File.Source>
-      <File.Source name="OperationsMap" isExportable isIndexable>
-        <Type name="OperationsMap" export>
-          {'Record<string, OperationSchema>'}
-        </Type>
-      </File.Source>
-      <File.Source name={name} isExportable isIndexable>
-        <Const export name={name} asConst>
-          {`{${stringifyObject(operationsJSON)}}`}
-        </Const>
-      </File.Source>
-      <File.Source name={'paths'} isExportable isIndexable>
-        <Const export name={'paths'} asConst>
-          {`{${stringifyObject(pathsJSON)}}`}
-        </Const>
-      </File.Source>
-    </>
-  )
-}

package/src/components/Zod.tsx

@@ -1,142 +0,0 @@
-import { jsStringEscape } from '@internals/utils'
-import type { SchemaObject } from '@kubb/oas'
-import { isKeyword, type Schema, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
-import { Const, File, Type } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
-import * as parserZod from '../parser.ts'
-import type { PluginZod } from '../types.ts'
-
-type Props = {
-  name: string
-  typeName?: string
-  inferTypeName?: string
-  tree: Array<Schema>
-  schema: SchemaObject
-  description?: string
-  coercion: PluginZod['resolvedOptions']['coercion']
-  mapper: PluginZod['resolvedOptions']['mapper']
-  keysToOmit?: string[]
-  wrapOutput?: PluginZod['resolvedOptions']['wrapOutput']
-  version: '3' | '4'
-  guidType: PluginZod['resolvedOptions']['guidType']
-  emptySchemaType: PluginZod['resolvedOptions']['emptySchemaType']
-  mini?: boolean
-}
-
-export function Zod({
-  name,
-  typeName,
-  tree,
-  schema,
-  inferTypeName,
-  mapper,
-  coercion,
-  keysToOmit,
-  description,
-  wrapOutput,
-  version,
-  guidType,
-  emptySchemaType,
-  mini = false,
-}: Props): FabricReactNode {
-  const hasTuple = !!SchemaGenerator.find(tree, schemaKeywords.tuple)
-
-  const schemas = parserZod.sort(tree).filter((item) => {
-    if (hasTuple && (isKeyword(item, schemaKeywords.min) || isKeyword(item, schemaKeywords.max))) {
-      return false
-    }
-
-    return true
-  })
-
-  // In mini mode, filter out modifiers from the main schema parsing
-  const baseSchemas = mini ? parserZod.filterMiniModifiers(schemas) : schemas
-
-  const output = baseSchemas
-    .map((schemaKeyword, index) => {
-      const siblings = baseSchemas.filter((_, i) => i !== index)
-
-      return parserZod.parse({ schema, parent: undefined, current: schemaKeyword, siblings, name }, { mapper, coercion, wrapOutput, version, guidType, mini })
-    })
-    .filter(Boolean)
-    .join('')
-
-  let suffix = ''
-  const firstSchema = schemas.at(0)
-  const lastSchema = schemas.at(-1)
-
-  if (!mini && lastSchema && isKeyword(lastSchema, schemaKeywords.nullable)) {
-    if (firstSchema && isKeyword(firstSchema, schemaKeywords.ref)) {
-      if (version === '3') {
-        suffix = '.unwrap().schema.unwrap()'
-      } else {
-        suffix = '.unwrap().unwrap()'
-      }
-    } else {
-      suffix = '.unwrap()'
-    }
-  } else if (!mini) {
-    if (firstSchema && isKeyword(firstSchema, schemaKeywords.ref)) {
-      if (version === '3') {
-        suffix = '.schema'
-      } else {
-        suffix = '.unwrap()'
-      }
-    }
-  }
-
-  const emptyValue = parserZod.parse(
-    {
-      schema,
-      parent: undefined,
-      current: {
-        keyword: schemaKeywords[emptySchemaType],
-      },
-      siblings: [],
-    },
-    { mapper, coercion, wrapOutput, version, guidType, mini },
-  )
-
-  let baseSchemaOutput =
-    [output, keysToOmit?.length ? `${suffix}.omit({ ${keysToOmit.map((key) => `'${key}': true`).join(',')} })` : undefined].filter(Boolean).join('') ||
-    emptyValue ||
-    ''
-
-  // For mini mode, wrap the output with modifiers using the parser function
-  if (mini) {
-    baseSchemaOutput = parserZod.wrapWithMiniModifiers(baseSchemaOutput, parserZod.extractMiniModifiers(schemas))
-  }
-
-  const wrappedSchemaOutput = wrapOutput ? wrapOutput({ output: baseSchemaOutput, schema }) || baseSchemaOutput : baseSchemaOutput
-  const finalOutput = typeName ? `${wrappedSchemaOutput} as unknown as ${version === '4' ? 'z.ZodType' : 'ToZod'}<${typeName}>` : wrappedSchemaOutput
-
-  return (
-    <>
-      <File.Source name={name} isExportable isIndexable>
-        <Const
-          export
-          name={name}
-          JSDoc={{
-            comments: [description ? `@description ${jsStringEscape(description)}` : undefined].filter(Boolean),
-          }}
-        >
-          {finalOutput}
-        </Const>
-      </File.Source>
-      {inferTypeName && (
-        <File.Source name={inferTypeName} isExportable isIndexable isTypeOnly>
-          {typeName && (
-            <Type export name={inferTypeName}>
-              {typeName}
-            </Type>
-          )}
-          {!typeName && (
-            <Type export name={inferTypeName}>
-              {`z.infer<typeof ${name}>`}
-            </Type>
-          )}
-        </File.Source>
-      )}
-    </>
-  )
-}

package/src/components/index.ts

@@ -1,2 +0,0 @@
-export { Operations } from './Operations.tsx'
-export { Zod } from './Zod.tsx'

package/src/generators/index.ts

@@ -1,2 +0,0 @@
-export { operationsGenerator } from './operationsGenerator.tsx'
-export { zodGenerator } from './zodGenerator.tsx'

package/src/generators/operationsGenerator.tsx

@@ -1,50 +0,0 @@
-import { usePluginDriver } from '@kubb/core/hooks'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
-import { File } from '@kubb/react-fabric'
-import { Operations } from '../components/Operations.tsx'
-import type { PluginZod } from '../types'
-
-export const operationsGenerator = createReactGenerator<PluginZod>({
-  name: 'operations',
-  Operations({ operations, generator, plugin }) {
-    const {
-      name: pluginName,
-      options: { output, importPath },
-    } = plugin
-    const driver = usePluginDriver()
-
-    const oas = useOas()
-    const { getFile, groupSchemasByName } = useOperationManager(generator)
-
-    const name = 'operations'
-    const file = driver.getFile({ name, extname: '.ts', pluginName })
-
-    const transformedOperations = operations.map((operation) => ({ operation, data: groupSchemasByName(operation, { type: 'function' }) }))
-
-    const imports = Object.entries(transformedOperations)
-      .map(([key, { data, operation }]) => {
-        const names = [data.request, ...Object.values(data.responses), ...Object.values(data.parameters)].filter(Boolean)
-
-        return <File.Import key={key} name={names} root={file.path} path={getFile(operation).path} />
-      })
-      .filter(Boolean)
-
-    const isZodImport = importPath === 'zod' || importPath === 'zod/mini'
-
-    return (
-      <File
-        baseName={file.baseName}
-        path={file.path}
-        meta={file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
-      >
-        <File.Import isTypeOnly name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
-        {imports}
-        <Operations name={name} operations={transformedOperations} />
-      </File>
-    )
-  },
-})

package/src/generators/zodGenerator.tsx

@@ -1,202 +0,0 @@
-import path from 'node:path'
-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 { getBanner, getFooter, getImports } from '@kubb/plugin-oas/utils'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { File } from '@kubb/react-fabric'
-import { Zod } from '../components'
-import type { PluginZod } from '../types'
-
-export const zodGenerator = createReactGenerator<PluginZod>({
-  name: 'zod',
-  Operation({ config, operation, generator, plugin }) {
-    const {
-      options,
-      options: { coercion: globalCoercion, inferred, typed, mapper, wrapOutput, version, guidType, mini },
-    } = plugin
-
-    const mode = useMode()
-    const driver = usePluginDriver()
-
-    const oas = useOas()
-    const { getSchemas, getFile, getGroup } = useOperationManager(generator)
-    const schemaManager = useSchemaManager()
-
-    const file = getFile(operation)
-    const schemas = getSchemas(operation)
-    const schemaGenerator = new SchemaGenerator(options, {
-      fabric: generator.context.fabric,
-      oas,
-      plugin,
-      driver,
-      events: generator.context.events,
-      mode,
-      override: options.override,
-    })
-
-    const operationSchemas = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response]
-      .flat()
-      .filter(Boolean)
-    const toZodPath = path.resolve(config.root, config.output.path, '.kubb/ToZod.ts')
-
-    const mapOperationSchema = ({ name, schema: schemaOriginal, description, keysToOmit: keysToOmitOriginal, ...options }: OperationSchemaType) => {
-      let schemaObject = schemaOriginal
-      let keysToOmit = keysToOmitOriginal
-
-      if ((schemaOriginal.anyOf || schemaOriginal.oneOf) && keysToOmitOriginal && keysToOmitOriginal.length > 0) {
-        schemaObject = structuredClone(schemaOriginal)
-
-        // Remove $ref so the schema parser generates inline schema instead of a reference
-        delete schemaObject.$ref
-
-        for (const key of keysToOmitOriginal) {
-          delete schemaObject.properties?.[key]
-        }
-
-        if (Array.isArray(schemaObject.required)) {
-          schemaObject.required = schemaObject.required.filter((key) => !keysToOmitOriginal.includes(key))
-        }
-
-        keysToOmit = undefined
-      }
-
-      const hasProperties = Object.keys(schemaObject || {}).length > 0
-      const hasDefaults = Object.values(schemaObject.properties || {}).some((prop) => prop && Object.hasOwn(prop, 'default'))
-
-      const required = Array.isArray(schemaObject?.required) ? schemaObject.required.length > 0 : !!schemaObject?.required
-      const optional = !required && !hasDefaults && hasProperties && name.includes('Params')
-
-      if (!optional && Array.isArray(schemaObject.required) && !schemaObject.required.length) {
-        schemaObject.required = Object.entries(schemaObject.properties || {})
-          .filter(([_key, value]) => value && Object.hasOwn(value, 'default'))
-          .map(([key]) => key)
-      }
-
-      const tree = [
-        ...schemaGenerator.parse({ schema: schemaObject, name, parentName: null }),
-        optional ? { keyword: schemaKeywords.optional } : undefined,
-      ].filter(Boolean)
-      const imports = getImports(tree)
-      const group = options.operation ? getGroup(options.operation) : undefined
-
-      const coercion = name.includes('Params') ? { numbers: true, strings: false, dates: true } : globalCoercion
-
-      const zod = {
-        name: schemaManager.getName(name, { type: 'function' }),
-        inferTypeName: schemaManager.getName(name, { type: 'type' }),
-        file: schemaManager.getFile(name),
-      }
-
-      const type = {
-        name: schemaManager.getName(name, {
-          type: 'type',
-          pluginName: pluginTsName,
-        }),
-        file: schemaManager.getFile(options.operationName || name, {
-          pluginName: pluginTsName,
-          group,
-        }),
-      }
-
-      return (
-        <>
-          {typed && <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} />
-          ))}
-          <Zod
-            name={zod.name}
-            typeName={typed ? type.name : undefined}
-            inferTypeName={inferred ? zod.inferTypeName : undefined}
-            description={description}
-            tree={tree}
-            schema={schemaObject}
-            mapper={mapper}
-            coercion={coercion}
-            keysToOmit={keysToOmit}
-            wrapOutput={wrapOutput}
-            version={plugin.options.version}
-            guidType={guidType}
-            emptySchemaType={plugin.options.emptySchemaType}
-            mini={mini}
-          />
-        </>
-      )
-    }
-
-    const isZodImport = plugin.options.importPath === 'zod' || plugin.options.importPath === 'zod/mini'
-
-    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 })}
-      >
-        <File.Import name={isZodImport ? 'z' : ['z']} path={plugin.options.importPath} isNameSpace={isZodImport} />
-        {typed && version === '3' && <File.Import name={['ToZod']} isTypeOnly root={file.path} path={toZodPath} />}
-        {operationSchemas.map(mapOperationSchema)}
-      </File>
-    )
-  },
-  Schema({ config, schema, plugin }) {
-    const { getName, getFile } = useSchemaManager()
-    const {
-      options: { output, emptySchemaType, coercion, inferred, typed, mapper, importPath, wrapOutput, version, guidType, mini },
-    } = plugin
-    const driver = usePluginDriver()
-    const oas = useOas()
-
-    const imports = getImports(schema.tree)
-
-    const zod = {
-      name: getName(schema.name, { type: 'function' }),
-      inferTypeName: getName(schema.name, { type: 'type' }),
-      file: getFile(schema.name),
-    }
-
-    const type = {
-      name: getName(schema.name, { type: 'type', pluginName: pluginTsName }),
-      file: getFile(schema.name, { pluginName: pluginTsName }),
-    }
-
-    const isZodImport = importPath === 'zod' || importPath === 'zod/mini'
-    const toZodPath = path.resolve(config.root, config.output.path, '.kubb/ToZod.ts')
-
-    return (
-      <File
-        baseName={zod.file.baseName}
-        path={zod.file.path}
-        meta={zod.file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
-      >
-        <File.Import name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
-        {typed && <File.Import isTypeOnly root={zod.file.path} path={type.file.path} name={[type.name]} />}
-        {typed && version === '3' && <File.Import name={['ToZod']} isTypeOnly root={zod.file.path} path={toZodPath} />}
-        {imports.map((imp) => (
-          <File.Import key={[imp.path, imp.name, imp.isTypeOnly].join('-')} root={zod.file.path} path={imp.path} name={imp.name} />
-        ))}
-
-        <Zod
-          name={zod.name}
-          typeName={typed ? type.name : undefined}
-          inferTypeName={inferred ? zod.inferTypeName : undefined}
-          description={schema.value.description}
-          tree={schema.tree}
-          schema={schema.value}
-          mapper={mapper}
-          coercion={coercion}
-          wrapOutput={wrapOutput}
-          version={version}
-          guidType={guidType}
-          emptySchemaType={emptySchemaType}
-          mini={mini}
-        />
-      </File>
-    )
-  },
-})

package/src/index.ts

@@ -1,2 +0,0 @@
-export { pluginZod, pluginZodName } from './plugin.ts'
-export type { PluginZod } from './types.ts'