@amritk/generate-validators 0.3.1 → 0.4.1

package/dist/generators/build-schema.d.ts

@@ -27,4 +27,4 @@ export type GeneratedFile = {
  * // files → [{ filename: 'document.ts', content: '...' }, { filename: 'info.ts', ... }, ...]
  * ```
  */
-export declare const buildValidatorSchema: (rootSchema: JSONSchema, rootTypeName: string) => Promise<GeneratedFile[]>;
+export declare const buildValidatorSchema: (rootSchema: JSONSchema, rootTypeName: string, typeSuffix?: string) => Promise<GeneratedFile[]>;

package/dist/generators/collect-validator-imports.d.ts

@@ -13,6 +13,11 @@ type CollectValidatorImportsOptions = {
      * are excluded from the import list (they were never generated as files).
      */
     readonly rootSchema?: Record<string, unknown> | undefined;
+    /**
+     * Suffix appended to every type/validator name derived from a `$ref`. Must
+     * match the suffix used when generating the referenced files. Defaults to `''`.
+     */
+    readonly typeSuffix?: string;
 };
 /**
  * Collects import statements for all $ref dependencies of a schema.
@@ -22,7 +27,7 @@ type CollectValidatorImportsOptions = {
  * ```typescript
  * const schema = { properties: { contact: { $ref: '#/$defs/contact' } } }
  * collectValidatorImports(schema)
- * // ["import { type ContactObject, validateContactObject } from './contact-object'"]
+ * // ["import { type Contact, validateContact } from './contact'"]
  * ```
  */
 export declare const collectValidatorImports: (schema: JSONSchema, options?: CollectValidatorImportsOptions) => string[];

package/dist/generators/generate-files.d.ts

@@ -12,6 +12,11 @@ type GenerateValidatorFileOptions = {
      * The root schema document. Used to filter out unresolvable refs.
      */
     readonly rootSchema?: Record<string, unknown>;
+    /**
+     * Suffix appended to every type/validator name derived from a `$ref`.
+     * Defaults to `''` (no suffix).
+     */
+    readonly typeSuffix?: string;
 };
 /**
  * Generates a complete TypeScript validator file from a JSON Schema.

package/dist/generators/generate-validator-function.d.ts

@@ -21,4 +21,4 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * // }
  * ```
  */
-export declare const generateValidatorFunction: (schema: JSONSchema, typeName: string) => string;
+export declare const generateValidatorFunction: (schema: JSONSchema, typeName: string, suffix?: string) => string;

package/dist/index.js

@@ -132,15 +132,15 @@ var refToFilename2 = (ref) => {
   }
   return filename;
 };
-var kebabToPascal = (kebab) => {
+var kebabToPascal = (kebab, suffix) => {
   const words = kebab.split("-");
   let pascalCase = "";
   for (const word of words) {
     pascalCase += word.charAt(0).toUpperCase() + word.slice(1);
   }
-  return pascalCase + "Object";
+  return pascalCase + suffix;
 };
-var refToName = (ref) => kebabToPascal(refToFilename2(ref));
+var refToName = (ref, suffix = "") => kebabToPascal(refToFilename2(ref), suffix);
 
 // ../helpers/dist/resolve-dynamic-refs.js
 var resolveDynamicRefs = (schema, dynamicRefMap) => {
@@ -415,15 +415,15 @@ var refToFilename4 = (ref) => {
   }
   return filename;
 };
-var kebabToPascal2 = (kebab) => {
+var kebabToPascal2 = (kebab, suffix) => {
   const words = kebab.split("-");
   let pascalCase = "";
   for (const word of words) {
     pascalCase += word.charAt(0).toUpperCase() + word.slice(1);
   }
-  return pascalCase + "Object";
+  return pascalCase + suffix;
 };
-var refToName2 = (ref) => kebabToPascal2(refToFilename4(ref));
+var refToName2 = (ref, suffix = "") => kebabToPascal2(refToFilename4(ref), suffix);
 var JS_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 var safeKey = (key) => {
   if (JS_IDENTIFIER.test(key)) {
@@ -541,13 +541,13 @@ var getUnbrandedType = (schema, options = {}) => {
     if (!schema.$ref.startsWith("#")) {
       return "unknown";
     }
-    return refToName2(schema.$ref);
+    return refToName2(schema.$ref, options.typeSuffix);
   }
   if (schema.$dynamicRef) {
     if (schema.$dynamicRef === "#meta") {
-      return "Schema";
+      return `Schema${options.typeSuffix ?? ""}`;
     }
-    return refToName2(schema.$dynamicRef);
+    return refToName2(schema.$dynamicRef, options.typeSuffix);
   }
   if (schema.const !== undefined) {
     return JSON.stringify(schema.const);
@@ -594,7 +594,7 @@ var getUnbrandedType = (schema, options = {}) => {
   if (conditionalResult) {
     const baseType = getTypeScriptType(conditionalResult.schema, options);
     if (conditionalResult.thenRef) {
-      return `(${baseType}) & ${refToName2(conditionalResult.thenRef)}`;
+      return `(${baseType}) & ${refToName2(conditionalResult.thenRef, options.typeSuffix)}`;
     }
     return baseType;
   }
@@ -675,6 +675,31 @@ var getUnbrandedType = (schema, options = {}) => {
     case "object":
       if (schema.properties) {
         const readonlyPrefix = options.readonly ? "readonly " : "";
+        const hasDescriptions = Object.values(schema.properties).some((p) => isSchemaObject2(p) && (typeof p.description === "string" || typeof p.$comment === "string"));
+        if (hasDescriptions) {
+          let properties2 = "";
+          let first2 = true;
+          for (const key in schema.properties) {
+            const propSchema = schema.properties[key];
+            const isRequired = schema.required?.includes(key) ?? false;
+            const optional = isRequired ? "" : "?";
+            const propType = getTypeScriptType(propSchema, options);
+            const inlineDescription = isSchemaObject2(propSchema) && typeof propSchema.description === "string" ? propSchema.description : isSchemaObject2(propSchema) && typeof propSchema.$comment === "string" ? propSchema.$comment : undefined;
+            if (!first2)
+              properties2 += `
+`;
+            first2 = false;
+            if (inlineDescription) {
+              properties2 += "  /** " + inlineDescription + ` */
+  ` + readonlyPrefix + safeKey(key) + optional + ": " + propType + ";";
+            } else {
+              properties2 += "  " + readonlyPrefix + safeKey(key) + optional + ": " + propType + ";";
+            }
+          }
+          return `{
+` + properties2 + `
+}`;
+        }
         let properties = "";
         let first = true;
         for (const key in schema.properties) {
@@ -716,8 +741,9 @@ var generateTypeDefinition = (schema, typeName, options = {}) => {
   if (!isObjectLikeSchema(schema)) {
     const tsType = getTypeScriptType(schema, options);
     let result = "";
-    if (isSchemaObject2(schema) && schema.$comment && typeof schema.$comment === "string") {
-      result += buildJsDocBlock(typeName, schema.$comment);
+    const topLevelComment = isSchemaObject2(schema) && typeof schema.description === "string" && schema.description || isSchemaObject2(schema) && typeof schema.$comment === "string" && schema.$comment || undefined;
+    if (topLevelComment) {
+      result += buildJsDocBlock(typeName, topLevelComment);
     }
     result += `export type ${typeName} = ${tsType};`;
     return result;
@@ -728,9 +754,10 @@ var generateTypeDefinition = (schema, typeName, options = {}) => {
     const conditionalThenRef = conditionalResult?.thenRef ?? null;
     let jsDocTitle;
     let jsDocDescription;
-    if (isSchemaObject2(schema) && schema.$comment && typeof schema.$comment === "string") {
+    const topLevelComment = isSchemaObject2(schema) && typeof schema.description === "string" && schema.description || isSchemaObject2(schema) && typeof schema.$comment === "string" && schema.$comment || undefined;
+    if (topLevelComment) {
       jsDocTitle = typeName;
-      jsDocDescription = schema.$comment;
+      jsDocDescription = topLevelComment;
     }
     const hasProperties2 = normalizedSchema.properties && Object.keys(normalizedSchema.properties).length > 0;
     const hasAdditionalProperties2 = normalizedSchema.additionalProperties && typeof normalizedSchema.additionalProperties === "object";
@@ -787,12 +814,12 @@ var generateTypeDefinition = (schema, typeName, options = {}) => {
     if (isSchemaObject2(schema) && Array.isArray(schema.allOf)) {
       for (const entry of schema.allOf) {
         if (isSchemaObject2(entry) && entry.$ref) {
-          allOfIntersections.push(refToName2(entry.$ref));
+          allOfIntersections.push(refToName2(entry.$ref, options.typeSuffix));
         }
       }
     }
     if (isSchemaObject2(schema) && typeof schema.$ref === "string" && schema.$ref.startsWith("#")) {
-      allOfIntersections.push(refToName2(schema.$ref));
+      allOfIntersections.push(refToName2(schema.$ref, options.typeSuffix));
     }
     let result = "";
     if (jsDocTitle && jsDocDescription) {
@@ -802,7 +829,7 @@ var generateTypeDefinition = (schema, typeName, options = {}) => {
 ` + properties + `
 }`;
     if (conditionalThenRef) {
-      typeBody += " & " + refToName2(conditionalThenRef);
+      typeBody += " & " + refToName2(conditionalThenRef, options.typeSuffix);
     }
     for (const intersectionType of allOfIntersections) {
       typeBody += " & " + intersectionType;
@@ -876,9 +903,9 @@ var hasMultipleOf = (schema) => {
 };
 
 // src/generators/collect-validator-imports.ts
-var buildImport = (ref) => {
+var buildImport = (ref, suffix) => {
   const filename = refToFilename(ref);
-  const typeName = refToName(ref);
+  const typeName = refToName(ref, suffix);
   const validatorName = `validate${typeName}`;
   return `import { type ${typeName}, ${validatorName} } from './${filename}'`;
 };
@@ -923,6 +950,7 @@ var collectDirectRefs = (schema) => {
 var collectValidatorImports = (schema, options) => {
   const selfFilename = options?.selfRef ? refToFilename(options.selfRef) : null;
   const rootSchema = options?.rootSchema;
+  const typeSuffix = options?.typeSuffix ?? "";
   const refs = collectDirectRefs(schema);
   const seen = new Set;
   const imports = [];
@@ -939,7 +967,7 @@ var collectValidatorImports = (schema, options) => {
     }
     seen.add(filename);
     const importRef = ref.endsWith("-or-reference") ? ref.replace("-or-reference", "") : ref;
-    imports.push(buildImport(importRef));
+    imports.push(buildImport(importRef, typeSuffix));
   }
   return imports;
 };
@@ -993,7 +1021,7 @@ var wrongTypeCondition = (accessor, type) => {
       return "";
   }
 };
-var generatePropertyChecks = (key, propSchema, isRequired) => {
+var generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
   if (!isSchemaObject3(propSchema))
     return [];
   const raw = `obj[${JSON.stringify(key)}]`;
@@ -1001,7 +1029,7 @@ var generatePropertyChecks = (key, propSchema, isRequired) => {
   const lines = [];
   if (hasRef(propSchema)) {
     const ref = propSchema.$ref;
-    const vName = validatorName(refToName(ref));
+    const vName = validatorName(refToName(ref, suffix));
     if (isRequired) {
       lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
       lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
@@ -1127,7 +1155,7 @@ var generatePropertyChecks = (key, propSchema, isRequired) => {
     if (t === "array" && hasItems(propSchema)) {
       const itemSchema = propSchema.items;
       if (hasRef(itemSchema)) {
-        const vName = validatorName(refToName(itemSchema.$ref));
+        const vName = validatorName(refToName(itemSchema.$ref, suffix));
         lines.push(`  if (Array.isArray(${raw})) {`);
         lines.push(`    for (let _i = 0; _i < ${raw}.length; _i++) {`);
         lines.push(`      const _ir = ${vName}(${raw}[_i], \`${path.slice(1, -1)}/${key}/\${_i}\`)`);
@@ -1151,19 +1179,19 @@ var generatePropertyChecks = (key, propSchema, isRequired) => {
   }
   return lines;
 };
-var generateObjectValidator = (schema, typeName) => {
+var generateObjectValidator = (schema, typeName, suffix) => {
   const vName = validatorName(typeName);
   const required = new Set(hasRequired(schema) ? schema.required : []);
   const properties = hasProperties(schema) ? schema.properties : {};
   const propertyLines = [];
   for (const [key, propSchema] of Object.entries(properties)) {
-    const checks = generatePropertyChecks(key, propSchema, required.has(key));
+    const checks = generatePropertyChecks(key, propSchema, required.has(key), suffix);
     if (checks.length > 0) {
       propertyLines.push(...checks);
     }
   }
   if (hasAdditionalProperties(schema) && isSchemaObject3(schema.additionalProperties) && hasRef(schema.additionalProperties)) {
-    const vRefName = validatorName(refToName(schema.additionalProperties.$ref));
+    const vRefName = validatorName(refToName(schema.additionalProperties.$ref, suffix));
     propertyLines.push(`  for (const _key of Object.keys(obj)) {`);
     propertyLines.push(`    if (${JSON.stringify(Object.keys(properties))}.includes(_key)) continue`);
     propertyLines.push(`    const _r = ${vRefName}(obj[_key as keyof typeof obj], \`\${_path}/\${_key}\`)`);
@@ -1188,14 +1216,14 @@ var generateObjectValidator = (schema, typeName) => {
   ].join(`
 `);
 };
-var generateScalarValidator = (schema, typeName) => {
+var generateScalarValidator = (schema, typeName, suffix) => {
   const vName = validatorName(typeName);
   if (!isSchemaObject3(schema)) {
     return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join(`
 `);
   }
   if (hasRef(schema)) {
-    const delegateName = validatorName(refToName(schema.$ref));
+    const delegateName = validatorName(refToName(schema.$ref, suffix));
     return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  return ${delegateName}(input, _path)`,
@@ -1244,7 +1272,7 @@ var generateScalarValidator = (schema, typeName) => {
     const branches = schema.oneOf.map((branch, i) => {
       if (!hasRef(branch))
         return null;
-      const bName = validatorName(refToName(branch.$ref));
+      const bName = validatorName(refToName(branch.$ref, suffix));
       return `  const _r${i} = ${bName}(input, _path)
   if (_r${i} === true) return true`;
     }).filter(Boolean).join(`
@@ -1314,21 +1342,23 @@ var generateScalarValidator = (schema, typeName) => {
   return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join(`
 `);
 };
-var generateValidatorFunction = (schema, typeName) => {
+var generateValidatorFunction = (schema, typeName, suffix = "") => {
   if (isObjectSchema2(schema)) {
-    return generateObjectValidator(schema, typeName);
+    return generateObjectValidator(schema, typeName, suffix);
   }
-  return generateScalarValidator(schema, typeName);
+  return generateScalarValidator(schema, typeName, suffix);
 };
 
 // src/generators/generate-files.ts
 var generateValidatorFile = (schema, typeName, options) => {
+  const typeSuffix = options?.typeSuffix ?? "";
   const refImports = collectValidatorImports(schema, {
     selfRef: options?.selfRef,
-    rootSchema: options?.rootSchema
+    rootSchema: options?.rootSchema,
+    typeSuffix
   });
-  const typeDefinition = generateTypeDefinition(schema, typeName);
-  const validatorFunction = generateValidatorFunction(schema, typeName);
+  const typeDefinition = generateTypeDefinition(schema, typeName, { typeSuffix });
+  const validatorFunction = generateValidatorFunction(schema, typeName, typeSuffix);
   let result = `import type { ValidationResult, ValidationError } from './validation-result'
 `;
   for (const imp of refImports) {
@@ -1365,7 +1395,7 @@ export type ValidationError = {
  */
 export type ValidationResult = true | { valid: false; errors: ValidationError[] }
 `;
-var buildValidatorSchema = async (rootSchema, rootTypeName) => {
+var buildValidatorSchema = async (rootSchema, rootTypeName, typeSuffix = "") => {
   rootSchema = upgradeDraft07Schema(rootSchema);
   const files = [];
   const processedRefs = new Set;
@@ -1374,7 +1404,8 @@ var buildValidatorSchema = async (rootSchema, rootTypeName) => {
   const dynamicRefMap = buildDynamicRefMap(rootSchema);
   const processedRootSchema = resolveDynamicRefs(rootSchema, dynamicRefMap);
   const rootContent = generateValidatorFile(processedRootSchema, rootTypeName, {
-    rootSchema
+    rootSchema,
+    typeSuffix
   });
   const rootFilename = rootTypeName.toLowerCase();
   if (rootFilename !== "validation-result") {
@@ -1393,12 +1424,13 @@ var buildValidatorSchema = async (rootSchema, rootTypeName) => {
       console.warn(`Warning: Could not resolve ref: ${ref}`);
       continue;
     }
-    const typeName = refToName(ref);
+    const typeName = refToName(ref, typeSuffix);
     const filename = refToFilename(ref);
     const processedSchema = resolveDynamicRefs(resolvedSchema, dynamicRefMap);
     const content = generateValidatorFile(processedSchema, typeName, {
       selfRef: ref,
-      rootSchema
+      rootSchema,
+      typeSuffix
     });
     if (filename !== "validation-result" && !processedFilenames.has(filename)) {
       processedFilenames.add(filename);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Generate TypeScript validation functions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -47,7 +47,7 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.5.0"
+    "@amritk/helpers": "0.6.1"
   },
   "devDependencies": {
     "@scalar/openapi-parser": "^0.26.1"

package/src/generators/build-schema.test.ts

@@ -74,7 +74,7 @@ describe('build-schema', () => {
     const documentFile = files.find((f) => f.filename === 'document.ts')
 
     expect(documentFile?.content).toContain("from './info'")
-    expect(documentFile?.content).toContain('validateInfoObject')
+    expect(documentFile?.content).toContain('validateInfo')
   })
 
   it('generates a valid index.ts with re-exports', async () => {
@@ -136,7 +136,7 @@ describe('build-schema', () => {
     const infoFile = files.find((f) => f.filename === 'info.ts')
 
     expect(documentFile?.content).toContain('validateDocument')
-    expect(infoFile?.content).toContain('validateInfoObject')
+    expect(infoFile?.content).toContain('validateInfo')
 
     // Cross-check: @scalar/openapi-parser says a complete document is valid
     const validDoc = { openapi: '3.1.0', info: { title: 'API', version: '1.0' }, paths: {} }

package/src/generators/build-schema.ts

@@ -55,7 +55,11 @@ export type ValidationResult = true | { valid: false; errors: ValidationError[]
  * // files → [{ filename: 'document.ts', content: '...' }, { filename: 'info.ts', ... }, ...]
  * ```
  */
-export const buildValidatorSchema = async (rootSchema: JSONSchema, rootTypeName: string): Promise<GeneratedFile[]> => {
+export const buildValidatorSchema = async (
+  rootSchema: JSONSchema,
+  rootTypeName: string,
+  typeSuffix = '',
+): Promise<GeneratedFile[]> => {
   rootSchema = upgradeDraft07Schema(rootSchema as Record<string, unknown>) as JSONSchema
 
   const files: GeneratedFile[] = []
@@ -69,6 +73,7 @@ export const buildValidatorSchema = async (rootSchema: JSONSchema, rootTypeName:
   const processedRootSchema = resolveDynamicRefs(rootSchema, dynamicRefMap)
   const rootContent = generateValidatorFile(processedRootSchema, rootTypeName, {
     rootSchema: rootSchema as Record<string, unknown>,
+    typeSuffix,
   })
   const rootFilename = rootTypeName.toLowerCase()
 
@@ -91,12 +96,13 @@ export const buildValidatorSchema = async (rootSchema: JSONSchema, rootTypeName:
       continue
     }
 
-    const typeName = refToName(ref)
+    const typeName = refToName(ref, typeSuffix)
     const filename = refToFilename(ref)
     const processedSchema = resolveDynamicRefs(resolvedSchema as JSONSchema, dynamicRefMap)
     const content = generateValidatorFile(processedSchema, typeName, {
       selfRef: ref,
       rootSchema: rootSchema as Record<string, unknown>,
+      typeSuffix,
     })
 
     if (filename !== 'validation-result' && !processedFilenames.has(filename)) {

package/src/generators/collect-validator-imports.ts

@@ -18,15 +18,20 @@ type CollectValidatorImportsOptions = {
    * are excluded from the import list (they were never generated as files).
    */
   readonly rootSchema?: Record<string, unknown> | undefined
+  /**
+   * Suffix appended to every type/validator name derived from a `$ref`. Must
+   * match the suffix used when generating the referenced files. Defaults to `''`.
+   */
+  readonly typeSuffix?: string
 }
 
 /**
  * Generates an import statement for a single $ref, importing both the type
  * and the validator function from the ref's generated file.
  */
-const buildImport = (ref: string): string => {
+const buildImport = (ref: string, suffix: string): string => {
   const filename = refToFilename(ref)
-  const typeName = refToName(ref)
+  const typeName = refToName(ref, suffix)
   const validatorName = `validate${typeName}`
   return `import { type ${typeName}, ${validatorName} } from './${filename}'`
 }
@@ -94,12 +99,13 @@ const collectDirectRefs = (schema: JSONSchema): string[] => {
  * ```typescript
  * const schema = { properties: { contact: { $ref: '#/$defs/contact' } } }
  * collectValidatorImports(schema)
- * // ["import { type ContactObject, validateContactObject } from './contact-object'"]
+ * // ["import { type Contact, validateContact } from './contact'"]
  * ```
  */
 export const collectValidatorImports = (schema: JSONSchema, options?: CollectValidatorImportsOptions): string[] => {
   const selfFilename = options?.selfRef ? refToFilename(options.selfRef) : null
   const rootSchema = options?.rootSchema
+  const typeSuffix = options?.typeSuffix ?? ''
 
   const refs = collectDirectRefs(schema)
   const seen = new Set<string>()
@@ -121,7 +127,7 @@ export const collectValidatorImports = (schema: JSONSchema, options?: CollectVal
 
     // -or-reference unions import the base type's validator
     const importRef = ref.endsWith('-or-reference') ? ref.replace('-or-reference', '') : ref
-    imports.push(buildImport(importRef))
+    imports.push(buildImport(importRef, typeSuffix))
   }
 
   return imports

package/src/generators/generate-files.ts

@@ -17,6 +17,11 @@ type GenerateValidatorFileOptions = {
    * The root schema document. Used to filter out unresolvable refs.
    */
   readonly rootSchema?: Record<string, unknown>
+  /**
+   * Suffix appended to every type/validator name derived from a `$ref`.
+   * Defaults to `''` (no suffix).
+   */
+  readonly typeSuffix?: string
 }
 
 /**
@@ -46,13 +51,15 @@ export const generateValidatorFile = (
   typeName: string,
   options?: GenerateValidatorFileOptions,
 ): string => {
+  const typeSuffix = options?.typeSuffix ?? ''
   const refImports = collectValidatorImports(schema, {
     selfRef: options?.selfRef,
     rootSchema: options?.rootSchema,
+    typeSuffix,
   })
 
-  const typeDefinition = generateTypeDefinition(schema, typeName)
-  const validatorFunction = generateValidatorFunction(schema, typeName)
+  const typeDefinition = generateTypeDefinition(schema, typeName, { typeSuffix })
+  const validatorFunction = generateValidatorFunction(schema, typeName, typeSuffix)
 
   let result = `import type { ValidationResult, ValidationError } from './validation-result'\n`
 

package/src/generators/generate-validator-function.test.ts

@@ -135,7 +135,7 @@ describe('generate-validator-function', () => {
     }
     const code = generateValidatorFunction(schema, 'Document')
 
-    expect(code).toContain('validateInfoObject(')
+    expect(code).toContain('validateInfo(')
     expect(code).toContain('"info" in obj')
   })
 

package/src/generators/generate-validator-function.ts

@@ -61,7 +61,7 @@ const wrongTypeCondition = (accessor: string, type: string): string => {
  * Generates validation lines for a single property in an object schema.
  * Handles $ref delegation, enum checks, type checks, and string/number constraints.
  */
-const generatePropertyChecks = (key: string, propSchema: JSONSchema, isRequired: boolean): string[] => {
+const generatePropertyChecks = (key: string, propSchema: JSONSchema, isRequired: boolean, suffix: string): string[] => {
   if (!isSchemaObject(propSchema)) return []
 
   const raw = `obj[${JSON.stringify(key)}]`
@@ -71,7 +71,7 @@ const generatePropertyChecks = (key: string, propSchema: JSONSchema, isRequired:
   // $ref — delegate to the imported validator
   if (hasRef(propSchema)) {
     const ref = propSchema.$ref
-    const vName = validatorName(refToName(ref))
+    const vName = validatorName(refToName(ref, suffix))
 
     if (isRequired) {
       lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`)
@@ -218,7 +218,7 @@ const generatePropertyChecks = (key: string, propSchema: JSONSchema, isRequired:
     if (t === 'array' && hasItems(propSchema)) {
       const itemSchema = propSchema.items
       if (hasRef(itemSchema)) {
-        const vName = validatorName(refToName(itemSchema.$ref))
+        const vName = validatorName(refToName(itemSchema.$ref, suffix))
         lines.push(`  if (Array.isArray(${raw})) {`)
         lines.push(`    for (let _i = 0; _i < ${raw}.length; _i++) {`)
         lines.push(`      const _ir = ${vName}(${raw}[_i], \`${path.slice(1, -1)}/${key}/\${_i}\`)`)
@@ -250,7 +250,7 @@ const generatePropertyChecks = (key: string, propSchema: JSONSchema, isRequired:
  * Generates a validator function body for an object schema, checking each
  * property's presence and type and collecting all errors.
  */
-const generateObjectValidator = (schema: JSONSchema, typeName: string): string => {
+const generateObjectValidator = (schema: JSONSchema, typeName: string, suffix: string): string => {
   const vName = validatorName(typeName)
   const required = new Set(hasRequired(schema) ? schema.required : [])
   const properties = hasProperties(schema) ? schema.properties : {}
@@ -258,7 +258,7 @@ const generateObjectValidator = (schema: JSONSchema, typeName: string): string =
   const propertyLines: string[] = []
 
   for (const [key, propSchema] of Object.entries(properties)) {
-    const checks = generatePropertyChecks(key, propSchema as JSONSchema, required.has(key))
+    const checks = generatePropertyChecks(key, propSchema as JSONSchema, required.has(key), suffix)
     if (checks.length > 0) {
       propertyLines.push(...checks)
     }
@@ -270,7 +270,7 @@ const generateObjectValidator = (schema: JSONSchema, typeName: string): string =
     isSchemaObject(schema.additionalProperties) &&
     hasRef(schema.additionalProperties)
   ) {
-    const vRefName = validatorName(refToName(schema.additionalProperties.$ref))
+    const vRefName = validatorName(refToName(schema.additionalProperties.$ref, suffix))
     propertyLines.push(`  for (const _key of Object.keys(obj)) {`)
     propertyLines.push(`    if (${JSON.stringify(Object.keys(properties))}.includes(_key)) continue`)
     propertyLines.push(`    const _r = ${vRefName}(obj[_key as keyof typeof obj], \`\${_path}/\${_key}\`)`)
@@ -297,7 +297,7 @@ const generateObjectValidator = (schema: JSONSchema, typeName: string): string =
 /**
  * Generates a validator function for a non-object schema (primitive, array, enum, $ref).
  */
-const generateScalarValidator = (schema: JSONSchema, typeName: string): string => {
+const generateScalarValidator = (schema: JSONSchema, typeName: string, suffix: string): string => {
   const vName = validatorName(typeName)
 
   if (!isSchemaObject(schema)) {
@@ -308,7 +308,7 @@ const generateScalarValidator = (schema: JSONSchema, typeName: string): string =
 
   // Top-level $ref — delegate entirely
   if (hasRef(schema)) {
-    const delegateName = validatorName(refToName(schema.$ref))
+    const delegateName = validatorName(refToName(schema.$ref, suffix))
     return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  return ${delegateName}(input, _path)`,
@@ -361,7 +361,7 @@ const generateScalarValidator = (schema: JSONSchema, typeName: string): string =
     const branches = schema.oneOf
       .map((branch, i) => {
         if (!hasRef(branch)) return null
-        const bName = validatorName(refToName((branch as { $ref: string }).$ref))
+        const bName = validatorName(refToName((branch as { $ref: string }).$ref, suffix))
         return `  const _r${i} = ${bName}(input, _path)\n  if (_r${i} === true) return true`
       })
       .filter(Boolean)
@@ -463,10 +463,10 @@ const generateScalarValidator = (schema: JSONSchema, typeName: string): string =
  * // }
  * ```
  */
-export const generateValidatorFunction = (schema: JSONSchema, typeName: string): string => {
+export const generateValidatorFunction = (schema: JSONSchema, typeName: string, suffix = ''): string => {
   if (isObjectSchema(schema)) {
-    return generateObjectValidator(schema, typeName)
+    return generateObjectValidator(schema, typeName, suffix)
   }
 
-  return generateScalarValidator(schema, typeName)
+  return generateScalarValidator(schema, typeName, suffix)
 }