import { ConvenienceRenderer } from "../../ConvenienceRenderer.js";
import { type Name, type Namer } from "../../Naming.js";
import type { RenderContext } from "../../Renderer.js";
import type { OptionValues } from "../../RendererOptions/index.js";
import type { Sourcelike } from "../../Source.js";
import type { TargetLanguage } from "../../TargetLanguage.js";
import { type ClassProperty, type EnumType, ObjectType, type Type } from "../../Type/index.js";
import type { typeScriptZodOptions } from "./language.js";
export declare class TypeScriptZodRenderer extends ConvenienceRenderer {
    protected readonly _options: OptionValues<typeof typeScriptZodOptions>;
    /** TypeRefs of object types that participate in a reference cycle.
     * These must be emitted as z.lazy() schemas with an explicit type
     * annotation, since zod cannot infer recursive types. */
    private _recursiveTypeRefs;
    constructor(targetLanguage: TargetLanguage, renderContext: RenderContext, _options: OptionValues<typeof typeScriptZodOptions>);
    protected forbiddenNamesForGlobalNamespace(): string[];
    protected nameStyle(original: string, upper: boolean): string;
    protected makeNamedTypeNamer(): Namer;
    protected makeUnionMemberNamer(): Namer;
    protected namerForObjectProperty(): Namer;
    protected makeEnumCaseNamer(): Namer;
    protected importStatement(lhs: Sourcelike, moduleName: Sourcelike): Sourcelike;
    protected emitImports(): void;
    protected typeMapTypeForProperty(p: ClassProperty): Sourcelike;
    protected typeMapTypeFor(t: Type, required?: boolean): Sourcelike;
    /** TypeScript type for `t`, used to annotate recursive schemas for
     * which zod cannot infer the type.
     *
     * This intentionally duplicates neither `typeMapTypeFor` above nor
     * `sourceFor` in the plain TypeScript renderer
     * (`TypeScriptFlowBaseRenderer`): it must mirror exactly what
     * `z.infer` would derive from the schemas emitted by
     * `typeMapTypeFor` (e.g. `z.coerce.date()` implies `Date`), while
     * `sourceFor` is shaped by ts/flow-specific options like
     * `preferConstValues` and `declareUnions` that don't exist here. */
    protected underlyingTypeFor(t: Type): Sourcelike;
    protected isRecursive(t: ObjectType): boolean;
    protected emitObject(name: Name, t: ObjectType): void;
    /** Emit a recursive object type. zod cannot infer recursive types, so
     * the type is declared explicitly and the schema is wrapped in
     * z.lazy() with a z.ZodType annotation. */
    protected emitLazyObject(name: Name, t: ObjectType): void;
    protected emitEnum(e: EnumType, enumName: Name): void;
    /** Static function that extracts underlying type refs for types that form part of the
     * definition of the passed type - used to ensure that these appear in generated source
     * before types that reference them.
     *
     * Primitive types don't need defining and enums are output before other types, hence,
     * these are ignored.
     */
    private static extractUnderlyingTyperefs;
    protected emitSchemas(): void;
    protected emitSourceStructure(): void;
}
