@rawan-temo/prisma-zod-generator 3.3.1-config-coercion.0

package/lib/typed-json/emission.d.ts

@@ -0,0 +1,115 @@
+/**
+ * The parts of typed-JSON wiring that both emitters need.
+ *
+ * `src/typed-json/resolver.ts` answers "what schema does this field get?" and knows
+ * nothing about files. This module covers the two things that only make sense once an
+ * emitter is writing a file: which imports that file actually needs, and how to report a
+ * diagnostic without repeating it once per generated schema.
+ */
+import type { CustomImport } from '../parsers/zod-comments';
+import type { TypedJsonResult } from './resolver';
+/**
+ * The members of a `<Model><Create|Update><field>Input` list wrapper that hold values of
+ * the wrapped column, and so inherit its annotation.
+ *
+ * `{ set: [...] }` and `{ push: ... }` are how a list column is written through Prisma,
+ * which is the whole reason these wrappers need typing. The list is closed rather than
+ * "everything in the file" so that any member Prisma adds later is left alone until
+ * somebody has checked that a replacement is right for it.
+ */
+export declare const LIST_OPERATION_MEMBERS: Set<string>;
+export declare function isSharedFieldUpdateOperationsInput(name: unknown): boolean;
+/**
+ * The name of the per-field copy of a shared update-operations input.
+ *
+ * `Post.label` gets `PostLabelFieldUpdateOperationsInput`. The name is not guaranteed
+ * unique on its own - `Post.labelField` and `PostLabel.field` both produce
+ * `PostLabelFieldFieldUpdateOperationsInput` - so the caller checks for a clash and
+ * leaves the field alone when it finds one.
+ */
+export declare function typedFieldUpdateOperationsName(modelName: string, fieldName: string): string;
+/**
+ * Whether an annotation is allowed to replace this input type.
+ *
+ * Deliberately a short allow-list rather than "every scalar". These are the types the
+ * upstream corpus annotates, and a type absent from it is one where nobody has checked
+ * that a replacement composes with the rest of the pipeline. Widening it later is cheap;
+ * shipping a wrong schema for `Bytes` is not.
+ */
+export declare function isTypedJsonInputType(inputType: unknown): boolean;
+/**
+ * Schema names that must never receive a typed replacement, even though their members are
+ * named after model fields.
+ *
+ * `*ScalarWhereWithAggregatesInput` is the one that is easy to get wrong. Its inline
+ * scalar branch looks exactly like `WhereInput`'s, but upstream requires it to stay
+ * untyped: `{ price: { gt: 100 } }` has to keep typechecking there without a cast, since
+ * an aggregate comparison is over the whole group and not over one annotated value.
+ *
+ * `*Select` and the `*AggregateInput` family are boolean-flag schemas whose members happen
+ * to share the field names; the existing `extractZodValidationsForField` bails on exactly
+ * these two for the same reason.
+ *
+ * Every test here is a whole-name match, never a substring. Prisma builds these names as
+ * `<Model><suffix>`, and a model name is arbitrary user text: `includes('Select')` reads
+ * `SelectionRoundCreateInput` as a flag schema and silently drops typing from every
+ * `objects/` schema of a model called `SelectionRound`, while its `models/` and `results/`
+ * schemas keep it. The two boolean-flag families this skips - `<Model>Select`,
+ * `<CountOutputType>Select`, `<Model><Count|Min|Max|Sum|Avg>AggregateInput` - are all
+ * suffixes, so matching the suffix loses none of them.
+ */
+export declare function isTypedJsonExcludedSchema(schemaName: string | undefined | null): boolean;
+/**
+ * The model whose fields an input-object schema's members refer to, repaired for the one
+ * shape the general extraction reads wrong.
+ *
+ * `Transformer.extractModelNameFromContext` tries `<Model>CreateWithout<Relation>Input`
+ * before `<Model>UncheckedCreateWithout<Relation>Input`, so it answers `WorkflowUnchecked`
+ * for `WorkflowUncheckedCreateWithoutPostsInput` - a model that does not exist, so the
+ * annotation lookup finds nothing and the field is emitted untyped. That is not a cosmetic
+ * gap: a nested write offers `z.union([Checked, Unchecked])`, so the untyped half is a way
+ * round the typed half and the annotation stops constraining anything at all.
+ *
+ * The repair is deliberately a repair and not a rewrite of the extraction. That function
+ * also drives file naming and field filtering, where a changed answer moves bytes for
+ * people who have never configured `typedJson`. So this takes the extraction's answer as
+ * given, accepts it when it names a real model, and otherwise strips only a trailing
+ * `Unchecked`. Anything else stays unresolved, which is the same "leave the field alone"
+ * that an unknown model name already produced.
+ *
+ * The exact match is tried first, so a model genuinely called `FooUnchecked` still wins
+ * over `Foo` plus the token.
+ */
+export declare function resolveTypedJsonOwnerModel(extractedName: string | undefined | null, isKnownModel: (name: string) => boolean): string | null;
+/**
+ * Keep only the imports whose names the emitted body actually uses, then collapse them to
+ * one statement per module.
+ *
+ * Both steps matter and the order matters. The resolver builds imports per field, so a
+ * model with three annotated fields yields three statements from the same module; merging
+ * makes that one. Filtering first means the merged statement names only what this
+ * particular file references, so `WorkflowWhereInput` (which types scalar branches but not
+ * Json ones) does not end up importing a schema it never mentions.
+ *
+ * Names are sorted so the emitted bytes do not depend on field order in the schema.
+ */
+export declare function mergeTypedJsonImports(imports: CustomImport[], schemaBody: string, 
+/**
+ * Emit one statement per imported name instead of one per module.
+ *
+ * For single-file mode, where every schema's imports are concatenated into one bundle and
+ * de-duplicated by exact statement text. Merged statements differ from file to file
+ * (`{ A }` here, `{ A, B, C }` there), so text de-duplication keeps both and the bundle
+ * imports `A` twice - a duplicate-identifier error. One name per statement makes every
+ * occurrence of a name byte-identical, so it collapses to exactly one.
+ */
+oneNamePerStatement?: boolean): CustomImport[];
+export declare function warnOnce(message: string): void;
+/**
+ * Log whatever a resolution has to say, at most once each.
+ *
+ * `unconvertible` is the important one: the field silently keeps its old schema, and
+ * without a line in the output the user has no way to tell that their annotation did
+ * nothing.
+ */
+export declare function reportTypedJsonResult(result: TypedJsonResult, describe: () => string): void;

package/lib/typed-json/emission.js

@@ -0,0 +1,231 @@
+"use strict";
+/**
+ * The parts of typed-JSON wiring that both emitters need.
+ *
+ * `src/typed-json/resolver.ts` answers "what schema does this field get?" and knows
+ * nothing about files. This module covers the two things that only make sense once an
+ * emitter is writing a file: which imports that file actually needs, and how to report a
+ * diagnostic without repeating it once per generated schema.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIST_OPERATION_MEMBERS = void 0;
+exports.isSharedFieldUpdateOperationsInput = isSharedFieldUpdateOperationsInput;
+exports.typedFieldUpdateOperationsName = typedFieldUpdateOperationsName;
+exports.isTypedJsonInputType = isTypedJsonInputType;
+exports.isTypedJsonExcludedSchema = isTypedJsonExcludedSchema;
+exports.resolveTypedJsonOwnerModel = resolveTypedJsonOwnerModel;
+exports.mergeTypedJsonImports = mergeTypedJsonImports;
+exports.warnOnce = warnOnce;
+exports.reportTypedJsonResult = reportTypedJsonResult;
+const logger_1 = require("../utils/logger");
+/** Prisma scalar input types a PJTG annotation may replace. */
+const TYPED_JSON_INPUT_TYPES = new Set(['Json', 'String', 'Int', 'Float']);
+/**
+ * The members of a `<Model><Create|Update><field>Input` list wrapper that hold values of
+ * the wrapped column, and so inherit its annotation.
+ *
+ * `{ set: [...] }` and `{ push: ... }` are how a list column is written through Prisma,
+ * which is the whole reason these wrappers need typing. The list is closed rather than
+ * "everything in the file" so that any member Prisma adds later is left alone until
+ * somebody has checked that a replacement is right for it.
+ */
+exports.LIST_OPERATION_MEMBERS = new Set(['set', 'push']);
+/**
+ * Prisma's shared per-scalar update-operations input: `StringFieldUpdateOperationsInput`,
+ * `NullableIntFieldUpdateOperationsInput`, and so on.
+ *
+ * One of these exists per scalar type for the whole schema, not per column, which is why
+ * it can never carry one column's annotation.
+ */
+const SHARED_FIELD_UPDATE_OPERATIONS_INPUT = /^(?:Nullable)?[A-Za-z0-9]+FieldUpdateOperationsInput$/;
+function isSharedFieldUpdateOperationsInput(name) {
+    return typeof name === 'string' && SHARED_FIELD_UPDATE_OPERATIONS_INPUT.test(name);
+}
+/**
+ * The name of the per-field copy of a shared update-operations input.
+ *
+ * `Post.label` gets `PostLabelFieldUpdateOperationsInput`. The name is not guaranteed
+ * unique on its own - `Post.labelField` and `PostLabel.field` both produce
+ * `PostLabelFieldFieldUpdateOperationsInput` - so the caller checks for a clash and
+ * leaves the field alone when it finds one.
+ */
+function typedFieldUpdateOperationsName(modelName, fieldName) {
+    const head = fieldName.charAt(0).toUpperCase() + fieldName.slice(1);
+    return `${modelName}${head}FieldUpdateOperationsInput`;
+}
+/**
+ * Whether an annotation is allowed to replace this input type.
+ *
+ * Deliberately a short allow-list rather than "every scalar". These are the types the
+ * upstream corpus annotates, and a type absent from it is one where nobody has checked
+ * that a replacement composes with the rest of the pipeline. Widening it later is cheap;
+ * shipping a wrong schema for `Bytes` is not.
+ */
+function isTypedJsonInputType(inputType) {
+    return typeof inputType === 'string' && TYPED_JSON_INPUT_TYPES.has(inputType);
+}
+/**
+ * Schema names that must never receive a typed replacement, even though their members are
+ * named after model fields.
+ *
+ * `*ScalarWhereWithAggregatesInput` is the one that is easy to get wrong. Its inline
+ * scalar branch looks exactly like `WhereInput`'s, but upstream requires it to stay
+ * untyped: `{ price: { gt: 100 } }` has to keep typechecking there without a cast, since
+ * an aggregate comparison is over the whole group and not over one annotated value.
+ *
+ * `*Select` and the `*AggregateInput` family are boolean-flag schemas whose members happen
+ * to share the field names; the existing `extractZodValidationsForField` bails on exactly
+ * these two for the same reason.
+ *
+ * Every test here is a whole-name match, never a substring. Prisma builds these names as
+ * `<Model><suffix>`, and a model name is arbitrary user text: `includes('Select')` reads
+ * `SelectionRoundCreateInput` as a flag schema and silently drops typing from every
+ * `objects/` schema of a model called `SelectionRound`, while its `models/` and `results/`
+ * schemas keep it. The two boolean-flag families this skips - `<Model>Select`,
+ * `<CountOutputType>Select`, `<Model><Count|Min|Max|Sum|Avg>AggregateInput` - are all
+ * suffixes, so matching the suffix loses none of them.
+ */
+function isTypedJsonExcludedSchema(schemaName) {
+    if (!schemaName)
+        return false;
+    if (/^\w+Select$/.test(schemaName))
+        return true;
+    if (/^\w+ScalarWhereWithAggregatesInput$/.test(schemaName))
+        return true;
+    if (/^\w+(?:Count|Min|Max|Sum|Avg)AggregateInput$/.test(schemaName))
+        return true;
+    return false;
+}
+/**
+ * The token the general model-name patterns swallow.
+ *
+ * `<Model>UncheckedCreateWithout<Relation>Input` also reads as a `CreateWithout` of a model
+ * called `<Model>Unchecked`, and `\w+` is greedy, so the earlier pattern wins.
+ */
+const UNCHECKED_SUFFIX = 'Unchecked';
+/**
+ * The model whose fields an input-object schema's members refer to, repaired for the one
+ * shape the general extraction reads wrong.
+ *
+ * `Transformer.extractModelNameFromContext` tries `<Model>CreateWithout<Relation>Input`
+ * before `<Model>UncheckedCreateWithout<Relation>Input`, so it answers `WorkflowUnchecked`
+ * for `WorkflowUncheckedCreateWithoutPostsInput` - a model that does not exist, so the
+ * annotation lookup finds nothing and the field is emitted untyped. That is not a cosmetic
+ * gap: a nested write offers `z.union([Checked, Unchecked])`, so the untyped half is a way
+ * round the typed half and the annotation stops constraining anything at all.
+ *
+ * The repair is deliberately a repair and not a rewrite of the extraction. That function
+ * also drives file naming and field filtering, where a changed answer moves bytes for
+ * people who have never configured `typedJson`. So this takes the extraction's answer as
+ * given, accepts it when it names a real model, and otherwise strips only a trailing
+ * `Unchecked`. Anything else stays unresolved, which is the same "leave the field alone"
+ * that an unknown model name already produced.
+ *
+ * The exact match is tried first, so a model genuinely called `FooUnchecked` still wins
+ * over `Foo` plus the token.
+ */
+function resolveTypedJsonOwnerModel(extractedName, isKnownModel) {
+    if (!extractedName)
+        return null;
+    if (isKnownModel(extractedName))
+        return extractedName;
+    if (!extractedName.endsWith(UNCHECKED_SUFFIX))
+        return null;
+    const owner = extractedName.slice(0, -UNCHECKED_SUFFIX.length);
+    return owner && isKnownModel(owner) ? owner : null;
+}
+/**
+ * Keep only the imports whose names the emitted body actually uses, then collapse them to
+ * one statement per module.
+ *
+ * Both steps matter and the order matters. The resolver builds imports per field, so a
+ * model with three annotated fields yields three statements from the same module; merging
+ * makes that one. Filtering first means the merged statement names only what this
+ * particular file references, so `WorkflowWhereInput` (which types scalar branches but not
+ * Json ones) does not end up importing a schema it never mentions.
+ *
+ * Names are sorted so the emitted bytes do not depend on field order in the schema.
+ */
+function mergeTypedJsonImports(imports, schemaBody, 
+/**
+ * Emit one statement per imported name instead of one per module.
+ *
+ * For single-file mode, where every schema's imports are concatenated into one bundle and
+ * de-duplicated by exact statement text. Merged statements differ from file to file
+ * (`{ A }` here, `{ A, B, C }` there), so text de-duplication keeps both and the bundle
+ * imports `A` twice - a duplicate-identifier error. One name per statement makes every
+ * occurrence of a name byte-identical, so it collapses to exactly one.
+ */
+oneNamePerStatement = false) {
+    var _a, _b;
+    if (imports.length === 0)
+        return [];
+    const bySource = new Map();
+    for (const candidate of imports) {
+        for (const item of (_a = candidate.importedItems) !== null && _a !== void 0 ? _a : []) {
+            if (!item)
+                continue;
+            if (schemaBody && !new RegExp(`\\b${escapeRegExp(item)}\\b`).test(schemaBody))
+                continue;
+            const names = (_b = bySource.get(candidate.source)) !== null && _b !== void 0 ? _b : new Set();
+            names.add(item);
+            bySource.set(candidate.source, names);
+        }
+    }
+    const build = (source, importedItems) => {
+        const importStatement = `import { ${importedItems.join(', ')} } from '${source}'`;
+        return {
+            importStatement,
+            source,
+            importedItems,
+            isDefault: false,
+            isNamespace: false,
+            isTypeOnly: false,
+            originalStatement: importStatement,
+        };
+    };
+    return [...bySource.entries()]
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+        .flatMap(([source, names]) => {
+        const importedItems = [...names].sort();
+        return oneNamePerStatement
+            ? importedItems.map((item) => build(source, [item]))
+            : [build(source, importedItems)];
+    });
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Report a typed-JSON diagnostic once per generate.
+ *
+ * One annotated field reaches a dozen input schemas, so an un-deduplicated warning buries
+ * everything else in the generator's output and trains people to ignore it.
+ */
+const reported = new Set();
+function warnOnce(message) {
+    if (reported.has(message))
+        return;
+    reported.add(message);
+    logger_1.logger.warn(`[typedJson] ${message}`);
+}
+/**
+ * Log whatever a resolution has to say, at most once each.
+ *
+ * `unconvertible` is the important one: the field silently keeps its old schema, and
+ * without a line in the output the user has no way to tell that their annotation did
+ * nothing.
+ */
+function reportTypedJsonResult(result, describe) {
+    for (const warning of result.warnings)
+        warnOnce(warning);
+    if (result.status === 'unconvertible') {
+        warnOnce(result.reason);
+        return;
+    }
+    if (result.status === 'resolved' && result.hasZodAnnotations) {
+        warnOnce(`${describe()}: the @zod annotations on this field are not applied, because ` +
+            `${result.annotation.raw} already replaces its base schema.`);
+    }
+}
+//# sourceMappingURL=emission.js.map

package/lib/typed-json/emission.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emission.js","sourceRoot":"","sources":["../../src/typed-json/emission.ts"],"names":[],"mappings":"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"}

package/lib/typed-json/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Typed JSON and typed scalar fields, compatible with
+ * prisma-json-types-generator (PJTG).
+ *
+ * Emitters should need only `resolveTypedJsonField`. The parser and the
+ * converter are exported for tests and for anything that wants to inspect an
+ * annotation without resolving it.
+ *
+ * Usage from an emitter, in the position where the base schema is chosen:
+ *
+ * ```ts
+ * const typed = resolveTypedJsonField(
+ *   { modelName, fieldName: field.name, documentation: field.documentation,
+ *     isList: field.isList, outputSubdir: 'schemas/objects' },
+ *   Transformer.getGeneratorConfig()?.typedJson,
+ * );
+ * const baseSchema =
+ *   typed.status === 'resolved' ? typed.elementExpression : (customSchema || 'jsonSchema');
+ * if (typed.status === 'unconvertible') logger.warn(typed.reason);
+ * ```
+ *
+ * `elementExpression` is deliberately the element schema: both the CRUD emitter
+ * and the pure-model emitter apply their own list wrapper afterwards. Use
+ * `expression` only in an emitter that does not.
+ */
+export { detectPjtgAnnotation, parsePjtgAnnotation, type PjtgAnnotation, type PjtgAnnotationKind, type PjtgAnnotationParseResult, } from './annotation-parser';
+export { convertTsTypeToZod, quoteStringLiteral, type TsTypeConversionFailure, type TsTypeConversionOptions, type TsTypeConversionResult, type TsTypeConversionSuccess, type TypeNameResolution, } from './ts-type-to-zod';
+export { resolveImportSpecifier, resolveTypedJsonField, type TypedJsonFieldContext, type TypedJsonImport, type TypedJsonNone, type TypedJsonResolved, type TypedJsonResult, type TypedJsonSuperseded, type TypedJsonTypeUse, type TypedJsonUnconvertible, } from './resolver';
+export { DEFAULT_TYPED_JSON_NAMESPACE, DEFAULT_TYPED_JSON_SCHEMA_SUFFIX, resolveTypedJsonConfig, resolveTypedJsonType, type ResolvedTypedJsonConfig, type TypedJsonConfig, type TypedJsonTypeResolution, } from '../config/typed-json';

package/lib/typed-json/index.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Typed JSON and typed scalar fields, compatible with
+ * prisma-json-types-generator (PJTG).
+ *
+ * Emitters should need only `resolveTypedJsonField`. The parser and the
+ * converter are exported for tests and for anything that wants to inspect an
+ * annotation without resolving it.
+ *
+ * Usage from an emitter, in the position where the base schema is chosen:
+ *
+ * ```ts
+ * const typed = resolveTypedJsonField(
+ *   { modelName, fieldName: field.name, documentation: field.documentation,
+ *     isList: field.isList, outputSubdir: 'schemas/objects' },
+ *   Transformer.getGeneratorConfig()?.typedJson,
+ * );
+ * const baseSchema =
+ *   typed.status === 'resolved' ? typed.elementExpression : (customSchema || 'jsonSchema');
+ * if (typed.status === 'unconvertible') logger.warn(typed.reason);
+ * ```
+ *
+ * `elementExpression` is deliberately the element schema: both the CRUD emitter
+ * and the pure-model emitter apply their own list wrapper afterwards. Use
+ * `expression` only in an emitter that does not.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTypedJsonType = exports.resolveTypedJsonConfig = exports.DEFAULT_TYPED_JSON_SCHEMA_SUFFIX = exports.DEFAULT_TYPED_JSON_NAMESPACE = exports.resolveTypedJsonField = exports.resolveImportSpecifier = exports.quoteStringLiteral = exports.convertTsTypeToZod = exports.parsePjtgAnnotation = exports.detectPjtgAnnotation = void 0;
+var annotation_parser_1 = require("./annotation-parser");
+Object.defineProperty(exports, "detectPjtgAnnotation", { enumerable: true, get: function () { return annotation_parser_1.detectPjtgAnnotation; } });
+Object.defineProperty(exports, "parsePjtgAnnotation", { enumerable: true, get: function () { return annotation_parser_1.parsePjtgAnnotation; } });
+var ts_type_to_zod_1 = require("./ts-type-to-zod");
+Object.defineProperty(exports, "convertTsTypeToZod", { enumerable: true, get: function () { return ts_type_to_zod_1.convertTsTypeToZod; } });
+Object.defineProperty(exports, "quoteStringLiteral", { enumerable: true, get: function () { return ts_type_to_zod_1.quoteStringLiteral; } });
+var resolver_1 = require("./resolver");
+Object.defineProperty(exports, "resolveImportSpecifier", { enumerable: true, get: function () { return resolver_1.resolveImportSpecifier; } });
+Object.defineProperty(exports, "resolveTypedJsonField", { enumerable: true, get: function () { return resolver_1.resolveTypedJsonField; } });
+// The configuration block, its defaults, and the `[TypeName]` resolution order
+// live in src/config/typed-json.ts and are re-exported here so an emitter needs
+// only one import. There is one implementation of resolution, not two.
+var typed_json_1 = require("../config/typed-json");
+Object.defineProperty(exports, "DEFAULT_TYPED_JSON_NAMESPACE", { enumerable: true, get: function () { return typed_json_1.DEFAULT_TYPED_JSON_NAMESPACE; } });
+Object.defineProperty(exports, "DEFAULT_TYPED_JSON_SCHEMA_SUFFIX", { enumerable: true, get: function () { return typed_json_1.DEFAULT_TYPED_JSON_SCHEMA_SUFFIX; } });
+Object.defineProperty(exports, "resolveTypedJsonConfig", { enumerable: true, get: function () { return typed_json_1.resolveTypedJsonConfig; } });
+Object.defineProperty(exports, "resolveTypedJsonType", { enumerable: true, get: function () { return typed_json_1.resolveTypedJsonType; } });
+//# sourceMappingURL=index.js.map

package/lib/typed-json/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/typed-json/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;;AAEH,yDAM6B;AAL3B,yHAAA,oBAAoB,OAAA;AACpB,wHAAA,mBAAmB,OAAA;AAMrB,mDAQ0B;AAPxB,oHAAA,kBAAkB,OAAA;AAClB,oHAAA,kBAAkB,OAAA;AAQpB,uCAWoB;AAVlB,kHAAA,sBAAsB,OAAA;AACtB,iHAAA,qBAAqB,OAAA;AAWvB,+EAA+E;AAC/E,gFAAgF;AAChF,uEAAuE;AACvE,mDAQ8B;AAP5B,0HAAA,4BAA4B,OAAA;AAC5B,8HAAA,gCAAgC,OAAA;AAChC,oHAAA,sBAAsB,OAAA;AACtB,kHAAA,oBAAoB,OAAA"}

package/lib/typed-json/resolver.d.ts

@@ -0,0 +1,112 @@
+/**
+ * The public entry point for typed JSON and typed scalar fields.
+ *
+ * Given a field's `documentation` plus its metadata, this returns either a Zod
+ * expression and the imports it needs, or a reason it could not be produced.
+ * It reads no DMMF, writes no files, and knows nothing about any emitter, so
+ * every emitter can call it the same way.
+ *
+ * Two guarantees the callers depend on:
+ *
+ * - **With no `typedJson` config the answer is always `none`.** Generated
+ *   output is then byte-identical to today, which is the compatibility contract
+ *   for the many schemas that carry PJTG annotations for a different generator.
+ * - **The returned expression carries no optionality and no null sentinel.**
+ *   It replaces exactly the base-schema token the emitter would otherwise have
+ *   used, and the emitter keeps applying `.optional()`, `.nullable()` and the
+ *   `JsonNullValueInput` union exactly as it does now.
+ */
+import { type ResolvedTypedJsonConfig, type TypedJsonTypeResolution } from '../config/typed-json';
+import type { CustomImport } from '../parsers/zod-comments';
+import { type PjtgAnnotation } from './annotation-parser';
+/** An import to add to the emitted file, shaped like the `@zod.import` pipeline's. */
+export type TypedJsonImport = CustomImport;
+export interface TypedJsonFieldContext {
+    fieldName: string;
+    modelName?: string;
+    /** The field's `documentation`, straight from the DMMF. */
+    documentation?: string | null;
+    /** True for a list field. The annotation then describes the ELEMENT type. */
+    isList?: boolean;
+    /** Informational. Optionality is applied by the caller, never here. */
+    isOptional?: boolean;
+    /**
+     * Directory of the file being emitted, relative to the generator output root,
+     * for example `schemas/objects` or `schemas/variants/pure`. Used to rewrite a
+     * relative `schemaModule`. Omit it and the specifier is used as configured.
+     */
+    outputSubdir?: string;
+    /** Extension to append to relative specifiers, e.g. `.js` under NodeNext. */
+    importExtension?: string;
+}
+interface TypedJsonResultBase {
+    /** Diagnostics worth logging. Never fatal. */
+    warnings: string[];
+    /** True when the field also carries any `@zod.` annotation. */
+    hasZodAnnotations: boolean;
+}
+/** One `[TypeName]` the field's schema depends on, and how it resolved. */
+export interface TypedJsonTypeUse {
+    typeName: string;
+    resolution: TypedJsonTypeResolution;
+}
+export interface TypedJsonResolved extends TypedJsonResultBase {
+    status: 'resolved';
+    /**
+     * The schema for one value of the field. For a list field this is the element
+     * schema, which is what the CRUD and pure-model emitters both want, because
+     * each already applies its own list wrapper.
+     */
+    elementExpression: string;
+    /** The whole field's schema: `elementExpression`, wrapped in `z.array` if it is a list. */
+    expression: string;
+    /** Imports the expression needs. Empty when it needs none. */
+    imports: TypedJsonImport[];
+    annotation: PjtgAnnotation;
+    /**
+     * Every type name the expression used, with the resolution it came from.
+     * Feeds `buildTypedJsonNamespace`, which must declare the schema actually
+     * used for the field rather than form a second opinion about it.
+     */
+    typeUses: TypedJsonTypeUse[];
+    /**
+     * True only when `expression` is rooted in `z.string()`, so a native
+     * `@db.VarChar(n)` length constraint may still be appended to it.
+     *
+     * The CRUD emitter appends `.max(n)` for `@db.VarChar(n)` on every `String`
+     * field, replaced base schema or not, and `z.enum([...]).max(8)` is a module
+     * that throws `TypeError: z.enum(...).max is not a function` the moment it is
+     * imported. Callers must skip that step when this is false.
+     */
+    allowsStringLengthConstraints: boolean;
+}
+export interface TypedJsonNone extends TypedJsonResultBase {
+    status: 'none';
+}
+export interface TypedJsonSuperseded extends TypedJsonResultBase {
+    status: 'superseded';
+    reason: string;
+    annotation: PjtgAnnotation;
+}
+export interface TypedJsonUnconvertible extends TypedJsonResultBase {
+    status: 'unconvertible';
+    reason: string;
+    annotation: PjtgAnnotation | null;
+}
+export type TypedJsonResult = TypedJsonResolved | TypedJsonNone | TypedJsonSuperseded | TypedJsonUnconvertible;
+/**
+ * Resolve one field's PJTG annotation to a Zod expression.
+ *
+ * Never throws. Returns `none` when there is nothing to do, which includes the
+ * case of `typedJson` not being configured at all.
+ */
+export declare function resolveTypedJsonField(context: TypedJsonFieldContext, config: ResolvedTypedJsonConfig | undefined | null): TypedJsonResult;
+/**
+ * Rewrite `schemaModule` so it resolves from the directory being emitted into.
+ *
+ * A relative specifier is read from the generator output root, because one
+ * literal string cannot be correct in `schemas/objects`, `schemas/models` and
+ * `schemas/variants/pure` at once. Package specifiers pass through untouched.
+ */
+export declare function resolveImportSpecifier(schemaModule: string, context: Pick<TypedJsonFieldContext, 'outputSubdir' | 'importExtension'>): string;
+export {};