@amritk/generate-parsers 0.5.0 → 0.6.0

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

@@ -40,6 +40,9 @@ export type GeneratedFile = {
  *   directory while the helper sources are emitted once at the output root.
  * @param readonly - When true, every property, array, and record in the generated type
  *   definitions is emitted as `readonly`.
+ * @param typeSuffix - Suffix appended to every type/parser name derived from a `$ref`
+ *   (e.g. `'Object'` → `ContactObject`). Defaults to `''` (no suffix). The root type name
+ *   is used verbatim and is not affected by this suffix.
  * @returns An array of generated TypeScript files
  *
  * @example
@@ -72,4 +75,4 @@ export type GeneratedFile = {
  * });
  * ```
  */
-export declare const buildSchema: (rootSchema: JSONSchema, rootTypeName: string, extensions?: SchemaExtensions, typesOnly?: boolean, logWarnings?: boolean, strict?: boolean, helpersMode?: HelpersMode, helpersImportPrefix?: string, readonly?: boolean) => Promise<GeneratedFile[]>;
+export declare const buildSchema: (rootSchema: JSONSchema, rootTypeName: string, extensions?: SchemaExtensions, typesOnly?: boolean, logWarnings?: boolean, strict?: boolean, helpersMode?: HelpersMode, helpersImportPrefix?: string, readonly?: boolean, typeSuffix?: string) => Promise<GeneratedFile[]>;

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

@@ -49,6 +49,11 @@ type GenerateFileOptions = {
      * definitions is emitted as `readonly`.
      */
     readonly readonly?: boolean;
+    /**
+     * Suffix appended to every type/parser name derived from a `$ref`.
+     * Defaults to `''` (no suffix). Set to e.g. `'Object'` to emit `ContactObject`.
+     */
+    readonly typeSuffix?: string;
 };
 /** Result of generating a single parser file. */
 export type GeneratedFileContent = {

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

@@ -20,6 +20,11 @@ type GenerateParserOptions = {
      * with a path-aware Error. Unknown extra keys are still allowed.
      */
     readonly strict?: boolean;
+    /**
+     * Suffix appended to every type/parser name derived from a `$ref`. Must match
+     * the suffix used when generating the referenced files. Defaults to `''`.
+     */
+    readonly typeSuffix?: string;
 };
 /**
  * Generates a safe parser as an arrow function that never throws.
@@ -49,5 +54,5 @@ export declare const shapeValidatorFunctionName: (typeName: string) => string;
  * in additionalProperties). The stub is safe: parents calling it will fall
  * through to the slow path, matching the pre-deep-fast-path behavior.
  */
-export declare const generateShapeValidator: (schema: JSONSchema, typeName: string, useRefImports: boolean) => string;
+export declare const generateShapeValidator: (schema: JSONSchema, typeName: string, useRefImports: boolean, suffix?: string) => string;
 export {};

package/dist/helpers/collect-imports.d.ts

@@ -20,6 +20,12 @@ type CollectImportsOptions = {
      * imports for external schemas that were never generated as files.
      */
     readonly rootSchema?: Record<string, unknown> | undefined;
+    /**
+     * Suffix appended to every type name derived from a `$ref`. Must match the
+     * suffix used when generating the referenced files so imports resolve.
+     * Defaults to `''` (no suffix).
+     */
+    readonly typeSuffix?: string;
 };
 /**
  * Collects all import statements needed for a schema by finding $ref references

package/dist/index.js

@@ -137,15 +137,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) => {
@@ -439,15 +439,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)) {
@@ -565,13 +565,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);
@@ -618,7 +618,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;
   }
@@ -811,12 +811,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) {
@@ -826,7 +826,7 @@ var generateTypeDefinition = (schema, typeName, options = {}) => {
 ` + properties + `
 }`;
     if (conditionalThenRef) {
-      typeBody += " & " + refToName2(conditionalThenRef);
+      typeBody += " & " + refToName2(conditionalThenRef, options.typeSuffix);
     }
     for (const intersectionType of allOfIntersections) {
       typeBody += " & " + intersectionType;
@@ -967,6 +967,7 @@ var collectImports = (schema, options) => {
   const typesOnly = options?.typesOnly === true;
   const selfFilename = options?.selfRef ? refToFilename(options.selfRef) : undefined;
   const rootSchema = options?.rootSchema;
+  const typeSuffix = options?.typeSuffix;
   const refs = new Set;
   const collectRefsFromValue = (value) => {
     if (typeof value !== "object" || value === null) {
@@ -1094,7 +1095,7 @@ var collectImports = (schema, options) => {
       if (!resolveRef(ref, rootSchema))
         continue;
     }
-    const typeName = refToName(ref);
+    const typeName = refToName(ref, typeSuffix);
     const filename = refToFilename(ref);
     if (selfFilename !== undefined && filename === selfFilename) {
       continue;
@@ -1786,33 +1787,33 @@ var isPropertyRequired = (key, schema) => {
   }
   return schema.required.includes(key);
 };
-var generateRequiredRefCall = (key, ref) => {
+var generateRequiredRefCall = (key, ref, suffix) => {
   const acc = safeAccessor("input", key);
-  const parserName = generateParserName(refToName(ref));
+  const parserName = generateParserName(refToName(ref, suffix));
   return `${parserName}(${acc})`;
 };
-var generateOptionalRefCall = (key, ref) => {
+var generateOptionalRefCall = (key, ref, suffix) => {
   const acc = safeAccessor("input", key);
-  const parserName = generateParserName(refToName(ref));
+  const parserName = generateParserName(refToName(ref, suffix));
   return `...(${acc} && { ${safeKey2(key)}: ${parserName}(${acc}) })`;
 };
-var generateRequiredArrayRefCall = (key, ref) => {
-  const parserName = generateParserName(refToName(ref));
+var generateRequiredArrayRefCall = (key, ref, suffix) => {
+  const parserName = generateParserName(refToName(ref, suffix));
   return `validateArray(${safeAccessor("input", key)}, ${parserName})`;
 };
-var generateOptionalArrayRefCall = (key, ref) => {
-  const parserName = generateParserName(refToName(ref));
+var generateOptionalArrayRefCall = (key, ref, suffix) => {
+  const parserName = generateParserName(refToName(ref, suffix));
   const acc = safeAccessor("input", key);
   return `...(${acc} && { ${safeKey2(key)}: validateArray(${acc}, ${parserName}) })`;
 };
-var generateRequiredRecordRefCall = (key, ref) => {
+var generateRequiredRecordRefCall = (key, ref, suffix) => {
   const acc = safeAccessor("input", key);
-  const parserName = generateParserName(refToName(ref));
+  const parserName = generateParserName(refToName(ref, suffix));
   return `validateRecord(${acc}, ${parserName})`;
 };
-var generateOptionalRecordRefCall = (key, ref) => {
+var generateOptionalRecordRefCall = (key, ref, suffix) => {
   const acc = safeAccessor("input", key);
-  const parserName = generateParserName(refToName(ref));
+  const parserName = generateParserName(refToName(ref, suffix));
   return `...(${acc} && { ${safeKey2(key)}: validateRecord(${acc}, ${parserName}) })`;
 };
 var generateOptionalInlineProperty = (key, valueExpression) => {
@@ -1857,20 +1858,20 @@ var shouldUseRecordRefImport = (propSchema, useRefImports) => {
   const additionalProps = propSchema.additionalProperties;
   return isSchemaObject3(additionalProps) && hasRef(additionalProps);
 };
-var generatePropertyValue = (key, propSchema, isRequired, useRefImports) => {
+var generatePropertyValue = (key, propSchema, isRequired, useRefImports, suffix) => {
   if (shouldUseRefImport(propSchema, useRefImports)) {
     const ref = propSchema.$ref;
-    return isRequired ? generateRequiredRefCall(key, ref) : generateOptionalRefCall(key, ref);
+    return isRequired ? generateRequiredRefCall(key, ref, suffix) : generateOptionalRefCall(key, ref, suffix);
   }
   if (shouldUseArrayRefImport(propSchema, useRefImports)) {
     const items = propSchema.items;
     const ref = items.$ref;
-    return isRequired ? generateRequiredArrayRefCall(key, ref) : generateOptionalArrayRefCall(key, ref);
+    return isRequired ? generateRequiredArrayRefCall(key, ref, suffix) : generateOptionalArrayRefCall(key, ref, suffix);
   }
   if (shouldUseRecordRefImport(propSchema, useRefImports)) {
     const additionalProps = propSchema.additionalProperties;
     const ref = additionalProps.$ref;
-    return isRequired ? generateRequiredRecordRefCall(key, ref) : generateOptionalRecordRefCall(key, ref);
+    return isRequired ? generateRequiredRecordRefCall(key, ref, suffix) : generateOptionalRecordRefCall(key, ref, suffix);
   }
   if (!isSchemaObject3(propSchema)) {
     return isRequired ? "undefined" : generateOptionalInlineProperty(key, "undefined");
@@ -1879,23 +1880,23 @@ var generatePropertyValue = (key, propSchema, isRequired, useRefImports) => {
   const valueExpression = generateValidationExpression(key, propSchema, defaultValue, isRequired);
   return isRequired ? valueExpression : generateOptionalInlineProperty(key, valueExpression);
 };
-var generatePropertyEntries = (schema, useRefImports) => {
+var generatePropertyEntries = (schema, useRefImports, suffix) => {
   if (!hasProperties(schema)) {
     return [];
   }
   const entries = [];
   for (const [key, propSchema] of Object.entries(schema.properties)) {
     const isRequired = isPropertyRequired(key, schema);
-    const value = generatePropertyValue(key, propSchema, isRequired, useRefImports);
+    const value = generatePropertyValue(key, propSchema, isRequired, useRefImports, suffix);
     const isOptional = value.startsWith("...");
     entries.push({ key, value, isOptional });
   }
   return entries;
 };
-var generateFallbackValue = (_, propSchema, useRefImports) => {
+var generateFallbackValue = (_, propSchema, useRefImports, suffix) => {
   if (useRefImports && hasRef(propSchema)) {
     const ref = propSchema.$ref;
-    const parserName = generateParserName(refToName(ref));
+    const parserName = generateParserName(refToName(ref, suffix));
     return `${parserName}(undefined)`;
   }
   if (useRefImports && isSchemaObject3(propSchema) && propSchema.type === "array" && hasItems(propSchema) && hasRef(propSchema.items)) {
@@ -1938,7 +1939,7 @@ var generateFallbackValue = (_, propSchema, useRefImports) => {
       return "undefined";
   }
 };
-var generateFallbackObject = (schema, useRefImports, typeName) => {
+var generateFallbackObject = (schema, useRefImports, typeName, suffix) => {
   if (!hasProperties(schema)) {
     return `{} as ${typeName}`;
   }
@@ -1949,7 +1950,7 @@ var generateFallbackObject = (schema, useRefImports, typeName) => {
   for (const [key, propSchema] of Object.entries(schema.properties)) {
     const isRequired = isPropertyRequired(key, schema);
     if (isRequired) {
-      const fallbackValue = generateFallbackValue(key, propSchema, useRefImports);
+      const fallbackValue = generateFallbackValue(key, propSchema, useRefImports, suffix);
       if (fallbackValue === "undefined") {
         return `{} as ${typeName}`;
       }
@@ -2017,11 +2018,11 @@ var toVarName = (key) => {
   return `_${safe}`;
 };
 var shapeValidatorName = (typeName) => `validate${typeName}Shape`;
-var generatePropertyTypeCheck = (varName, schema, useRefImports) => {
+var generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
   if (!isSchemaObject3(schema))
     return null;
   if (useRefImports && hasRef(schema)) {
-    const refName = refToName(schema.$ref);
+    const refName = refToName(schema.$ref, suffix);
     return `${shapeValidatorName(refName)}(${varName})`;
   }
   if (hasEnum(schema) || hasOneOf(schema) || hasAnyOf(schema) || hasAllOf(schema) || hasRef(schema) || "not" in schema) {
@@ -2030,7 +2031,7 @@ var generatePropertyTypeCheck = (varName, schema, useRefImports) => {
   if (!hasType(schema))
     return null;
   if (useRefImports && schema.type === "array" && hasItems(schema) && isSchemaObject3(schema.items) && hasRef(schema.items)) {
-    const refName = refToName(schema.items.$ref);
+    const refName = refToName(schema.items.$ref, suffix);
     return `Array.isArray(${varName}) && ${varName}.every(${shapeValidatorName(refName)})`;
   }
   const checks = [];
@@ -2091,7 +2092,7 @@ var generatePropertyTypeCheck = (varName, schema, useRefImports) => {
 var shouldCacheVariable = (propSchema, _canFastPath, _useRefImports) => {
   return isSchemaObject3(propSchema);
 };
-var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict) => {
+var generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict) => {
   const functionName = generateParserName(typeName);
   if (!hasProperties(schema)) {
     if (strict) {
@@ -2102,7 +2103,7 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict
     }
     return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? input as ${typeName} : {} as ${typeName};`;
   }
-  const fallbackObject = generateFallbackObject(schema, useRefImports, typeName);
+  const fallbackObject = generateFallbackObject(schema, useRefImports, typeName, suffix);
   const properties = Object.entries(schema.properties);
   const lines = [];
   lines.push(`export const ${functionName} = (input: unknown): ${typeName} => {`);
@@ -2125,7 +2126,7 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict
       if (shouldUseRecordRefImport(propSchema, useRefImports)) {
         canFastPath = false;
       } else {
-        const check = generatePropertyTypeCheck(varName, propSchema, useRefImports);
+        const check = generatePropertyTypeCheck(varName, propSchema, useRefImports, suffix);
         if (check === null) {
           canFastPath = false;
         } else {
@@ -2164,7 +2165,7 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict
   if (useRefImports && isSchemaObject3(schema) && hasAllOf(schema)) {
     for (const entry of schema.allOf) {
       if (isSchemaObject3(entry) && hasRef(entry)) {
-        const parserName = generateParserName(refToName(entry.$ref));
+        const parserName = generateParserName(refToName(entry.$ref, suffix));
         objectLines.push(`    ...(${parserName}(input) as Record<string, unknown>),`);
       }
     }
@@ -2174,7 +2175,7 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict
     const accessor = shouldCache ? varName : safeAccessor("input", key);
     if (shouldUseRefImport(propSchema, useRefImports)) {
       const ref = propSchema.$ref;
-      const parserName = generateParserName(refToName(ref));
+      const parserName = generateParserName(refToName(ref, suffix));
       if (isRequired) {
         objectLines.push(`    ${safeKey2(key)}: ${parserName}(${accessor}),`);
       } else {
@@ -2185,7 +2186,7 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict
     if (shouldUseArrayRefImport(propSchema, useRefImports)) {
       const items = propSchema.items;
       const ref = items.$ref;
-      const parserName = generateParserName(refToName(ref));
+      const parserName = generateParserName(refToName(ref, suffix));
       if (isRequired) {
         objectLines.push(`    ${safeKey2(key)}: validateArray(${accessor}, ${parserName}),`);
       } else {
@@ -2196,7 +2197,7 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict
     if (shouldUseRecordRefImport(propSchema, useRefImports)) {
       const additionalProps = propSchema.additionalProperties;
       const ref = additionalProps.$ref;
-      const parserName = generateParserName(refToName(ref));
+      const parserName = generateParserName(refToName(ref, suffix));
       if (isRequired) {
         objectLines.push(`    ${safeKey2(key)}: validateRecord(${accessor}, ${parserName}),`);
       } else {
@@ -2235,9 +2236,9 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict
   }
   return result;
 };
-var generateCombinedObjectParser = (schema, typeName, useRefImports, logWarnings, strict) => {
+var generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict) => {
   const functionName = generateParserName(typeName);
-  const entries = generatePropertyEntries(schema, useRefImports);
+  const entries = generatePropertyEntries(schema, useRefImports, suffix);
   const propertyLines = entries.map((entry) => {
     if (entry.isOptional) {
       return `    ${entry.value},`;
@@ -2245,17 +2246,17 @@ var generateCombinedObjectParser = (schema, typeName, useRefImports, logWarnings
     return `    ${safeKey2(entry.key)}: ${entry.value},`;
   });
   if (!isSchemaObject3(schema) || !("patternProperties" in schema)) {
-    return generateObjectParser(schema, typeName, useRefImports, logWarnings, strict);
+    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict);
   }
   const patternProps = schema.patternProperties;
   const patterns = Object.entries(patternProps);
   const refPattern = patterns.find(([, ps]) => isSchemaObject3(ps) && hasRef(ps));
   if (!refPattern || !useRefImports) {
-    return generateObjectParser(schema, typeName, useRefImports, logWarnings, strict);
+    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict);
   }
   const [pattern, patternSchema] = refPattern;
   const ref = patternSchema.$ref;
-  const parserName = generateParserName(refToName(ref));
+  const parserName = generateParserName(refToName(ref, suffix));
   const assignmentCode = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
   const escapedPattern = escapeRegexPattern2(pattern);
   const inputSpread = "    ...input,";
@@ -2283,7 +2284,7 @@ ${objectProperties}
   return result;
 };`;
 };
-var generateAdditionalPropertiesParser = (schema, typeName, useRefImports, strict) => {
+var generateAdditionalPropertiesParser = (schema, typeName, useRefImports, suffix, strict) => {
   const functionName = generateParserName(typeName);
   const additionalProps = schema.additionalProperties;
   if (!additionalProps) {
@@ -2291,7 +2292,7 @@ var generateAdditionalPropertiesParser = (schema, typeName, useRefImports, stric
   }
   if (useRefImports && isSchemaObject3(additionalProps) && hasRef(additionalProps)) {
     const ref = additionalProps.$ref;
-    const parserName = generateParserName(refToName(ref));
+    const parserName = generateParserName(refToName(ref, suffix));
     if (strict) {
       return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);
@@ -2341,7 +2342,7 @@ var generateInlineValueParser = (schema) => {
 var escapeRegexPattern2 = (pattern) => {
   return pattern.replace(/\\/g, "\\\\").replace(/\//g, "\\/");
 };
-var generatePatternPropertiesParser = (schema, typeName, useRefImports, strict) => {
+var generatePatternPropertiesParser = (schema, typeName, useRefImports, suffix, strict) => {
   const functionName = generateParserName(typeName);
   if (!("patternProperties" in schema) || typeof schema.patternProperties !== "object") {
     return generateEmptyObjectParser(typeName, strict);
@@ -2355,7 +2356,7 @@ var generatePatternPropertiesParser = (schema, typeName, useRefImports, strict)
   let patternAssignment = "(result as Record<string, unknown>)[key] = value;";
   if (useRefImports && isSchemaObject3(patternSchema) && hasRef(patternSchema)) {
     const ref = patternSchema.$ref;
-    const parserName = generateParserName(refToName(ref));
+    const parserName = generateParserName(refToName(ref, suffix));
     patternAssignment = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
   } else if (patternSchema === false) {
     patternAssignment = "";
@@ -2378,7 +2379,7 @@ ${notObjectBranch}
   return result;
 };`;
 };
-var generateConditionalParser = (schema, typeName) => {
+var generateConditionalParser = (schema, typeName, suffix) => {
   const functionName = generateParserName(typeName);
   const ifSchema = schema.if;
   const thenSchema = schema.then;
@@ -2388,7 +2389,7 @@ var generateConditionalParser = (schema, typeName) => {
   if (!thenHasRef || !elseHasRef) {
     const mergedSchema = getConditionalObjectSchema2(schema);
     if (mergedSchema) {
-      return generateObjectParser(mergedSchema, typeName, false);
+      return generateObjectParser(mergedSchema, typeName, false, suffix);
     }
     return generateEmptyObjectParser(typeName);
   }
@@ -2396,15 +2397,15 @@ var generateConditionalParser = (schema, typeName) => {
   if (!isRefCondition) {
     const mergedSchema = getConditionalObjectSchema2(schema);
     if (mergedSchema) {
-      return generateObjectParser(mergedSchema, typeName, false);
+      return generateObjectParser(mergedSchema, typeName, false, suffix);
     }
     return generateEmptyObjectParser(typeName);
   }
   const thenRef = thenSchema.$ref;
   const elseRef = elseSchema.$ref;
-  const thenParserName = generateParserName(refToName(thenRef));
-  const elseParserName = generateParserName(refToName(elseRef));
-  const thenTypeName = refToName(thenRef);
+  const thenParserName = generateParserName(refToName(thenRef, suffix));
+  const elseParserName = generateParserName(refToName(elseRef, suffix));
+  const thenTypeName = refToName(thenRef, suffix);
   return `export const ${functionName} = (input: unknown): ${typeName} | ${thenTypeName} =>
   hasRef(input) ? ${thenParserName}(input) : ${elseParserName}(input)
       `;
@@ -2477,7 +2478,8 @@ var selectParserStrategy = (schema, typeName, options) => {
   const useRefImports = options?.useRefImports ?? false;
   const logWarnings = options?.logWarnings ?? false;
   const strict = options?.strict ?? false;
-  if (typeName === "SchemaObject") {
+  const suffix = options?.typeSuffix ?? "";
+  if (typeName === `Schema${suffix}`) {
     return generateSchemaObjectParser(typeName);
   }
   const isObjectLikeSchema2 = isObjectSchema2(schema) || isSchemaObject3(schema) && (("patternProperties" in schema) || ("additionalProperties" in schema));
@@ -2485,30 +2487,30 @@ var selectParserStrategy = (schema, typeName, options) => {
     return generateNonObjectParser(typeName, schema, strict);
   }
   if (hasProperties(schema) && isSchemaObject3(schema) && "patternProperties" in schema) {
-    return generateCombinedObjectParser(schema, typeName, useRefImports, logWarnings, strict);
+    return generateCombinedObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict);
   }
   if (hasProperties(schema)) {
-    return generateObjectParser(schema, typeName, useRefImports, logWarnings, strict);
+    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict);
   }
   if (isSchemaObject3(schema) && "if" in schema && "then" in schema && "else" in schema) {
-    return generateConditionalParser(schema, typeName);
+    return generateConditionalParser(schema, typeName, suffix);
   }
   const conditionalObjectSchema = getConditionalObjectSchema2(schema);
   if (conditionalObjectSchema) {
-    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, logWarnings, strict);
+    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, suffix, logWarnings, strict);
   }
   if (!isObjectLikeSchema2) {
     return generateNonObjectParser(typeName, schema, strict);
   }
   if ("patternProperties" in schema) {
-    return generatePatternPropertiesParser(schema, typeName, useRefImports, strict);
+    return generatePatternPropertiesParser(schema, typeName, useRefImports, suffix, strict);
   }
   if ("additionalProperties" in schema && !hasProperties(schema)) {
     const additionalProps = schema.additionalProperties;
     if (additionalProps === true || additionalProps === false) {
       return generateEmptyObjectParser(typeName, strict);
     }
-    return generateAdditionalPropertiesParser(schema, typeName, useRefImports, strict);
+    return generateAdditionalPropertiesParser(schema, typeName, useRefImports, suffix, strict);
   }
   if ("type" in schema && schema.type === "object" && !hasProperties(schema)) {
     return generateEmptyObjectParser(typeName, strict);
@@ -2518,7 +2520,7 @@ var selectParserStrategy = (schema, typeName, options) => {
 var generateParserFunction = (schema, typeName, options) => {
   return selectParserStrategy(schema, typeName, options);
 };
-var generateShapeValidator = (schema, typeName, useRefImports) => {
+var generateShapeValidator = (schema, typeName, useRefImports, suffix = "") => {
   const fnName = shapeValidatorName(typeName);
   const stub = `export const ${fnName} = (_input: unknown): boolean => false;`;
   if (!isSchemaObject3(schema))
@@ -2536,7 +2538,7 @@ var generateShapeValidator = (schema, typeName, useRefImports) => {
     }
     const accessor = safeAccessor("input", key);
     const isRequired = isPropertyRequired(key, schema);
-    const check = generatePropertyTypeCheck(accessor, propSchema, useRefImports);
+    const check = generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
     if (check === null) {
       return stub;
     }
@@ -2566,9 +2568,10 @@ var generateFile = (schema, typeName, options) => {
   const selfRef = options?.selfRef;
   const rootSchema = options?.rootSchema;
   const helpersMode = options?.helpersMode ?? "package";
-  const typeDefinition = generateTypeDefinition(schema, typeName, { readonly: options?.readonly ?? false });
+  const typeSuffix = options?.typeSuffix ?? "";
+  const typeDefinition = generateTypeDefinition(schema, typeName, { readonly: options?.readonly ?? false, typeSuffix });
   if (typesOnly) {
-    const imports2 = collectImports(schema, { typesOnly: true, selfRef, rootSchema });
+    const imports2 = collectImports(schema, { typesOnly: true, selfRef, rootSchema, typeSuffix });
     let result2 = "";
     if (imports2.length > 0) {
       result2 += imports2[0];
@@ -2584,15 +2587,16 @@ var generateFile = (schema, typeName, options) => {
   }
   const parserFunction = generateParserFunction(schema, typeName, {
     useRefImports: true,
+    typeSuffix,
     ...options?.logWarnings !== undefined ? { logWarnings: options.logWarnings } : {},
     ...options?.strict !== undefined ? { strict: options.strict } : {}
   });
-  const shapeValidator = generateShapeValidator(schema, typeName, true);
+  const shapeValidator = generateShapeValidator(schema, typeName, true, typeSuffix);
   const combinedFunctions = `${shapeValidator}
 
 ${parserFunction}`;
   const helpers = collectHelpers(combinedFunctions, helpersMode, options?.helpersImportPrefix);
-  const imports = [...collectImports(schema, { selfRef, rootSchema }), ...helpers.imports];
+  const imports = [...collectImports(schema, { selfRef, rootSchema, typeSuffix }), ...helpers.imports];
   let result = "";
   if (imports.length > 0) {
     result += imports[0];
@@ -2635,7 +2639,7 @@ var extractDynamicAnchorDefs = (schema) => {
   }
   return refs;
 };
-var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict, helpersMode = "package", helpersImportPrefix = "./", readonly = false) => {
+var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict, helpersMode = "package", helpersImportPrefix = "./", readonly = false, typeSuffix = "") => {
   rootSchema = upgradeDraft07Schema(rootSchema);
   const files = [];
   const processedRefs = new Set;
@@ -2651,6 +2655,7 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
     helpersMode,
     helpersImportPrefix,
     readonly,
+    typeSuffix,
     ...logWarnings !== undefined ? { logWarnings } : {},
     ...strict !== undefined ? { strict } : {}
   });
@@ -2677,7 +2682,7 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
       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 extendedSchema = extensions ? applySchemaExtensions(processedSchema, filename, extensions) : processedSchema;
@@ -2688,6 +2693,7 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
       helpersMode,
       helpersImportPrefix,
       readonly,
+      typeSuffix,
       ...logWarnings !== undefined ? { logWarnings } : {},
       ...strict !== undefined ? { strict } : {}
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -49,7 +49,7 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.5.0",
+    "@amritk/helpers": "0.6.0",
     "@amritk/generate-markdown": "0.2.1"
   }
 }