@cerios/openapi-to-zod 1.0.0 → 1.1.1

package/README.md

@@ -187,6 +187,7 @@ Examples:
 | `schemaType` | `"all"` \| `"request"` \| `"response"` | Schema filtering |
 | `prefix` | `string` | Prefix for schema names |
 | `suffix` | `string` | Suffix for schema names |
+| `stripSchemaPrefix` | `string` | Strip prefix from schema names before generating using glob patterns (e.g., `"Company.Models."` or `"*.Models."`) |
 | `showStats` | `boolean` | Include generation statistics |
 | `request` | `object` | Request-specific options (mode, includeDescriptions, useDescribe) |
 | `response` | `object` | Response-specific options (mode, includeDescriptions, useDescribe) |
@@ -570,10 +571,46 @@ OpenAPI's `nullable: true` is converted to `.nullable()`
 
 ### Enums
 
-Enums are generated as Zod enums with:
-- Proper string value handling
-- Zod schema using `z.enum()`
-- TypeScript type inference from the Zod schema
+Enums are generated based on their value types:
+
+- **String enums**: `z.enum()` for type-safe string unions
+- **Numeric enums**: `z.union([z.literal(n), ...])` for proper number types
+- **Boolean enums**: `z.boolean()` for true/false values
+- **Mixed enums**: `z.union([z.literal(...), ...])` for heterogeneous values
+
+**Examples:**
+
+```yaml
+# String enum
+Status:
+  type: string
+  enum: [active, inactive, pending]
+
+# Integer enum
+Priority:
+  type: integer
+  enum: [0, 1, 2, 3]
+
+# Mixed enum
+Value:
+  enum: [0, "none", 1, "some"]
+```
+
+**Generated schemas:**
+
+```typescript
+// String enum → z.enum()
+export const statusSchema = z.enum(["active", "inactive", "pending"]);
+export type Status = z.infer<typeof statusSchema>; // "active" | "inactive" | "pending"
+
+// Integer enum → z.union with z.literal
+export const prioritySchema = z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3)]);
+export type Priority = z.infer<typeof prioritySchema>; // 0 | 1 | 2 | 3
+
+// Mixed enum → z.union with z.literal
+export const valueSchema = z.union([z.literal(0), z.literal("none"), z.literal(1), z.literal("some")]);
+export type Value = z.infer<typeof valueSchema>; // 0 | "none" | 1 | "some"
+```
 
 ## Schema Naming
 
@@ -598,6 +635,203 @@ This is useful when:
 - Following specific naming conventions (DTO, Model, Entity)
 - Avoiding naming conflicts with existing code
 
+### Schema Prefix Stripping
+
+The `stripSchemaPrefix` option removes common prefixes from schema names in your OpenAPI spec before generating Zod schemas. This is particularly useful when your OpenAPI spec uses namespaced schema names (like .NET-generated specs with "Company.Models.User").
+
+**OpenAPI Spec with Namespaced Schemas:**
+```yaml
+components:
+  schemas:
+    Company.Models.User:
+      type: object
+      properties:
+        id:
+          type: string
+        name:
+          type: string
+        role:
+          $ref: '#/components/schemas/Company.Models.UserRole'
+    Company.Models.UserRole:
+      type: string
+      enum: [admin, user, guest]
+    Company.Models.Post:
+      type: object
+      properties:
+        id:
+          type: string
+        title:
+          type: string
+        author:
+          $ref: '#/components/schemas/Company.Models.User'
+```
+
+**Without `stripSchemaPrefix`:**
+```typescript
+export const companyModelsUserRoleSchema = z.enum(["admin", "user", "guest"]);
+
+export const companyModelsUserSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  role: companyModelsUserRoleSchema  // Long reference name
+});
+
+export const companyModelsPostSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  author: companyModelsUserSchema  // Long reference name
+});
+
+export type CompanyModelsUserRole = z.infer<typeof companyModelsUserRoleSchema>;
+export type CompanyModelsUser = z.infer<typeof companyModelsUserSchema>;
+export type CompanyModelsPost = z.infer<typeof companyModelsPostSchema>;
+```
+
+**With `stripSchemaPrefix: "Company.Models."`:**
+```typescript
+export const userRoleSchema = z.enum(["admin", "user", "guest"]);
+
+export const userSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  role: userRoleSchema  // Clean reference
+});
+
+export const postSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  author: userSchema  // Clean reference
+});
+
+export type UserRole = z.infer<typeof userRoleSchema>;
+export type User = z.infer<typeof userSchema>;
+export type Post = z.infer<typeof postSchema>;
+```
+
+#### Usage
+
+```typescript
+export default defineConfig({
+  specs: [{
+    input: 'openapi.yaml',
+    output: 'schemas.ts',
+    stripSchemaPrefix: 'Company.Models.'  // Strip this exact prefix
+  }]
+});
+```
+
+#### Glob Patterns
+
+Use glob patterns to strip dynamic prefixes:
+
+```typescript
+export default defineConfig({
+  specs: [{
+    input: 'openapi.yaml',
+    output: 'schemas.ts',
+    // Strip any namespace prefix with wildcard
+    stripSchemaPrefix: '*.Models.'
+  }]
+});
+```
+
+**Glob Pattern Syntax:**
+
+Glob patterns support powerful matching using [minimatch](https://github.com/isaacs/minimatch):
+- `*` matches any characters within a single segment (stops at `.`)
+- `**` matches any characters across multiple segments (crosses `.` boundaries)
+- `?` matches a single character
+- `[abc]` matches any character in the set
+- `{a,b}` matches any of the alternatives
+- `!(pattern)` matches anything except the pattern
+
+```typescript
+// Examples of glob patterns:
+stripSchemaPrefix: '*.Models.'                      // Matches Company.Models., App.Models.
+stripSchemaPrefix: '**.Models.'                     // Matches any depth: Company.Api.Models., App.V2.Models.
+stripSchemaPrefix: 'Company.{Models,Services}.'     // Matches Company.Models. or Company.Services.
+stripSchemaPrefix: 'api_v[0-9]_'                   // Matches api_v1_, api_v2_, etc.
+stripSchemaPrefix: 'v*.*.'                          // Matches v1.0., v2.1., etc.
+stripSchemaPrefix: '!(Internal)*.'                  // Matches any prefix except those starting with Internal
+```
+
+#### Common Patterns
+
+**Pattern 1: .NET Namespaces**
+```typescript
+{
+  stripSchemaPrefix: 'Company.Models.'
+}
+// Company.Models.User → User
+// Company.Models.Post → Post
+```
+
+**Pattern 2: Multiple Namespaces with Wildcard**
+```typescript
+{
+  stripSchemaPrefix: '*.Models.'
+}
+// MyApp.Models.User → User
+// OtherApp.Models.User → User
+// Company.Models.Post → Post
+```
+
+**Pattern 3: Multiple Namespace Types**
+```typescript
+{
+  stripSchemaPrefix: '*.{Models,Services}.'
+}
+// App.Models.User → User
+// App.Services.UserService → UserService
+```
+
+**Pattern 4: Version Prefixes with Character Class**
+```typescript
+{
+  stripSchemaPrefix: 'v[0-9].'
+}
+// v1.User → User
+// v2.Product → Product
+```
+
+**Pattern 5: Versioned Prefixes with Wildcards**
+```typescript
+{
+  stripSchemaPrefix: 'api_v*_'
+}
+// api_v1_User → User
+// api_v2_Product → Product
+// api_v10_Comment → Comment
+```
+
+#### Interaction with prefix/suffix Options
+
+`stripSchemaPrefix` is applied **before** `prefix` and `suffix` options:
+
+```typescript
+export default defineConfig({
+  specs: [{
+    input: 'openapi.yaml',
+    output: 'schemas.ts',
+    stripSchemaPrefix: 'Company.Models.',  // Applied first
+    prefix: 'api',                          // Applied second
+    suffix: 'dto'                           // Applied third
+  }]
+});
+```
+
+**Result:**
+- `Company.Models.User` → `User` → `apiUserDtoSchema`
+- `Company.Models.Post` → `Post` → `apiPostDtoSchema`
+
+#### Benefits
+
+1. **Cleaner Schema Names**: Generates `userSchema` instead of `companyModelsUserSchema`
+2. **Better Type Names**: Creates `User` type instead of `CompanyModelsUser`
+3. **Shorter References**: Simpler schema references in composed types
+4. **Better Code Completion**: Easier to find schemas in IDE autocomplete
+5. **Flexible Pattern Matching**: Use regex for dynamic prefixes
+
 ## Generation Statistics
 
 Statistics are **included by default** in generated files. Use `showStats: false` to disable:

package/dist/cli.js

@@ -5129,7 +5129,7 @@ function getBatchExitCode(summary) {
 init_cjs_shims();
 var import_node_fs = require("fs");
 var import_node_path = require("path");
-var import_minimatch2 = require("minimatch");
+var import_minimatch3 = require("minimatch");
 var import_yaml = require("yaml");
 
 // src/generators/enum-generator.ts
@@ -5137,8 +5137,20 @@ init_cjs_shims();
 
 // src/utils/name-utils.ts
 init_cjs_shims();
+function sanitizeIdentifier(str) {
+  return str.replace(/[^a-zA-Z0-9._\-\s]+/g, "_");
+}
 function toCamelCase(str, options) {
-  let name = str.charAt(0).toLowerCase() + str.slice(1);
+  const sanitized = sanitizeIdentifier(str);
+  const words = sanitized.split(/[.\-_\s]+/).filter((word) => word.length > 0);
+  let name;
+  if (words.length === 0) {
+    name = str.charAt(0).toLowerCase() + str.slice(1);
+  } else if (words.length === 1) {
+    name = words[0].charAt(0).toLowerCase() + words[0].slice(1);
+  } else {
+    name = words[0].charAt(0).toLowerCase() + words[0].slice(1) + words.slice(1).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
   if (options == null ? void 0 : options.prefix) {
     const prefix = options.prefix.toLowerCase();
     name = prefix + name.charAt(0).toUpperCase() + name.slice(1);
@@ -5151,12 +5163,23 @@ function toCamelCase(str, options) {
 }
 function toPascalCase(str) {
   const stringValue = String(str);
-  let result = stringValue.replace(/[^a-zA-Z0-9_]+/g, "_").split(/[-_]+/).filter((word) => word.length > 0).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+  const isAlreadyValidCase = /^[a-zA-Z][a-zA-Z0-9]*$/.test(stringValue);
+  if (isAlreadyValidCase) {
+    return stringValue.charAt(0).toUpperCase() + stringValue.slice(1);
+  }
+  const sanitized = sanitizeIdentifier(stringValue);
+  const words = sanitized.split(/[.\-_\s]+/).filter((word) => word.length > 0);
+  let result;
+  if (words.length === 0) {
+    result = "Value";
+  } else {
+    result = words.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
   if (/^\d/.test(result)) {
     result = `N${result}`;
   }
   if (!result || /^_+$/.test(result)) {
-    result = "Value";
+    return "Value";
   }
   return result;
 }
@@ -5168,9 +5191,28 @@ function resolveRef(ref) {
 // src/generators/enum-generator.ts
 function generateEnum(name, values, options) {
   const schemaName = `${toCamelCase(name, options)}Schema`;
-  const enumValues = values.map((v) => `"${v}"`).join(", ");
-  const schemaCode = `export const ${schemaName} = z.enum([${enumValues}]);`;
-  const typeCode = `export type ${name} = z.infer<typeof ${schemaName}>;`;
+  const typeName = toPascalCase(name);
+  const allBooleans = values.every((v) => typeof v === "boolean");
+  if (allBooleans) {
+    const schemaCode2 = `export const ${schemaName} = z.boolean();`;
+    const typeCode2 = `export type ${typeName} = z.infer<typeof ${schemaName}>;`;
+    return { schemaCode: schemaCode2, typeCode: typeCode2 };
+  }
+  const allStrings = values.every((v) => typeof v === "string");
+  if (allStrings) {
+    const enumValues = values.map((v) => `"${v}"`).join(", ");
+    const schemaCode2 = `export const ${schemaName} = z.enum([${enumValues}]);`;
+    const typeCode2 = `export type ${typeName} = z.infer<typeof ${schemaName}>;`;
+    return { schemaCode: schemaCode2, typeCode: typeCode2 };
+  }
+  const literalValues = values.map((v) => {
+    if (typeof v === "string") {
+      return `z.literal("${v}")`;
+    }
+    return `z.literal(${v})`;
+  }).join(", ");
+  const schemaCode = `export const ${schemaName} = z.union([${literalValues}]);`;
+  const typeCode = `export type ${typeName} = z.infer<typeof ${schemaName}>;`;
   return { schemaCode, typeCode };
 }
 
@@ -5183,7 +5225,7 @@ function escapeDescription(str) {
   return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
 }
 function escapePattern(str) {
-  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  return str.replace(/\//g, "\\/");
 }
 function escapeJSDoc(str) {
   return str.replace(/\*\//g, "*\\/");
@@ -5311,6 +5353,65 @@ var LRUCache = class {
   }
 };
 
+// src/utils/pattern-utils.ts
+init_cjs_shims();
+var import_minimatch = require("minimatch");
+function isValidGlobPattern(pattern) {
+  try {
+    new import_minimatch.minimatch.Minimatch(pattern);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isGlobPattern(pattern) {
+  return /[*?[\]{}!]/.test(pattern);
+}
+function stripPrefix(input, pattern, ensureLeadingChar) {
+  if (!pattern) {
+    return input;
+  }
+  if (isGlobPattern(pattern) && !isValidGlobPattern(pattern)) {
+    console.warn(`\u26A0\uFE0F  Invalid glob pattern "${pattern}": Pattern is malformed`);
+    return input;
+  }
+  if (isGlobPattern(pattern)) {
+    let longestMatch = -1;
+    for (let i = 1; i <= input.length; i++) {
+      const testPrefix = input.substring(0, i);
+      if ((0, import_minimatch.minimatch)(testPrefix, pattern)) {
+        longestMatch = i;
+      }
+    }
+    if (longestMatch > 0) {
+      const stripped = input.substring(longestMatch);
+      if (ensureLeadingChar) {
+        if (stripped === "") {
+          return ensureLeadingChar;
+        }
+        if (!stripped.startsWith(ensureLeadingChar)) {
+          return `${ensureLeadingChar}${stripped}`;
+        }
+      }
+      return stripped === "" && !ensureLeadingChar ? input : stripped;
+    }
+    return input;
+  }
+  if (input.startsWith(pattern)) {
+    const stripped = input.substring(pattern.length);
+    if (ensureLeadingChar) {
+      if (stripped === "") {
+        return ensureLeadingChar;
+      }
+      if (!stripped.startsWith(ensureLeadingChar)) {
+        return `${ensureLeadingChar}${stripped}`;
+      }
+    }
+    return stripped;
+  }
+  return input;
+}
+
 // src/validators/array-validator.ts
 init_cjs_shims();
 function generateArrayValidation(schema, context) {
@@ -6175,8 +6276,9 @@ var _PropertyGenerator = class _PropertyGenerator {
         }
         (_a = this.context.schemaDependencies.get(currentSchema)) == null ? void 0 : _a.add(refName);
       }
-      const schemaName = `${toCamelCase(resolvedRefName, this.context.namingOptions)}Schema`;
-      if (currentSchema && this.isCircularThroughAlias(currentSchema, refName)) {
+      const strippedRefName = stripPrefix(resolvedRefName, this.context.stripSchemaPrefix);
+      const schemaName = `${toCamelCase(strippedRefName, this.context.namingOptions)}Schema`;
+      if (currentSchema && (refName === currentSchema || this.isCircularThroughAlias(currentSchema, refName))) {
         const lazySchema = `z.lazy((): z.ZodTypeAny => ${schemaName})`;
         return wrapNullable(lazySchema, nullable);
       }
@@ -6188,9 +6290,25 @@ var _PropertyGenerator = class _PropertyGenerator {
       return wrapNullable(zodLiteral, nullable);
     }
     if (schema.enum) {
-      const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
-      const zodEnum = `z.enum([${enumValues}])`;
-      return wrapNullable(zodEnum, nullable);
+      const allBooleans = schema.enum.every((v) => typeof v === "boolean");
+      if (allBooleans) {
+        const zodBoolean = "z.boolean()";
+        return wrapNullable(zodBoolean, nullable);
+      }
+      const allStrings = schema.enum.every((v) => typeof v === "string");
+      if (allStrings) {
+        const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
+        const zodEnum = `z.enum([${enumValues}])`;
+        return wrapNullable(zodEnum, nullable);
+      }
+      const literalValues = schema.enum.map((v) => {
+        if (typeof v === "string") {
+          return `z.literal("${v}")`;
+        }
+        return `z.literal(${v})`;
+      }).join(", ");
+      const zodUnion = `z.union([${literalValues}])`;
+      return wrapNullable(zodUnion, nullable);
     }
     if (schema.allOf) {
       let composition = generateAllOf(
@@ -6322,7 +6440,7 @@ var PropertyGenerator = _PropertyGenerator;
 
 // src/utils/operation-filters.ts
 init_cjs_shims();
-var import_minimatch = require("minimatch");
+var import_minimatch2 = require("minimatch");
 function createFilterStatistics() {
   return {
     totalOperations: 0,
@@ -6341,7 +6459,7 @@ function matchesAnyPattern(value, patterns) {
   if (!value) {
     return false;
   }
-  return patterns.some((pattern) => (0, import_minimatch.minimatch)(value, pattern));
+  return patterns.some((pattern) => (0, import_minimatch2.minimatch)(value, pattern));
 }
 function containsAny(arr, values) {
   if (!values || values.length === 0) {
@@ -6477,6 +6595,7 @@ var OpenApiGenerator = class {
       schemaType: options.schemaType || "all",
       prefix: options.prefix,
       suffix: options.suffix,
+      stripSchemaPrefix: options.stripSchemaPrefix,
       showStats: (_c = options.showStats) != null ? _c : true,
       request: options.request,
       response: options.response,
@@ -6553,7 +6672,8 @@ var OpenApiGenerator = class {
       namingOptions: {
         prefix: this.options.prefix,
         suffix: this.options.suffix
-      }
+      },
+      stripSchemaPrefix: this.options.stripSchemaPrefix
     });
   }
   /**
@@ -6566,6 +6686,9 @@ var OpenApiGenerator = class {
       throw new SpecValidationError("No schemas found in OpenAPI spec", { filePath: this.options.input });
     }
     for (const [name, schema] of Object.entries(this.spec.components.schemas)) {
+      if (this.options.operationFilters && this.schemaUsageMap.size > 0 && !this.schemaUsageMap.has(name)) {
+        continue;
+      }
       this.generateComponentSchema(name, schema);
     }
     this.generateQueryParameterSchemas();
@@ -6587,9 +6710,11 @@ var OpenApiGenerator = class {
       const typeCode = this.types.get(name);
       if (schemaCode) {
         output.push(schemaCode);
-        if (!schemaCode.includes(`export type ${name}`)) {
-          const schemaName = `${toCamelCase(name, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
-          output.push(`export type ${name} = z.infer<typeof ${schemaName}>;`);
+        const strippedName = stripPrefix(name, this.options.stripSchemaPrefix);
+        const typeName = toPascalCase(strippedName);
+        if (!schemaCode.includes(`export type ${typeName}`)) {
+          const schemaName = `${toCamelCase(strippedName, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
+          output.push(`export type ${typeName} = z.infer<typeof ${schemaName}>;`);
         }
         output.push("");
       } else if (typeCode) {
@@ -6905,7 +7030,8 @@ var OpenApiGenerator = class {
     const resolvedOptions = context === "response" ? this.responseOptions : this.requestOptions;
     if (schema.enum) {
       const jsdoc2 = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
-      const { schemaCode, typeCode } = generateEnum(name, schema.enum, {
+      const strippedName2 = stripPrefix(name, this.options.stripSchemaPrefix);
+      const { schemaCode, typeCode } = generateEnum(strippedName2, schema.enum, {
         prefix: this.options.prefix,
         suffix: this.options.suffix
       });
@@ -6914,7 +7040,8 @@ ${typeCode}`;
       this.schemas.set(name, enumSchemaCode);
       return;
     }
-    const schemaName = `${toCamelCase(name, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
+    const strippedName = stripPrefix(name, this.options.stripSchemaPrefix);
+    const schemaName = `${toCamelCase(strippedName, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
     const jsdoc = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
     if (schema.allOf && schema.allOf.length === 1 && schema.allOf[0].$ref) {
       const refName = resolveRef(schema.allOf[0].$ref);
@@ -6930,7 +7057,8 @@ ${typeCode}`;
       namingOptions: {
         prefix: this.options.prefix,
         suffix: this.options.suffix
-      }
+      },
+      stripSchemaPrefix: this.options.stripSchemaPrefix
     });
     const isAlias = !!(schema.$ref && !schema.properties && !schema.allOf && !schema.oneOf && !schema.anyOf);
     const zodSchema = this.propertyGenerator.generatePropertySchema(schema, name, isAlias);
@@ -7049,7 +7177,7 @@ ${propsCode}
     const headerLower = headerName.toLowerCase();
     return ignorePatterns.some((pattern) => {
       const patternLower = pattern.toLowerCase();
-      return (0, import_minimatch2.minimatch)(headerLower, patternLower);
+      return (0, import_minimatch3.minimatch)(headerLower, patternLower);
     });
   }
   /**
@@ -7132,12 +7260,27 @@ ${propsCode}
   generateQueryParamType(schema, param) {
     if (schema.$ref) {
       const refName = resolveRef(schema.$ref);
-      const schemaName = toCamelCase(refName, { prefix: this.options.prefix, suffix: this.options.suffix });
+      const strippedRefName = stripPrefix(refName, this.options.stripSchemaPrefix);
+      const schemaName = toCamelCase(strippedRefName, { prefix: this.options.prefix, suffix: this.options.suffix });
       return `${schemaName}Schema`;
     }
     if (schema.enum) {
-      const enumValues = schema.enum.map((v) => typeof v === "string" ? `"${v}"` : v).join(", ");
-      return `z.enum([${enumValues}])`;
+      const allBooleans = schema.enum.every((v) => typeof v === "boolean");
+      if (allBooleans) {
+        return "z.boolean()";
+      }
+      const allStrings = schema.enum.every((v) => typeof v === "string");
+      if (allStrings) {
+        const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
+        return `z.enum([${enumValues}])`;
+      }
+      const literalValues = schema.enum.map((v) => {
+        if (typeof v === "string") {
+          return `z.literal("${v}")`;
+        }
+        return `z.literal(${v})`;
+      }).join(", ");
+      return `z.union([${literalValues}])`;
     }
     const type = schema.type;
     if (type === "string") {
@@ -7368,6 +7511,7 @@ var OpenApiGeneratorOptionsSchema = import_zod2.z.strictObject({
   schemaType: import_zod2.z.enum(["all", "request", "response"]).optional(),
   prefix: import_zod2.z.string().optional(),
   suffix: import_zod2.z.string().optional(),
+  stripSchemaPrefix: import_zod2.z.string().optional(),
   showStats: import_zod2.z.boolean().optional(),
   request: RequestResponseOptionsSchema.optional(),
   response: RequestResponseOptionsSchema.optional(),
@@ -7384,6 +7528,7 @@ var ConfigFileSchema = import_zod2.z.strictObject({
     schemaType: import_zod2.z.enum(["all", "request", "response"]).optional(),
     prefix: import_zod2.z.string().optional(),
     suffix: import_zod2.z.string().optional(),
+    stripSchemaPrefix: import_zod2.z.string().optional(),
     showStats: import_zod2.z.boolean().optional(),
     request: RequestResponseOptionsSchema.optional(),
     response: RequestResponseOptionsSchema.optional(),
@@ -7413,7 +7558,7 @@ async function loadConfig(configPath) {
   }
   if (!result || !result.config) {
     throw new Error(
-      configPath ? `Config file not found at: ${configPath}` : "No config file found. Searched for: openapi-to-zod.config.ts, openapi-to-zod.config.json, package.json (openapi-to-zod key)"
+      configPath ? `Config file not found at: ${configPath}` : "No config file found. Searched for: openapi-to-zod.config.ts, openapi-to-zod.config.json, package.json (openapi-to-zod key)\nRun 'openapi-to-zod init' to create a new config file."
     );
   }
   try {
@@ -7520,14 +7665,7 @@ function findSpecFiles() {
 }
 async function executeConfigMode(options) {
   var _a, _b;
-  let config;
-  try {
-    config = await loadConfig(options.config);
-  } catch {
-    throw new CliOptionsError("No config file found. Run 'openapi-to-zod init' to create one.", {
-      configPath: options.config
-    });
-  }
+  const config = await loadConfig(options.config);
   const specs = mergeConfigWithDefaults(config);
   const executionMode = config.executionMode || "parallel";
   const batchSize = (_b = (_a = specs[0]) == null ? void 0 : _a.batchSize) != null ? _b : 10;