zod-nest 0.10.0 → 0.10.1

package/dist/index.js

@@ -2,25 +2,18 @@
 
 var zod = require('zod');
 var common = require('@nestjs/common');
+var core = require('@nestjs/core');
 var rxjs = require('rxjs');
 var operators = require('rxjs/operators');
 var constants_js = require('@nestjs/common/constants.js');
-var core = require('@nestjs/core');
 var stringify = require('fast-json-stable-stringify');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var stringify__default = /*#__PURE__*/_interopDefault(stringify);
 
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (decorator(result)) || result;
-  return result;
-};
-var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/schema/constants.ts
 var COMPONENTS_SCHEMAS_PREFIX = "#/components/schemas/";
@@ -32,28 +25,37 @@ var ZOD_NEST_DTO_EXTENSION = "x-zod-nest-dto";
 // src/schema/composition.ts
 var lineageMap = /* @__PURE__ */ new WeakMap();
 var propsMap = /* @__PURE__ */ new WeakMap();
-var OPTIONAL_WRAPPER_TYPES = /* @__PURE__ */ new Set(["optional", "default"]);
-var isOptionalProp = (propSchema) => OPTIONAL_WRAPPER_TYPES.has(propSchema._zod.def.type);
-var computeShapeKeys = (schema) => {
+var OPTIONAL_WRAPPER_TYPES = /* @__PURE__ */ new Set([
+  "optional",
+  "default"
+]);
+var isOptionalProp = /* @__PURE__ */ __name((propSchema) => OPTIONAL_WRAPPER_TYPES.has(propSchema._zod.def.type), "isOptionalProp");
+var computeShapeKeys = /* @__PURE__ */ __name((schema) => {
   const { shape } = schema;
   const properties = Object.keys(shape);
   const required = properties.filter((key) => {
     const propSchema = shape[key];
     return propSchema !== void 0 && !isOptionalProp(propSchema);
   });
-  return { properties, required };
-};
-var extend = (parent, build) => {
+  return {
+    properties,
+    required
+  };
+}, "computeShapeKeys");
+var extend = /* @__PURE__ */ __name((parent, build) => {
   const result = build(parent);
-  lineageMap.set(result, { op: "extend", parent });
+  lineageMap.set(result, {
+    op: "extend",
+    parent
+  });
   if (!propsMap.has(parent)) {
     propsMap.set(parent, computeShapeKeys(parent));
   }
   return result;
-};
-var getLineage = (schema) => lineageMap.get(schema);
-var DEFAULT_BUILD_REF = (id) => `${DEFS_PREFIX}${id}`;
-var createCompositionOverride = (opts) => {
+}, "extend");
+var getLineage = /* @__PURE__ */ __name((schema) => lineageMap.get(schema), "getLineage");
+var DEFAULT_BUILD_REF = /* @__PURE__ */ __name((id) => `${DEFS_PREFIX}${id}`, "DEFAULT_BUILD_REF");
+var createCompositionOverride = /* @__PURE__ */ __name((opts) => {
   const { buildRef, registry } = opts;
   return (ctx) => {
     const { jsonSchema, zodSchema } = ctx;
@@ -81,7 +83,10 @@ var createCompositionOverride = (opts) => {
       deltaProps[key] = value;
     }
     const deltaRequired = childRequired.filter((key) => !parentReqSet.has(key));
-    const delta = { type: "object", properties: deltaProps };
+    const delta = {
+      type: "object",
+      properties: deltaProps
+    };
     if (deltaRequired.length > 0) {
       delta.required = deltaRequired;
     }
@@ -89,39 +94,48 @@ var createCompositionOverride = (opts) => {
     delete jsonSchema.properties;
     delete jsonSchema.required;
     delete jsonSchema.additionalProperties;
-    jsonSchema.allOf = [{ $ref: buildRef(parentId) }, delta];
+    jsonSchema.allOf = [
+      {
+        $ref: buildRef(parentId)
+      },
+      delta
+    ];
     jsonSchema.unevaluatedProperties = false;
   };
-};
+}, "createCompositionOverride");
 
 // src/schema/errors.ts
 var ZodNestError = class extends Error {
+  static {
+    __name(this, "ZodNestError");
+  }
   constructor(message) {
     super(message);
     this.name = "ZodNestError";
   }
 };
 var ZodNestUnrepresentableError = class extends ZodNestError {
+  static {
+    __name(this, "ZodNestUnrepresentableError");
+  }
   path;
   zodType;
   constructor(path, zodType) {
-    super(
-      `Unrepresentable Zod schema \`${zodType}\` at ${formatPath(path)}: no override produced a JSON Schema body. Set strict: false to emit \`{}\` instead, or supply an \`override\` that handles this Zod type.`
-    );
+    super(`Unrepresentable Zod schema \`${zodType}\` at ${formatPath(path)}: no override produced a JSON Schema body. Set strict: false to emit \`{}\` instead, or supply an \`override\` that handles this Zod type.`);
     this.name = "ZodNestUnrepresentableError";
     this.path = path;
     this.zodType = zodType;
   }
 };
-var formatPath = (path) => {
+var formatPath = /* @__PURE__ */ __name((path) => {
   if (path.length === 0) {
     return "<root>";
   }
   return "/" + path.map(String).join("/");
-};
+}, "formatPath");
 
 // src/schema/override.ts
-var primitiveOverride = ({ zodSchema, jsonSchema }) => {
+var primitiveOverride = /* @__PURE__ */ __name(({ zodSchema, jsonSchema }) => {
   const type = zodSchema._zod.def.type;
   if (type === "bigint") {
     jsonSchema.type = "integer";
@@ -132,8 +146,8 @@ var primitiveOverride = ({ zodSchema, jsonSchema }) => {
     jsonSchema.format = "date-time";
     return;
   }
-};
-var combine = (...overrides) => {
+}, "primitiveOverride");
+var combine = /* @__PURE__ */ __name((...overrides) => {
   const list = [];
   for (const candidate of overrides) {
     if (typeof candidate !== "function") {
@@ -146,10 +160,10 @@ var combine = (...overrides) => {
       o(ctx);
     }
   };
-};
+}, "combine");
 
 // src/schema/post-process.ts
-var rewriteRefs = (node, selfRef) => {
+var rewriteRefs = /* @__PURE__ */ __name((node, selfRef) => {
   if (Array.isArray(node)) {
     for (const item of node) {
       rewriteRefs(item, selfRef);
@@ -169,8 +183,8 @@ var rewriteRefs = (node, selfRef) => {
   for (const value of Object.values(obj)) {
     rewriteRefs(value, selfRef);
   }
-};
-var postProcess = (raw) => {
+}, "rewriteRefs");
+var postProcess = /* @__PURE__ */ __name((raw) => {
   const refs = /* @__PURE__ */ new Map();
   const rawDefs = raw.$defs;
   if (rawDefs !== void 0) {
@@ -178,15 +192,20 @@ var postProcess = (raw) => {
       refs.set(id, body);
     }
   }
-  const root = { ...raw };
+  const root = {
+    ...raw
+  };
   delete root.$schema;
   delete root.$defs;
   rewriteRefs(root, void 0);
   for (const [id, body] of refs) {
     rewriteRefs(body, `${COMPONENTS_SCHEMAS_PREFIX}${id}`);
   }
-  return { schema: root, refs };
-};
+  return {
+    schema: root,
+    refs
+  };
+}, "postProcess");
 
 // src/schema/engine.ts
 var STRICT_REQUIRES_OVERRIDE = /* @__PURE__ */ new Set([
@@ -201,13 +220,13 @@ var STRICT_REQUIRES_OVERRIDE = /* @__PURE__ */ new Set([
   "nan",
   "custom"
 ]);
-var isStrictlyUnrepresentable = (jsonSchema, zodSchema) => {
+var isStrictlyUnrepresentable = /* @__PURE__ */ __name((jsonSchema, zodSchema) => {
   if (!STRICT_REQUIRES_OVERRIDE.has(zodSchema._zod.def.type)) {
     return false;
   }
   return Object.keys(jsonSchema).length === 0;
-};
-var buildToJsonSchemaOptions = (params) => {
+}, "isStrictlyUnrepresentable");
+var buildToJsonSchemaOptions = /* @__PURE__ */ __name((params) => {
   const strict = params.strict ?? true;
   const compositionOverride = createCompositionOverride({
     buildRef: params.uri ?? DEFAULT_BUILD_REF,
@@ -215,16 +234,18 @@ var buildToJsonSchemaOptions = (params) => {
   });
   const merged = combine(primitiveOverride, compositionOverride, params.override);
   const unrepresentableHits = [];
-  const wrapped = (ctx) => {
+  const wrapped = /* @__PURE__ */ __name((ctx) => {
     merged(ctx);
     if (!strict || !isStrictlyUnrepresentable(ctx.jsonSchema, ctx.zodSchema)) {
       return;
     }
     unrepresentableHits.push({
-      path: [...ctx.path],
+      path: [
+        ...ctx.path
+      ],
       zodType: ctx.zodSchema._zod.def.type
     });
-  };
+  }, "wrapped");
   const options = {
     target: "draft-2020-12",
     io: params.io,
@@ -239,15 +260,15 @@ var buildToJsonSchemaOptions = (params) => {
   }
   return {
     options,
-    consumeUnrepresentable: () => {
+    consumeUnrepresentable: /* @__PURE__ */ __name(() => {
       const firstHit = unrepresentableHits[0];
       if (firstHit !== void 0) {
         throw new ZodNestUnrepresentableError(firstHit.path, firstHit.zodType);
       }
-    }
+    }, "consumeUnrepresentable")
   };
-};
-var toOpenApi = (schema, opts) => {
+}, "buildToJsonSchemaOptions");
+var toOpenApi = /* @__PURE__ */ __name((schema, opts) => {
   const built = buildToJsonSchemaOptions({
     registry: opts.registry,
     io: opts.io,
@@ -268,25 +289,27 @@ var toOpenApi = (schema, opts) => {
     });
   }
   return result;
-};
-var createRegistry = () => {
+}, "toOpenApi");
+var createRegistry = /* @__PURE__ */ __name(() => {
   const seen = /* @__PURE__ */ new Map();
   return {
     zodRegistry: zod.z.globalRegistry,
-    register: (schema, id) => {
-      zod.z.globalRegistry.add(schema, { id });
+    register: /* @__PURE__ */ __name((schema, id) => {
+      zod.z.globalRegistry.add(schema, {
+        id
+      });
       let set = seen.get(id);
       if (set === void 0) {
         set = /* @__PURE__ */ new Set();
         seen.set(id, set);
       }
       set.add(schema);
-    },
-    hasCollision: (id) => {
+    }, "register"),
+    hasCollision: /* @__PURE__ */ __name((id) => {
       const set = seen.get(id);
       return set !== void 0 && set.size > 1;
-    },
-    getCollisions: () => {
+    }, "hasCollision"),
+    getCollisions: /* @__PURE__ */ __name(() => {
       const out = /* @__PURE__ */ new Map();
       for (const [id, set] of seen) {
         if (set.size <= 1) {
@@ -295,34 +318,39 @@ var createRegistry = () => {
         out.set(id, set);
       }
       return out;
-    },
-    ids: () => [...seen.keys()]
+    }, "getCollisions"),
+    ids: /* @__PURE__ */ __name(() => [
+      ...seen.keys()
+    ], "ids")
   };
-};
+}, "createRegistry");
 var defaultRegistry = createRegistry();
 
 // src/dto/marker.ts
-var makeZodDtoMarker = (dtoId, io) => ({
-  type: () => Object,
+var makeZodDtoMarker = /* @__PURE__ */ __name((dtoId, io) => ({
+  type: /* @__PURE__ */ __name(() => Object, "type"),
   required: false,
   __zodNestDto: true,
   dtoId,
   io
-});
-var isZodDtoMarker = (value) => {
+}), "makeZodDtoMarker");
+var isZodDtoMarker = /* @__PURE__ */ __name((value) => {
   if (value === null || typeof value !== "object") {
     return false;
   }
   return value.__zodNestDto === true;
-};
+}, "isZodDtoMarker");
 
 // src/dto/symbols.ts
 var ZOD_DTO_SYMBOL = /* @__PURE__ */ Symbol.for("zod-nest.dto");
 
 // src/dto/output-dto.ts
 var outputCache = /* @__PURE__ */ new WeakMap();
-var buildSiblingClass = (parent, schema) => {
+var buildSiblingClass = /* @__PURE__ */ __name((parent, schema) => {
   const SiblingClass = class {
+    static {
+      __name(this, "SiblingClass");
+    }
     static schema = schema;
     static io = "output";
     static [ZOD_DTO_SYMBOL] = true;
@@ -339,12 +367,14 @@ var buildSiblingClass = (parent, schema) => {
       return schema.safeParse(input);
     }
     static _OPENAPI_METADATA_FACTORY() {
-      return { [ZOD_NEST_DTO_EXTENSION]: makeZodDtoMarker(parent.id, "output") };
+      return {
+        [ZOD_NEST_DTO_EXTENSION]: makeZodDtoMarker(parent.id, "output")
+      };
     }
   };
   return SiblingClass;
-};
-var resolveOutput = (parent, schema) => {
+}, "buildSiblingClass");
+var resolveOutput = /* @__PURE__ */ __name((parent, schema) => {
   const cached = outputCache.get(parent);
   if (cached !== void 0) {
     return cached;
@@ -352,12 +382,12 @@ var resolveOutput = (parent, schema) => {
   const sibling = buildSiblingClass(parent, schema);
   outputCache.set(parent, sibling);
   return sibling;
-};
+}, "resolveOutput");
 
 // src/dto/create-zod-dto.ts
 var anonCounter = 0;
 var warnedOnAnonymous = false;
-var resolveId = (registry, schema, providedId, className) => {
+var resolveId = /* @__PURE__ */ __name((registry, schema, providedId, className) => {
   if (providedId !== void 0 && providedId !== "") {
     return providedId;
   }
@@ -372,25 +402,26 @@ var resolveId = (registry, schema, providedId, className) => {
   const fallback = `_AnonZodDto_${anonCounter}`;
   if (!warnedOnAnonymous) {
     warnedOnAnonymous = true;
-    console.warn(
-      `[zod-nest] Could not resolve a DTO id from class name (got "${className}"). Using "${fallback}". Set an explicit id via \`schema.meta({ id: 'Foo' })\` (preferred) or \`createZodDto(schema, { id: 'Foo' })\` \u2014 important under minification, where class names become single mangled characters.`
-    );
+    console.warn(`[zod-nest] Could not resolve a DTO id from class name (got "${className}"). Using "${fallback}". Set an explicit id via \`schema.meta({ id: 'Foo' })\` (preferred) or \`createZodDto(schema, { id: 'Foo' })\` \u2014 important under minification, where class names become single mangled characters.`);
   }
   return fallback;
-};
-var createZodDto = (schema, options) => {
+}, "resolveId");
+var createZodDto = /* @__PURE__ */ __name((schema, options) => {
   const registry = options?.registry ?? defaultRegistry;
   const io = "input";
   let cachedId;
-  const ensureRegistered = (className) => {
+  const ensureRegistered = /* @__PURE__ */ __name((className) => {
     if (cachedId !== void 0) {
       return cachedId;
     }
     cachedId = resolveId(registry, schema, options?.id, className);
     registry.register(schema, cachedId);
     return cachedId;
-  };
+  }, "ensureRegistered");
   const ZodDtoBase = class {
+    static {
+      __name(this, "ZodDtoBase");
+    }
     static schema = schema;
     static io = io;
     static [ZOD_DTO_SYMBOL] = true;
@@ -407,41 +438,47 @@ var createZodDto = (schema, options) => {
       return schema.safeParse(input);
     }
     static _OPENAPI_METADATA_FACTORY() {
-      return { [ZOD_NEST_DTO_EXTENSION]: makeZodDtoMarker(ensureRegistered(this.name), io) };
+      return {
+        [ZOD_NEST_DTO_EXTENSION]: makeZodDtoMarker(ensureRegistered(this.name), io)
+      };
     }
   };
   return ZodDtoBase;
-};
+}, "createZodDto");
 
 // src/dto/predicates.ts
-var isZodDto = (value) => typeof value === "function" && value[ZOD_DTO_SYMBOL] === true;
+var isZodDto = /* @__PURE__ */ __name((value) => typeof value === "function" && value[ZOD_DTO_SYMBOL] === true, "isZodDto");
 var ZodSerializationException = class extends common.InternalServerErrorException {
+  static {
+    __name(this, "ZodSerializationException");
+  }
   zodError;
   executionContext;
   constructor(zodError, executionContext) {
-    super(
-      {
-        statusCode: common.HttpStatus.INTERNAL_SERVER_ERROR,
-        message: "Response validation failed"
-      },
-      { cause: zodError }
-    );
+    super({
+      statusCode: common.HttpStatus.INTERNAL_SERVER_ERROR,
+      message: "Response validation failed"
+    }, {
+      cause: zodError
+    });
     this.zodError = zodError;
     this.executionContext = executionContext;
   }
 };
 var ZodValidationException = class extends common.BadRequestException {
+  static {
+    __name(this, "ZodValidationException");
+  }
   zodError;
   argMetadata;
   constructor(zodError, argMetadata) {
-    super(
-      {
-        statusCode: common.HttpStatus.BAD_REQUEST,
-        message: "Validation failed",
-        errors: zod.z.treeifyError(zodError)
-      },
-      { cause: zodError }
-    );
+    super({
+      statusCode: common.HttpStatus.BAD_REQUEST,
+      message: "Validation failed",
+      errors: zod.z.treeifyError(zodError)
+    }, {
+      cause: zodError
+    });
     this.zodError = zodError;
     this.argMetadata = argMetadata;
   }
@@ -449,11 +486,11 @@ var ZodValidationException = class extends common.BadRequestException {
 var DEFAULT_LOGGER_CONTEXT = "ZodValidation";
 var REDACTED = "[REDACTED]";
 var PREVIEW_RESERVE_BYTES = 100;
-var noopLogValidationFailure = () => {
-};
-var isPlainRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var noopLogValidationFailure = /* @__PURE__ */ __name(() => {
+}, "noopLogValidationFailure");
+var isPlainRecord = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value), "isPlainRecord");
 var CIRCULAR = "[CIRCULAR]";
-var redactValue = (value, redactSet, seen = /* @__PURE__ */ new WeakSet()) => {
+var redactValue = /* @__PURE__ */ __name((value, redactSet, seen = /* @__PURE__ */ new WeakSet()) => {
   if (Array.isArray(value)) {
     if (seen.has(value)) {
       return CIRCULAR;
@@ -477,13 +514,17 @@ var redactValue = (value, redactSet, seen = /* @__PURE__ */ new WeakSet()) => {
     out[key] = redactValue(value[key], redactSet, seen);
   }
   return out;
-};
-var capLoggedValue = (value, maxBytes) => {
+}, "redactValue");
+var capLoggedValue = /* @__PURE__ */ __name((value, maxBytes) => {
   let serialized;
   try {
     serialized = JSON.stringify(value);
   } catch {
-    return { _truncated: true, _originalBytes: -1, _reason: "unserializable" };
+    return {
+      _truncated: true,
+      _originalBytes: -1,
+      _reason: "unserializable"
+    };
   }
   if (serialized === void 0) {
     return value;
@@ -498,10 +539,10 @@ var capLoggedValue = (value, maxBytes) => {
     _originalBytes: byteSize,
     _preview: serialized.slice(0, previewBudget)
   };
-};
-var loggerContextFor = (side) => side === "output" ? "ZodSerializerInterceptor" : "ZodValidationPipe";
-var messageFor = (side) => side === "output" ? "Response validation failed" : "Request validation failed";
-var createValidationLogger = (opts) => {
+}, "capLoggedValue");
+var loggerContextFor = /* @__PURE__ */ __name((side) => side === "output" ? "ZodSerializerInterceptor" : "ZodValidationPipe", "loggerContextFor");
+var messageFor = /* @__PURE__ */ __name((side) => side === "output" ? "Response validation failed" : "Request validation failed", "messageFor");
+var createValidationLogger = /* @__PURE__ */ __name((opts) => {
   const redactSet = new Set(opts.redactKeys.map((key) => key.toLowerCase()));
   const { logger } = opts;
   return (err, value, ctx) => {
@@ -530,7 +571,7 @@ var createValidationLogger = (opts) => {
     }
     logger.warn(payload, loggerContext);
   };
-};
+}, "createValidationLogger");
 var DEFAULT_REDACT_KEYS = [
   // Credentials
   "password",
@@ -549,40 +590,67 @@ var DEFAULT_REDACT_KEYS = [
 ];
 var DEFAULT_MAX_LOGGED_VALUE_BYTES = 4096;
 var ZOD_NEST_OPTIONS = /* @__PURE__ */ Symbol("zod-nest.options");
-var resolveLogFlags = (validationLogs) => {
+var resolveLogFlags = /* @__PURE__ */ __name((validationLogs) => {
   if (typeof validationLogs === "boolean") {
-    return { input: validationLogs, output: validationLogs };
+    return {
+      input: validationLogs,
+      output: validationLogs
+    };
   }
   return {
     input: validationLogs?.input ?? false,
     output: validationLogs?.output ?? false
   };
-};
-var normalizeZodNestOptions = (opts) => {
+}, "resolveLogFlags");
+var normalizeZodNestOptions = /* @__PURE__ */ __name((opts) => {
   const flags = resolveLogFlags(opts?.validationLogs);
   const redactKeys = opts?.redactKeys ?? DEFAULT_REDACT_KEYS;
   const maxLoggedValueBytes = opts?.maxLoggedValueBytes ?? DEFAULT_MAX_LOGGED_VALUE_BYTES;
   const logger = opts?.logger ?? new common.Logger(DEFAULT_LOGGER_CONTEXT);
-  const loggerOpts = { logger, redactKeys, maxLoggedValueBytes };
+  const loggerOpts = {
+    logger,
+    redactKeys,
+    maxLoggedValueBytes
+  };
   return {
     createValidationException: opts?.createValidationException,
     createSerializationException: opts?.createSerializationException,
     logInputFailure: flags.input ? createValidationLogger(loggerOpts) : noopLogValidationFailure,
     logOutputFailure: flags.output ? createValidationLogger(loggerOpts) : noopLogValidationFailure
   };
-};
+}, "normalizeZodNestOptions");
 
 // src/pipes/validation.pipe.ts
-var isZodSchema = (value) => value !== null && typeof value === "object" && "_zod" in value;
-var isOptionsObject = (value) => value !== null && typeof value === "object" && !isZodSchema(value);
-var defaultExceptionFactory = (zodError, argMetadata) => new ZodValidationException(zodError, argMetadata);
-exports.ZodValidationPipe = class ZodValidationPipe {
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var isZodSchema = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && "_zod" in value, "isZodSchema");
+var isOptionsObject = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !isZodSchema(value), "isOptionsObject");
+var defaultExceptionFactory = /* @__PURE__ */ __name((zodError, argMetadata) => new ZodValidationException(zodError, argMetadata), "defaultExceptionFactory");
+exports.ZodValidationPipe = class _ZodValidationPipe {
+  static {
+    __name(this, "ZodValidationPipe");
+  }
   explicitSchema;
   explicitDtoName;
   createValidationException;
   logInputFailure;
   constructor(arg, moduleOptions) {
-    const parsed = exports.ZodValidationPipe.parseArg(arg);
+    const parsed = _ZodValidationPipe.parseArg(arg);
     this.explicitSchema = parsed.schema;
     this.explicitDtoName = parsed.dtoName;
     this.createValidationException = parsed.factory ?? moduleOptions?.createValidationException ?? defaultExceptionFactory;
@@ -627,16 +695,32 @@ exports.ZodValidationPipe = class ZodValidationPipe {
   }
   static parseArg(arg) {
     if (arg === void 0) {
-      return { schema: void 0, factory: void 0, dtoName: void 0 };
+      return {
+        schema: void 0,
+        factory: void 0,
+        dtoName: void 0
+      };
     }
     if (isZodDto(arg)) {
-      return { schema: arg.schema, factory: void 0, dtoName: arg.name };
+      return {
+        schema: arg.schema,
+        factory: void 0,
+        dtoName: arg.name
+      };
     }
     if (isZodSchema(arg)) {
-      return { schema: arg, factory: void 0, dtoName: void 0 };
+      return {
+        schema: arg,
+        factory: void 0,
+        dtoName: void 0
+      };
     }
     if (!isOptionsObject(arg)) {
-      return { schema: void 0, factory: void 0, dtoName: void 0 };
+      return {
+        schema: void 0,
+        factory: void 0,
+        dtoName: void 0
+      };
     }
     const optionSchema = arg.schema;
     const dtoName = isZodDto(optionSchema) ? optionSchema.name : void 0;
@@ -648,57 +732,76 @@ exports.ZodValidationPipe = class ZodValidationPipe {
     };
   }
 };
-exports.ZodValidationPipe = __decorateClass([
+exports.ZodValidationPipe = _ts_decorate([
   common.Injectable(),
-  __decorateParam(0, common.Optional()),
-  __decorateParam(1, common.Optional()),
-  __decorateParam(1, common.Inject(ZOD_NEST_OPTIONS))
+  _ts_param(0, common.Optional()),
+  _ts_param(1, common.Optional()),
+  _ts_param(1, common.Inject(ZOD_NEST_OPTIONS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ZodValidationPipeArg === "undefined" ? Object : ZodValidationPipeArg,
+    typeof NormalizedZodNestOptions === "undefined" ? Object : NormalizedZodNestOptions
+  ])
 ], exports.ZodValidationPipe);
 
 // src/response/metadata.ts
 var ZOD_RESPONSES_METADATA_KEY = /* @__PURE__ */ Symbol.for("zod-nest.responses");
-var getResponseVariants = (handler) => {
+var getResponseVariants = /* @__PURE__ */ __name((handler) => {
   const meta = Reflect.getMetadata(ZOD_RESPONSES_METADATA_KEY, handler);
   return meta;
-};
-var appendResponseVariant = (handler, variant) => {
+}, "getResponseVariants");
+var appendResponseVariant = /* @__PURE__ */ __name((handler, variant) => {
   const existing = Reflect.getMetadata(ZOD_RESPONSES_METADATA_KEY, handler) ?? [];
-  Reflect.defineMetadata(ZOD_RESPONSES_METADATA_KEY, [variant, ...existing], handler);
-};
+  Reflect.defineMetadata(ZOD_RESPONSES_METADATA_KEY, [
+    variant,
+    ...existing
+  ], handler);
+}, "appendResponseVariant");
 
 // src/decorators/zod-response.decorator.ts
-var buildArrayKind = (dtos) => {
+var buildArrayKind = /* @__PURE__ */ __name((dtos) => {
   for (const [index, element] of dtos.entries()) {
     if (!isZodDto(element)) {
-      throw new TypeError(
-        `[zod-nest] @ZodResponse({ type }) element [${index}] is not a zod-nest DTO (class returned by createZodDto). Wrap raw schemas with createZodDto first.`
-      );
+      throw new TypeError(`[zod-nest] @ZodResponse({ type }) element [${index}] is not a zod-nest DTO (class returned by createZodDto). Wrap raw schemas with createZodDto first.`);
     }
   }
   const [head, ...rest] = dtos;
   if (rest.length === 0) {
-    return { kind: "array", dto: [head], validationSchema: zod.z.array(head.schema) };
+    return {
+      kind: "array",
+      dto: [
+        head
+      ],
+      validationSchema: zod.z.array(head.schema)
+    };
   }
-  const tupleSchemas = [head.schema, ...rest.map((d) => d.schema)];
-  return { kind: "tuple", dto: dtos, validationSchema: zod.z.tuple(tupleSchemas) };
-};
-var buildKind = (type) => {
+  const tupleSchemas = [
+    head.schema,
+    ...rest.map((d) => d.schema)
+  ];
+  return {
+    kind: "tuple",
+    dto: dtos,
+    validationSchema: zod.z.tuple(tupleSchemas)
+  };
+}, "buildArrayKind");
+var buildKind = /* @__PURE__ */ __name((type) => {
   if (Array.isArray(type)) {
     if (type.length === 0) {
-      throw new TypeError(
-        "[zod-nest] @ZodResponse({ type: [] }) is invalid \u2014 provide at least one DTO."
-      );
+      throw new TypeError("[zod-nest] @ZodResponse({ type: [] }) is invalid \u2014 provide at least one DTO.");
     }
     return buildArrayKind(type);
   }
   if (!isZodDto(type)) {
-    throw new TypeError(
-      "[zod-nest] @ZodResponse({ type }) must be a zod-nest DTO class (from createZodDto) or an array of such classes."
-    );
+    throw new TypeError("[zod-nest] @ZodResponse({ type }) must be a zod-nest DTO class (from createZodDto) or an array of such classes.");
   }
-  return { kind: "single", dto: type, validationSchema: type.schema };
-};
-var ZodResponse = (opts) => {
+  return {
+    kind: "single",
+    dto: type,
+    validationSchema: type.schema
+  };
+}, "buildKind");
+var ZodResponse = /* @__PURE__ */ __name((opts) => {
   const built = buildKind(opts.type);
   return (_target, _propertyKey, descriptor) => {
     const handler = descriptor.value;
@@ -715,10 +818,10 @@ var ZodResponse = (opts) => {
     };
     appendResponseVariant(handler, variant);
   };
-};
+}, "ZodResponse");
 var POST_DEFAULT_STATUS = 201;
 var GENERIC_DEFAULT_STATUS = 200;
-var defaultStatusFor = (handler) => {
+var defaultStatusFor = /* @__PURE__ */ __name((handler) => {
   const httpCode = Reflect.getMetadata(constants_js.HTTP_CODE_METADATA, handler);
   if (typeof httpCode === "number") {
     return httpCode;
@@ -728,42 +831,59 @@ var defaultStatusFor = (handler) => {
     return POST_DEFAULT_STATUS;
   }
   return GENERIC_DEFAULT_STATUS;
-};
-var resolveEffectiveStatus = (variant, handler) => {
+}, "defaultStatusFor");
+var resolveEffectiveStatus = /* @__PURE__ */ __name((variant, handler) => {
   if (variant.status !== void 0) {
     return variant.status;
   }
   return defaultStatusFor(handler);
-};
+}, "resolveEffectiveStatus");
 
 // src/interceptors/serializer.interceptor.ts
-var defaultSerializationFactory = (err, ctx) => new ZodSerializationException(err, ctx);
-var formatDtoLabel = (variant) => {
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var defaultSerializationFactory = /* @__PURE__ */ __name((err, ctx) => new ZodSerializationException(err, ctx), "defaultSerializationFactory");
+var formatDtoLabel = /* @__PURE__ */ __name((variant) => {
   if (variant.kind === "single") {
     return variant.dto.name;
   }
   const dtos = variant.dto;
   return `[${dtos.map((d) => d.name).join(", ")}]`;
-};
-var formatHandlerLabel = (context) => `${context.getClass().name}.${context.getHandler().name}`;
+}, "formatDtoLabel");
+var formatHandlerLabel = /* @__PURE__ */ __name((context) => `${context.getClass().name}.${context.getHandler().name}`, "formatHandlerLabel");
 exports.ZodSerializerInterceptor = class ZodSerializerInterceptor {
+  static {
+    __name(this, "ZodSerializerInterceptor");
+  }
+  reflector;
+  logOutputFailure;
+  createSerializationException;
   constructor(reflector, options) {
     this.reflector = reflector;
     this.logOutputFailure = options?.logOutputFailure ?? noopLogValidationFailure;
     this.createSerializationException = options?.createSerializationException ?? defaultSerializationFactory;
   }
-  reflector;
-  logOutputFailure;
-  createSerializationException;
   intercept(context, next) {
     if (context.getType() !== "http") {
       return next.handle();
     }
     const handler = context.getHandler();
-    const variants = this.reflector.get(
-      ZOD_RESPONSES_METADATA_KEY,
-      handler
-    );
+    const variants = this.reflector.get(ZOD_RESPONSES_METADATA_KEY, handler);
     if (variants === void 0 || variants.length === 0) {
       return next.handle();
     }
@@ -797,35 +917,54 @@ exports.ZodSerializerInterceptor = class ZodSerializerInterceptor {
     throw this.createSerializationException(result.error, context);
   }
 };
-exports.ZodSerializerInterceptor = __decorateClass([
+exports.ZodSerializerInterceptor = _ts_decorate2([
   common.Injectable(),
-  __decorateParam(1, common.Optional()),
-  __decorateParam(1, common.Inject(ZOD_NEST_OPTIONS))
+  _ts_param2(1, common.Optional()),
+  _ts_param2(1, common.Inject(ZOD_NEST_OPTIONS)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof core.Reflector === "undefined" ? Object : core.Reflector,
+    typeof NormalizedZodNestOptions === "undefined" ? Object : NormalizedZodNestOptions
+  ])
 ], exports.ZodSerializerInterceptor);
 var ZodNestModule = class _ZodNestModule {
+  static {
+    __name(this, "ZodNestModule");
+  }
   static forRoot(options) {
     const normalized = normalizeZodNestOptions(options);
     return {
       module: _ZodNestModule,
       global: true,
       providers: [
-        { provide: ZOD_NEST_OPTIONS, useValue: normalized },
-        { provide: core.APP_PIPE, useClass: exports.ZodValidationPipe },
-        { provide: core.APP_INTERCEPTOR, useClass: exports.ZodSerializerInterceptor }
+        {
+          provide: ZOD_NEST_OPTIONS,
+          useValue: normalized
+        },
+        {
+          provide: core.APP_PIPE,
+          useClass: exports.ZodValidationPipe
+        },
+        {
+          provide: core.APP_INTERCEPTOR,
+          useClass: exports.ZodSerializerInterceptor
+        }
       ],
-      exports: [ZOD_NEST_OPTIONS]
+      exports: [
+        ZOD_NEST_OPTIONS
+      ]
     };
   }
 };
-var URI = (id) => `#/components/schemas/${id}`;
-var bulkEmit = (opts) => {
+var URI = /* @__PURE__ */ __name((id) => `#/components/schemas/${id}`, "URI");
+var bulkEmit = /* @__PURE__ */ __name((opts) => {
   const knownIds = new Set(opts.registry.ids());
   return {
     inputSchemas: runPass(opts, "input", knownIds),
     outputSchemas: runPass(opts, "output", knownIds)
   };
-};
-var runPass = (opts, io, knownIds) => {
+}, "bulkEmit");
+var runPass = /* @__PURE__ */ __name((opts, io, knownIds) => {
   const built = buildToJsonSchemaOptions({
     registry: opts.registry,
     io,
@@ -843,7 +982,7 @@ var runPass = (opts, io, knownIds) => {
     }
   }
   return filtered;
-};
+}, "runPass");
 
 // src/document/http-methods.ts
 var HTTP_METHODS = [
@@ -858,14 +997,18 @@ var HTTP_METHODS = [
 ];
 
 // src/document/collect-usage.ts
-var isPlainRecord2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-var collectUsage = (doc, app) => {
+var isPlainRecord2 = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value), "isPlainRecord");
+var collectUsage = /* @__PURE__ */ __name((doc, app) => {
   const classToDtoId = buildClassToDtoIdMap(doc);
   const inputExposedIds = collectInputExposedIds(doc, classToDtoId);
   const outputExposedIds = collectOutputExposedIds(app);
-  return { inputExposedIds, outputExposedIds, classToDtoId };
-};
-var buildClassToDtoIdMap = (doc) => {
+  return {
+    inputExposedIds,
+    outputExposedIds,
+    classToDtoId
+  };
+}, "collectUsage");
+var buildClassToDtoIdMap = /* @__PURE__ */ __name((doc) => {
   const map = /* @__PURE__ */ new Map();
   const schemas = doc.components?.schemas ?? {};
   for (const [className, schema] of Object.entries(schemas)) {
@@ -876,8 +1019,8 @@ var buildClassToDtoIdMap = (doc) => {
     map.set(className, marker.dtoId);
   }
   return map;
-};
-var readMarker = (schema) => {
+}, "buildClassToDtoIdMap");
+var readMarker = /* @__PURE__ */ __name((schema) => {
   if (!isPlainRecord2(schema)) {
     return void 0;
   }
@@ -888,9 +1031,11 @@ var readMarker = (schema) => {
   if (!isZodDtoMarker(marker)) {
     return void 0;
   }
-  return { dtoId: marker.dtoId };
-};
-var collectInputExposedIds = (doc, classToDtoId) => {
+  return {
+    dtoId: marker.dtoId
+  };
+}, "readMarker");
+var collectInputExposedIds = /* @__PURE__ */ __name((doc, classToDtoId) => {
   const ids = /* @__PURE__ */ new Set();
   const paths = doc.paths ?? {};
   for (const pathItem of Object.values(paths)) {
@@ -902,8 +1047,8 @@ var collectInputExposedIds = (doc, classToDtoId) => {
     }
   }
   return ids;
-};
-var operationsOf = (pathItem) => {
+}, "collectInputExposedIds");
+var operationsOf = /* @__PURE__ */ __name((pathItem) => {
   const out = [];
   for (const method of HTTP_METHODS) {
     const op = pathItem[method];
@@ -912,8 +1057,8 @@ var operationsOf = (pathItem) => {
     }
   }
   return out;
-};
-var collectRefsFromOperation = (operation, classToDtoId, ids) => {
+}, "operationsOf");
+var collectRefsFromOperation = /* @__PURE__ */ __name((operation, classToDtoId, ids) => {
   if (isPlainRecord2(operation.requestBody)) {
     collectRefsFromContent(operation.requestBody.content, classToDtoId, ids);
   }
@@ -926,8 +1071,8 @@ var collectRefsFromOperation = (operation, classToDtoId, ids) => {
       collectRefFromSchema(param.schema, classToDtoId, ids);
     }
   }
-};
-var collectRefsFromContent = (content, classToDtoId, ids) => {
+}, "collectRefsFromOperation");
+var collectRefsFromContent = /* @__PURE__ */ __name((content, classToDtoId, ids) => {
   if (!isPlainRecord2(content)) {
     return;
   }
@@ -937,8 +1082,8 @@ var collectRefsFromContent = (content, classToDtoId, ids) => {
     }
     collectRefFromSchema(mediaType.schema, classToDtoId, ids);
   }
-};
-var collectRefFromSchema = (schema, classToDtoId, ids) => {
+}, "collectRefsFromContent");
+var collectRefFromSchema = /* @__PURE__ */ __name((schema, classToDtoId, ids) => {
   if (!isPlainRecord2(schema)) {
     return;
   }
@@ -951,8 +1096,8 @@ var collectRefFromSchema = (schema, classToDtoId, ids) => {
   if (dtoId !== void 0) {
     ids.add(dtoId);
   }
-};
-var collectOutputExposedIds = (app) => {
+}, "collectRefFromSchema");
+var collectOutputExposedIds = /* @__PURE__ */ __name((app) => {
   const ids = /* @__PURE__ */ new Set();
   const discovery = app.get(core.DiscoveryService);
   for (const wrapper of discovery.getControllers()) {
@@ -979,8 +1124,8 @@ var collectOutputExposedIds = (app) => {
     }
   }
   return ids;
-};
-var addVariantDtoIds = (variant, ids) => {
+}, "collectOutputExposedIds");
+var addVariantDtoIds = /* @__PURE__ */ __name((variant, ids) => {
   if (variant.kind === "single") {
     if (isZodDto(variant.dto)) {
       ids.add(variant.dto.id);
@@ -995,10 +1140,13 @@ var addVariantDtoIds = (variant, ids) => {
       ids.add(dto.id);
     }
   }
-};
+}, "addVariantDtoIds");
 
 // src/document/errors.ts
 var ZodNestDocumentError = class extends ZodNestError {
+  static {
+    __name(this, "ZodNestDocumentError");
+  }
   code;
   details;
   constructor(code, message, details = {}) {
@@ -1010,7 +1158,7 @@ var ZodNestDocumentError = class extends ZodNestError {
 };
 
 // src/document/walk-refs.ts
-var walkRefs = (node, visit) => {
+var walkRefs = /* @__PURE__ */ __name((node, visit) => {
   if (node === null || typeof node !== "object") {
     return;
   }
@@ -1032,10 +1180,10 @@ var walkRefs = (node, visit) => {
     }
     walkRefs(value, visit);
   }
-};
+}, "walkRefs");
 
 // src/document/dangling-refs.ts
-var assertNoDanglingRefs = (params) => {
+var assertNoDanglingRefs = /* @__PURE__ */ __name((params) => {
   const { doc, collected } = params;
   const schemas = doc.components?.schemas ?? {};
   const dangling = [];
@@ -1053,14 +1201,12 @@ var assertNoDanglingRefs = (params) => {
     return;
   }
   const lines = dangling.map((ref) => `  - ${ref} \u2014 ${hintFor(ref, collected)}`);
-  throw new ZodNestDocumentError(
-    "DANGLING_REF",
-    `Found ${dangling.length} \`$ref\` target(s) that don't resolve to a schema in \`components.schemas\`. The most common cause is a \`meta.id\` typo on a DTO, a DTO used without \`createZodDto\`, or a \`$ref\` left behind by a pre-pass that mutated the doc before \`applyZodNest\`.
-${lines.join("\n")}`,
-    { dangling }
-  );
-};
-var hintFor = (ref, collected) => {
+  throw new ZodNestDocumentError("DANGLING_REF", `Found ${dangling.length} \`$ref\` target(s) that don't resolve to a schema in \`components.schemas\`. The most common cause is a \`meta.id\` typo on a DTO, a DTO used without \`createZodDto\`, or a \`$ref\` left behind by a pre-pass that mutated the doc before \`applyZodNest\`.
+${lines.join("\n")}`, {
+    dangling
+  });
+}, "assertNoDanglingRefs");
+var hintFor = /* @__PURE__ */ __name((ref, collected) => {
   const id = ref.slice(COMPONENTS_SCHEMAS_PREFIX.length);
   const usedInput = collected.inputExposedIds.has(id);
   const usedOutput = collected.outputExposedIds.has(id);
@@ -1074,28 +1220,23 @@ var hintFor = (ref, collected) => {
     return "used as output but body missing \u2014 DTO is registered under a different id";
   }
   return "no DTO with this id was registered \u2014 check for a meta.id typo or a DTO used without createZodDto";
-};
+}, "hintFor");
 
 // src/document/constants.ts
 var OUTPUT_SUFFIX = "Output";
 
 // src/document/merge-schemas.ts
-var mergeSchemas = (params) => {
+var mergeSchemas = /* @__PURE__ */ __name((params) => {
   const { doc, inputSchemas, outputSchemas, collected, collisions } = params;
   const schemas = ensureComponentsSchemas(doc);
   const renames = /* @__PURE__ */ new Map();
   const divergentOutputIds = /* @__PURE__ */ new Set();
-  const exposedIds = /* @__PURE__ */ new Set([...collected.inputExposedIds, ...collected.outputExposedIds]);
+  const exposedIds = /* @__PURE__ */ new Set([
+    ...collected.inputExposedIds,
+    ...collected.outputExposedIds
+  ]);
   for (const id of exposedIds) {
-    applyTruthTable(
-      schemas,
-      id,
-      collected.inputExposedIds.has(id),
-      collected.outputExposedIds.has(id),
-      inputSchemas.get(id),
-      outputSchemas.get(id),
-      divergentOutputIds
-    );
+    applyTruthTable(schemas, id, collected.inputExposedIds.has(id), collected.outputExposedIds.has(id), inputSchemas.get(id), outputSchemas.get(id), divergentOutputIds);
   }
   for (const [className, dtoId] of collected.classToDtoId) {
     if (className === dtoId) {
@@ -1105,16 +1246,19 @@ var mergeSchemas = (params) => {
     delete schemas[className];
   }
   applyCollisionDecoration(schemas, collisions, divergentOutputIds);
-  return { divergentOutputIds, renames };
-};
-var ensureComponentsSchemas = (doc) => {
+  return {
+    divergentOutputIds,
+    renames
+  };
+}, "mergeSchemas");
+var ensureComponentsSchemas = /* @__PURE__ */ __name((doc) => {
   const components = doc.components ?? {};
   doc.components = components;
   const schemas = components.schemas ?? {};
   components.schemas = schemas;
   return schemas;
-};
-var applyTruthTable = (schemas, id, inputExposed, outputExposed, inputBody, outputBody, divergentOutputIds) => {
+}, "ensureComponentsSchemas");
+var applyTruthTable = /* @__PURE__ */ __name((schemas, id, inputExposed, outputExposed, inputBody, outputBody, divergentOutputIds) => {
   if (inputExposed && !outputExposed) {
     writeOrThrowAmbiguous(schemas, id, inputBody);
     return;
@@ -1130,8 +1274,8 @@ var applyTruthTable = (schemas, id, inputExposed, outputExposed, inputBody, outp
   writeOrThrowAmbiguous(schemas, id, inputBody);
   writeOrThrowAmbiguous(schemas, `${id}${OUTPUT_SUFFIX}`, outputBody);
   divergentOutputIds.add(id);
-};
-var writeOrThrowAmbiguous = (schemas, key, body) => {
+}, "applyTruthTable");
+var writeOrThrowAmbiguous = /* @__PURE__ */ __name((schemas, key, body) => {
   if (body === void 0) {
     return;
   }
@@ -1140,13 +1284,11 @@ var writeOrThrowAmbiguous = (schemas, key, body) => {
     schemas[key] = body;
     return;
   }
-  throw new ZodNestDocumentError(
-    "AMBIGUOUS_RENAME",
-    `Two distinct schemas target \`components.schemas[${key}]\` with differing bodies \u2014 multiple createZodDto classes likely share the same dtoId. Set distinct \`options.id\` values, or align the class names so renames are unambiguous.`,
-    { key }
-  );
-};
-var isMarkerPlaceholder = (value) => {
+  throw new ZodNestDocumentError("AMBIGUOUS_RENAME", `Two distinct schemas target \`components.schemas[${key}]\` with differing bodies \u2014 multiple createZodDto classes likely share the same dtoId. Set distinct \`options.id\` values, or align the class names so renames are unambiguous.`, {
+    key
+  });
+}, "writeOrThrowAmbiguous");
+var isMarkerPlaceholder = /* @__PURE__ */ __name((value) => {
   if (value === null || typeof value !== "object") {
     return false;
   }
@@ -1156,8 +1298,8 @@ var isMarkerPlaceholder = (value) => {
   }
   const marker = properties[ZOD_NEST_DTO_EXTENSION];
   return isZodDtoMarker(marker);
-};
-var canonicalEqual = (a, b) => {
+}, "isMarkerPlaceholder");
+var canonicalEqual = /* @__PURE__ */ __name((a, b) => {
   if (a === b) {
     return true;
   }
@@ -1165,16 +1307,16 @@ var canonicalEqual = (a, b) => {
     return false;
   }
   return stringify__default.default(a) === stringify__default.default(b);
-};
-var applyCollisionDecoration = (schemas, collisions, divergentOutputIds) => {
+}, "canonicalEqual");
+var applyCollisionDecoration = /* @__PURE__ */ __name((schemas, collisions, divergentOutputIds) => {
   for (const [id] of collisions) {
     decorateIfPresent(schemas, id);
     if (divergentOutputIds.has(id)) {
       decorateIfPresent(schemas, `${id}${OUTPUT_SUFFIX}`);
     }
   }
-};
-var decorateIfPresent = (schemas, key) => {
+}, "applyCollisionDecoration");
+var decorateIfPresent = /* @__PURE__ */ __name((schemas, key) => {
   if (!(key in schemas)) {
     return;
   }
@@ -1182,10 +1324,10 @@ var decorateIfPresent = (schemas, key) => {
     description: `ERROR: duplicate zod-nest id <${key.replace(/Output$/, "")}>`,
     [ZOD_NEST_ERROR_EXTENSION]: ZOD_NEST_ERROR_DUPLICATE_ID
   };
-};
+}, "decorateIfPresent");
 
 // src/document/rewrite-refs.ts
-var rewriteRefs2 = (params) => {
+var rewriteRefs2 = /* @__PURE__ */ __name((params) => {
   const { doc, renames, divergentOutputIds } = params;
   if (renames.size > 0) {
     walkRefs(doc, (ref) => {
@@ -1210,8 +1352,8 @@ var rewriteRefs2 = (params) => {
     }
     rewriteResponseSubtree(pathItem, divergentOutputIds);
   }
-};
-var rewriteResponseSubtree = (pathItem, divergentOutputIds) => {
+}, "rewriteRefs");
+var rewriteResponseSubtree = /* @__PURE__ */ __name((pathItem, divergentOutputIds) => {
   for (const method of HTTP_METHODS) {
     const op = pathItem[method];
     if (op === null || typeof op !== "object") {
@@ -1232,10 +1374,10 @@ var rewriteResponseSubtree = (pathItem, divergentOutputIds) => {
       return `${COMPONENTS_SCHEMAS_PREFIX}${target}${OUTPUT_SUFFIX}`;
     });
   }
-};
+}, "rewriteResponseSubtree");
 
 // src/document/strip-markers.ts
-var stripMarkers = (doc) => {
+var stripMarkers = /* @__PURE__ */ __name((doc) => {
   const schemas = doc.components?.schemas;
   if (schemas === void 0) {
     return;
@@ -1243,8 +1385,8 @@ var stripMarkers = (doc) => {
   for (const schema of Object.values(schemas)) {
     stripMarkerFromSchema(schema);
   }
-};
-var stripMarkerFromSchema = (schema) => {
+}, "stripMarkers");
+var stripMarkerFromSchema = /* @__PURE__ */ __name((schema) => {
   if (schema === null || typeof schema !== "object") {
     return;
   }
@@ -1260,10 +1402,10 @@ var stripMarkerFromSchema = (schema) => {
   if (Object.keys(props).length === 0) {
     delete schema.properties;
   }
-};
+}, "stripMarkerFromSchema");
 
 // src/document/apply-zod-nest.ts
-var applyZodNest = (doc, opts) => {
+var applyZodNest = /* @__PURE__ */ __name((doc, opts) => {
   const registry = opts.registry ?? defaultRegistry;
   const collected = collectUsage(doc, opts.app);
   const { inputSchemas, outputSchemas } = bulkEmit({
@@ -1278,11 +1420,18 @@ var applyZodNest = (doc, opts) => {
     collected,
     collisions: registry.getCollisions()
   });
-  rewriteRefs2({ doc, renames, divergentOutputIds });
+  rewriteRefs2({
+    doc,
+    renames,
+    divergentOutputIds
+  });
   stripMarkers(doc);
-  assertNoDanglingRefs({ doc, collected });
+  assertNoDanglingRefs({
+    doc,
+    collected
+  });
   return doc;
-};
+}, "applyZodNest");
 
 exports.COMPONENTS_SCHEMAS_PREFIX = COMPONENTS_SCHEMAS_PREFIX;
 exports.DEFAULT_MAX_LOGGED_VALUE_BYTES = DEFAULT_MAX_LOGGED_VALUE_BYTES;