@cerios/openapi-to-zod 1.1.0 → 1.2.0

package/dist/cli.mjs

@@ -5197,8 +5197,26 @@ var init_name_utils = __esm({
 function generateEnum(name, values, options) {
   const schemaName = `${toCamelCase(name, options)}Schema`;
   const typeName = toPascalCase(name);
-  const enumValues = values.map((v) => `"${v}"`).join(", ");
-  const schemaCode = `export const ${schemaName} = z.enum([${enumValues}]);`;
+  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 };
 }
@@ -5215,7 +5233,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, "*\\/");
@@ -5223,14 +5241,17 @@ function escapeJSDoc(str) {
 function wrapNullable(validation, isNullable2) {
   return isNullable2 ? `${validation}.nullable()` : validation;
 }
-function isNullable(schema) {
+function isNullable(schema, defaultNullable = false) {
   if (schema.nullable === true) {
     return true;
   }
+  if (schema.nullable === false) {
+    return false;
+  }
   if (Array.isArray(schema.type)) {
     return schema.type.includes("null");
   }
-  return false;
+  return defaultNullable;
 }
 function getPrimaryType(schema) {
   if (Array.isArray(schema.type)) {
@@ -5360,61 +5381,36 @@ var init_lru_cache = __esm({
 });
 
 // src/utils/pattern-utils.ts
-function isRegexPattern(pattern) {
-  if (pattern.startsWith("^") || pattern.endsWith("$")) {
-    return true;
-  }
-  if (/\\[dDwWsS]/.test(pattern)) {
-    return true;
-  }
-  if (/\.\*|\.\+/.test(pattern)) {
-    return true;
-  }
-  if (/[[\]()]/.test(pattern)) {
-    return true;
-  }
-  if (/[^/][+?*]\{/.test(pattern)) {
+import { minimatch } from "minimatch";
+function isValidGlobPattern(pattern) {
+  try {
+    new minimatch.Minimatch(pattern);
     return true;
+  } catch {
+    return false;
   }
-  return false;
 }
-function patternToRegex(pattern) {
-  if (pattern instanceof RegExp) {
-    return pattern;
-  }
-  if (isRegexPattern(pattern)) {
-    try {
-      return new RegExp(pattern);
-    } catch (error) {
-      console.warn(`\u26A0\uFE0F  Invalid regex pattern "${pattern}": ${error instanceof Error ? error.message : String(error)}`);
-      return null;
-    }
-  }
-  return null;
+function isGlobPattern(pattern) {
+  return /[*?[\]{}!]/.test(pattern);
 }
 function stripPrefix(input, pattern, ensureLeadingChar) {
   if (!pattern) {
     return input;
   }
-  const regex = patternToRegex(pattern);
-  if (regex) {
-    const match = input.match(regex);
-    if (match && match.index === 0) {
-      const stripped = input.substring(match[0].length);
-      if (ensureLeadingChar) {
-        if (stripped === "") {
-          return ensureLeadingChar;
-        }
-        if (!stripped.startsWith(ensureLeadingChar)) {
-          return `${ensureLeadingChar}${stripped}`;
-        }
+  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 (minimatch(testPrefix, pattern)) {
+        longestMatch = i;
       }
-      return stripped;
     }
-  } else {
-    const stringPattern = pattern;
-    if (input.startsWith(stringPattern)) {
-      const stripped = input.substring(stringPattern.length);
+    if (longestMatch > 0) {
+      const stripped = input.substring(longestMatch);
       if (ensureLeadingChar) {
         if (stripped === "") {
           return ensureLeadingChar;
@@ -5423,11 +5419,40 @@ function stripPrefix(input, pattern, ensureLeadingChar) {
           return `${ensureLeadingChar}${stripped}`;
         }
       }
-      return 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;
 }
+function stripPathPrefix(path2, pattern) {
+  if (!pattern) {
+    return path2;
+  }
+  if (!isGlobPattern(pattern)) {
+    let normalizedPattern = pattern.trim();
+    if (!normalizedPattern.startsWith("/")) {
+      normalizedPattern = `/${normalizedPattern}`;
+    }
+    if (normalizedPattern.endsWith("/") && normalizedPattern !== "/") {
+      normalizedPattern = normalizedPattern.slice(0, -1);
+    }
+    return stripPrefix(path2, normalizedPattern, "/");
+  }
+  return stripPrefix(path2, pattern, "/");
+}
 var init_pattern_utils = __esm({
   "src/utils/pattern-utils.ts"() {
     "use strict";
@@ -5993,6 +6018,26 @@ function configurePatternCache(size) {
     PATTERN_CACHE = new LRUCache(size);
   }
 }
+function configureDateTimeFormat(pattern) {
+  if (!pattern) {
+    FORMAT_MAP["date-time"] = "z.iso.datetime()";
+    return;
+  }
+  const patternStr = pattern instanceof RegExp ? pattern.source : pattern;
+  if (patternStr === "") {
+    FORMAT_MAP["date-time"] = "z.iso.datetime()";
+    return;
+  }
+  try {
+    new RegExp(patternStr);
+  } catch (error) {
+    throw new Error(
+      `Invalid regular expression pattern for customDateTimeFormatRegex: ${patternStr}. ${error instanceof Error ? error.message : "Pattern is malformed"}`
+    );
+  }
+  const escapedPattern = escapePattern(patternStr);
+  FORMAT_MAP["date-time"] = `z.string().regex(/${escapedPattern}/)`;
+}
 function generateStringValidation(schema, useDescribe) {
   let validation = FORMAT_MAP[schema.format || ""] || "z.string()";
   if (schema.minLength !== void 0) {
@@ -6058,7 +6103,7 @@ function generateStringValidation(schema, useDescribe) {
   }
   return addDescription(validation, schema.description, useDescribe);
 }
-var PATTERN_CACHE, FORMAT_MAP;
+var PATTERN_CACHE, DEFAULT_FORMAT_MAP, FORMAT_MAP;
 var init_string_validator = __esm({
   "src/validators/string-validator.ts"() {
     "use strict";
@@ -6066,7 +6111,7 @@ var init_string_validator = __esm({
     init_lru_cache();
     init_string_utils();
     PATTERN_CACHE = new LRUCache(1e3);
-    FORMAT_MAP = {
+    DEFAULT_FORMAT_MAP = {
       uuid: "z.uuid()",
       email: "z.email()",
       uri: "z.url()",
@@ -6076,7 +6121,6 @@ var init_string_validator = __esm({
       byte: "z.base64()",
       binary: "z.string()",
       date: "z.iso.date()",
-      "date-time": "z.iso.datetime()",
       time: "z.iso.time()",
       duration: 'z.string().refine((val) => /^P(?:(?:\\d+Y)?(?:\\d+M)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+(?:\\.\\d+)?S)?)?|\\d+W)$/.test(val) && !/^PT?$/.test(val), { message: "Must be a valid ISO 8601 duration" })',
       ipv4: "z.ipv4()",
@@ -6095,6 +6139,10 @@ var init_string_validator = __esm({
       "json-pointer": 'z.string().refine((val) => val === "" || /^(\\/([^~/]|~0|~1)+)+$/.test(val), { message: "Must be a valid JSON Pointer (RFC 6901)" })',
       "relative-json-pointer": 'z.string().refine((val) => /^(0|[1-9]\\d*)(#|(\\/([^~/]|~0|~1)+)*)$/.test(val), { message: "Must be a valid relative JSON Pointer" })'
     };
+    FORMAT_MAP = {
+      ...DEFAULT_FORMAT_MAP,
+      "date-time": "z.iso.datetime()"
+    };
   }
 });
 
@@ -6335,7 +6383,8 @@ var init_property_generator = __esm({
         if ((this.context.schemaType === "request" || this.context.schemaType === "response") && schema.properties) {
           schema = this.filterNestedProperties(schema);
         }
-        const nullable = isNullable(schema);
+        const effectiveDefaultNullable = isTopLevel ? false : this.context.defaultNullable;
+        const nullable = isNullable(schema, effectiveDefaultNullable);
         if (hasMultipleTypes(schema)) {
           const union = this.generateMultiTypeUnion(schema, currentSchema);
           return wrapNullable(union, nullable);
@@ -6363,9 +6412,25 @@ var init_property_generator = __esm({
           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(
@@ -6498,7 +6563,7 @@ var init_property_generator = __esm({
 });
 
 // src/utils/operation-filters.ts
-import { minimatch } from "minimatch";
+import { minimatch as minimatch2 } from "minimatch";
 function createFilterStatistics() {
   return {
     totalOperations: 0,
@@ -6517,7 +6582,7 @@ function matchesAnyPattern(value, patterns) {
   if (!value) {
     return false;
   }
-  return patterns.some((pattern) => minimatch(value, pattern));
+  return patterns.some((pattern) => minimatch2(value, pattern));
 }
 function containsAny(arr, values) {
   if (!values || values.length === 0) {
@@ -6640,7 +6705,7 @@ var init_operation_filters = __esm({
 // src/openapi-generator.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, normalize } from "path";
-import { minimatch as minimatch2 } from "minimatch";
+import { minimatch as minimatch3 } from "minimatch";
 import { parse } from "yaml";
 var OpenApiGenerator;
 var init_openapi_generator = __esm({
@@ -6663,7 +6728,7 @@ var init_openapi_generator = __esm({
         this.schemaUsageMap = /* @__PURE__ */ new Map();
         this.needsZodImport = true;
         this.filterStats = createFilterStatistics();
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g;
         if (!options.input) {
           throw new ConfigurationError("Input path is required", { providedOptions: options });
         }
@@ -6673,21 +6738,27 @@ var init_openapi_generator = __esm({
           output: options.output,
           includeDescriptions: (_a = options.includeDescriptions) != null ? _a : true,
           useDescribe: (_b = options.useDescribe) != null ? _b : false,
+          defaultNullable: (_c = options.defaultNullable) != null ? _c : false,
           schemaType: options.schemaType || "all",
           prefix: options.prefix,
           suffix: options.suffix,
           stripSchemaPrefix: options.stripSchemaPrefix,
-          showStats: (_c = options.showStats) != null ? _c : true,
+          stripPathPrefix: options.stripPathPrefix,
+          showStats: (_d = options.showStats) != null ? _d : true,
           request: options.request,
           response: options.response,
           operationFilters: options.operationFilters,
           ignoreHeaders: options.ignoreHeaders,
-          cacheSize: (_d = options.cacheSize) != null ? _d : 1e3,
-          batchSize: (_e = options.batchSize) != null ? _e : 10
+          cacheSize: (_e = options.cacheSize) != null ? _e : 1e3,
+          batchSize: (_f = options.batchSize) != null ? _f : 10,
+          customDateTimeFormatRegex: options.customDateTimeFormatRegex
         };
         if (this.options.cacheSize) {
           configurePatternCache(this.options.cacheSize);
         }
+        if (this.options.customDateTimeFormatRegex) {
+          configureDateTimeFormat(this.options.customDateTimeFormatRegex);
+        }
         try {
           const fs = __require("fs");
           if (!fs.existsSync(this.options.input)) {
@@ -6750,6 +6821,7 @@ var init_openapi_generator = __esm({
           mode: this.requestOptions.mode,
           includeDescriptions: this.requestOptions.includeDescriptions,
           useDescribe: this.requestOptions.useDescribe,
+          defaultNullable: (_g = this.options.defaultNullable) != null ? _g : false,
           namingOptions: {
             prefix: this.options.prefix,
             suffix: this.options.suffix
@@ -6767,6 +6839,9 @@ var init_openapi_generator = __esm({
           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();
@@ -7100,7 +7175,7 @@ var init_openapi_generator = __esm({
        * Generate schema for a component
        */
       generateComponentSchema(name, schema) {
-        var _a, _b;
+        var _a, _b, _c;
         if (!this.schemaDependencies.has(name)) {
           this.schemaDependencies.set(name, /* @__PURE__ */ new Set());
         }
@@ -7132,14 +7207,14 @@ ${typeCode}`;
           mode: resolvedOptions.mode,
           includeDescriptions: resolvedOptions.includeDescriptions,
           useDescribe: resolvedOptions.useDescribe,
+          defaultNullable: (_b = this.options.defaultNullable) != null ? _b : false,
           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);
+        const zodSchema = this.propertyGenerator.generatePropertySchema(schema, name, true);
         const zodSchemaCode = `${jsdoc}export const ${schemaName} = ${zodSchema};`;
         if (zodSchema.includes("z.discriminatedUnion(")) {
           const match = zodSchema.match(/z\.discriminatedUnion\([^,]+,\s*\[([^\]]+)\]/);
@@ -7149,7 +7224,7 @@ ${typeCode}`;
               const depMatch = ref.match(/^([a-z][a-zA-Z0-9]*?)Schema$/);
               if (depMatch) {
                 const depName = depMatch[1].charAt(0).toUpperCase() + depMatch[1].slice(1);
-                (_b = this.schemaDependencies.get(name)) == null ? void 0 : _b.add(depName);
+                (_c = this.schemaDependencies.get(name)) == null ? void 0 : _c.add(depName);
               }
             }
           }
@@ -7173,7 +7248,7 @@ ${typeCode}`;
             if (!shouldIncludeOperation(operation, path2, method, this.options.operationFilters)) {
               continue;
             }
-            if (!operation.operationId || !operation.parameters || !Array.isArray(operation.parameters)) {
+            if (!operation.parameters || !Array.isArray(operation.parameters)) {
               continue;
             }
             const queryParams = operation.parameters.filter(
@@ -7182,7 +7257,13 @@ ${typeCode}`;
             if (queryParams.length === 0) {
               continue;
             }
-            const pascalOperationId = operation.operationId.includes("-") ? toPascalCase(operation.operationId) : operation.operationId.charAt(0).toUpperCase() + operation.operationId.slice(1);
+            let pascalOperationId;
+            if (operation.operationId) {
+              pascalOperationId = operation.operationId.includes("-") ? toPascalCase(operation.operationId) : operation.operationId.charAt(0).toUpperCase() + operation.operationId.slice(1);
+            } else {
+              const strippedPath = stripPathPrefix(path2, this.options.stripPathPrefix);
+              pascalOperationId = this.generateMethodNameFromPath(method, strippedPath);
+            }
             const schemaName = `${pascalOperationId}QueryParams`;
             if (!this.schemaDependencies.has(schemaName)) {
               this.schemaDependencies.set(schemaName, /* @__PURE__ */ new Set());
@@ -7230,8 +7311,9 @@ ${propsCode}
             const prefixedName = this.options.prefix ? `${toPascalCase(this.options.prefix)}${operationName}` : operationName;
             const suffixedName = this.options.suffix ? `${prefixedName}${toPascalCase(this.options.suffix)}` : prefixedName;
             const camelCaseSchemaName = `${suffixedName.charAt(0).toLowerCase() + suffixedName.slice(1)}QueryParamsSchema`;
+            const jsdocOperationName = operation.operationId || `${method.toUpperCase()} ${path2}`;
             const jsdoc = `/**
- * Query parameters for ${operation.operationId}
+ * Query parameters for ${jsdocOperationName}
  */
 `;
             const fullSchemaCode = `${jsdoc}export const ${camelCaseSchemaName} = ${schemaCode};`;
@@ -7240,6 +7322,35 @@ ${propsCode}
           }
         }
       }
+      /**
+       * Generate a PascalCase method name from HTTP method and path
+       * Used as fallback when operationId is not available
+       * @internal
+       */
+      generateMethodNameFromPath(method, path2) {
+        const segments = path2.split("/").filter(Boolean).map((segment) => {
+          if (segment.startsWith("{") && segment.endsWith("}")) {
+            const paramName = segment.slice(1, -1);
+            return `By${this.capitalizeSegment(paramName)}`;
+          }
+          return this.capitalizeSegment(segment);
+        }).join("");
+        const capitalizedMethod = method.charAt(0).toUpperCase() + method.slice(1).toLowerCase();
+        return `${capitalizedMethod}${segments}`;
+      }
+      /**
+       * Capitalizes a path segment, handling special characters like dashes, underscores, and dots
+       * @internal
+       */
+      capitalizeSegment(str) {
+        if (str.includes("-") || str.includes("_") || str.includes(".")) {
+          return str.split(/[-_.]/).map((part) => {
+            if (!part) return "";
+            return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
+          }).join("");
+        }
+        return str.charAt(0).toUpperCase() + str.slice(1);
+      }
       /**
        * Check if a header should be ignored based on filter patterns
        * @internal
@@ -7255,7 +7366,7 @@ ${propsCode}
         const headerLower = headerName.toLowerCase();
         return ignorePatterns.some((pattern) => {
           const patternLower = pattern.toLowerCase();
-          return minimatch2(headerLower, patternLower);
+          return minimatch3(headerLower, patternLower);
         });
       }
       /**
@@ -7276,7 +7387,7 @@ ${propsCode}
             if (!shouldIncludeOperation(operation, path2, method, this.options.operationFilters)) {
               continue;
             }
-            if (!operation.operationId || !operation.parameters || !Array.isArray(operation.parameters)) {
+            if (!operation.parameters || !Array.isArray(operation.parameters)) {
               continue;
             }
             const headerParams = operation.parameters.filter(
@@ -7285,7 +7396,13 @@ ${propsCode}
             if (headerParams.length === 0) {
               continue;
             }
-            const pascalOperationId = operation.operationId.includes("-") ? toPascalCase(operation.operationId) : operation.operationId.charAt(0).toUpperCase() + operation.operationId.slice(1);
+            let pascalOperationId;
+            if (operation.operationId) {
+              pascalOperationId = operation.operationId.includes("-") ? toPascalCase(operation.operationId) : operation.operationId.charAt(0).toUpperCase() + operation.operationId.slice(1);
+            } else {
+              const strippedPath = stripPathPrefix(path2, this.options.stripPathPrefix);
+              pascalOperationId = this.generateMethodNameFromPath(method, strippedPath);
+            }
             const schemaName = `${pascalOperationId}HeaderParams`;
             if (!this.schemaDependencies.has(schemaName)) {
               this.schemaDependencies.set(schemaName, /* @__PURE__ */ new Set());
@@ -7322,8 +7439,9 @@ ${propsCode}
             const prefixedName = this.options.prefix ? `${toPascalCase(this.options.prefix)}${operationName}` : operationName;
             const suffixedName = this.options.suffix ? `${prefixedName}${toPascalCase(this.options.suffix)}` : prefixedName;
             const camelCaseSchemaName = `${suffixedName.charAt(0).toLowerCase() + suffixedName.slice(1)}HeaderParamsSchema`;
+            const jsdocOperationName = operation.operationId || `${method.toUpperCase()} ${path2}`;
             const jsdoc = `/**
- * Header parameters for ${operation.operationId}
+ * Header parameters for ${jsdocOperationName}
  */
 `;
             const fullSchemaCode = `${jsdoc}export const ${camelCaseSchemaName} = ${schemaCode};`;
@@ -7343,8 +7461,22 @@ ${propsCode}
           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") {
@@ -7490,7 +7622,8 @@ var init_config_schemas = __esm({
     RequestResponseOptionsSchema = z.strictObject({
       mode: z.enum(["strict", "normal", "loose"]).optional(),
       useDescribe: z.boolean().optional(),
-      includeDescriptions: z.boolean().optional()
+      includeDescriptions: z.boolean().optional(),
+      defaultNullable: z.boolean().optional()
     });
     OperationFiltersSchema = z.strictObject({
       includeTags: z.array(z.string()).optional(),
@@ -7621,10 +7754,12 @@ function mergeConfigWithDefaults(config) {
       mode: defaults.mode,
       includeDescriptions: defaults.includeDescriptions,
       useDescribe: defaults.useDescribe,
+      defaultNullable: defaults.defaultNullable,
       schemaType: defaults.schemaType,
       prefix: defaults.prefix,
       suffix: defaults.suffix,
       showStats: defaults.showStats,
+      customDateTimeFormatRegex: defaults.customDateTimeFormatRegex,
       // Override with spec-specific values (including required input/output)
       ...spec
     };
@@ -7645,6 +7780,7 @@ var init_config_loader = __esm({
       output: z2.string(),
       includeDescriptions: z2.boolean().optional(),
       useDescribe: z2.boolean().optional(),
+      defaultNullable: z2.boolean().optional(),
       schemaType: z2.enum(["all", "request", "response"]).optional(),
       prefix: z2.string().optional(),
       suffix: z2.string().optional(),
@@ -7655,13 +7791,28 @@ var init_config_loader = __esm({
       name: z2.string().optional(),
       operationFilters: OperationFiltersSchema.optional(),
       cacheSize: z2.number().positive().optional(),
-      batchSize: z2.number().positive().optional()
+      batchSize: z2.number().positive().optional(),
+      customDateTimeFormatRegex: z2.union([
+        z2.string().refine(
+          (pattern) => {
+            try {
+              new RegExp(pattern);
+              return true;
+            } catch {
+              return false;
+            }
+          },
+          { message: "Must be a valid regular expression pattern" }
+        ),
+        z2.instanceof(RegExp)
+      ]).optional()
     });
     ConfigFileSchema = z2.strictObject({
       defaults: z2.strictObject({
         mode: z2.enum(["strict", "normal", "loose"]).optional(),
         includeDescriptions: z2.boolean().optional(),
         useDescribe: z2.boolean().optional(),
+        defaultNullable: z2.boolean().optional(),
         schemaType: z2.enum(["all", "request", "response"]).optional(),
         prefix: z2.string().optional(),
         suffix: z2.string().optional(),
@@ -7671,7 +7822,21 @@ var init_config_loader = __esm({
         response: RequestResponseOptionsSchema.optional(),
         operationFilters: OperationFiltersSchema.optional(),
         cacheSize: z2.number().positive().optional(),
-        batchSize: z2.number().positive().optional()
+        batchSize: z2.number().positive().optional(),
+        customDateTimeFormatRegex: z2.union([
+          z2.string().refine(
+            (pattern) => {
+              try {
+                new RegExp(pattern);
+                return true;
+              } catch {
+                return false;
+              }
+            },
+            { message: "Must be a valid regular expression pattern" }
+          ),
+          z2.instanceof(RegExp)
+        ]).optional()
       }).optional(),
       specs: z2.array(OpenApiGeneratorOptionsSchema).min(1, {
         message: "Configuration must include at least one specification. Each specification should have 'input' and 'output' paths."