zod-nest 3.2.0 → 3.2.2

package/dist/fastify/index.js

@@ -1,1125 +1,34 @@
 'use strict';
 
-var zod = require('zod');
-var swagger = require('@nestjs/swagger');
-var common = require('@nestjs/common');
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/helpers/fragments.ts
-var binaryFragment = {
-  type: "string",
-  format: "binary"
-};
-var binary = /* @__PURE__ */ __name((opts) => ({
-  ...binaryFragment,
-  ...opts
-}), "binary");
-
-// src/schema/custom-override.ts
-var customOverrideMap = /* @__PURE__ */ new WeakMap();
-var isWrapper = /* @__PURE__ */ __name((arg) => "input" in arg || "output" in arg, "isWrapper");
-var overrideJSONSchema = /* @__PURE__ */ __name((schema, arg) => {
-  const overrideSchema = isWrapper(arg) ? {
-    ...arg
-  } : {
-    input: arg,
-    output: arg
-  };
-  const schemaDescription = schema.description;
-  if (typeof schemaDescription === "string") {
-    overrideSchema.description = schemaDescription;
-  }
-  customOverrideMap.set(schema, overrideSchema);
-  return schema;
-}, "overrideJSONSchema");
-var peekRegistration = /* @__PURE__ */ __name((schema) => customOverrideMap.get(schema), "peekRegistration");
-var createCustomOverride = /* @__PURE__ */ __name((io) => {
-  return ({ zodSchema, jsonSchema }) => {
-    const record = customOverrideMap.get(zodSchema);
-    if (record === void 0) {
-      return;
-    }
-    const fragment = record[io];
-    if (fragment === void 0) {
-      return;
-    }
-    for (const key of Object.keys(jsonSchema)) {
-      Reflect.deleteProperty(jsonSchema, key);
-    }
-    Object.assign(jsonSchema, fragment);
-    if (fragment.description === void 0 && record.description !== void 0) {
-      jsonSchema.description = record.description;
-    }
-  };
-}, "createCustomOverride");
-
-// src/multipart/file-checks.ts
-var normalizeExtension = /* @__PURE__ */ __name((extension) => extension.startsWith(".") ? extension.toLowerCase() : `.${extension.toLowerCase()}`, "normalizeExtension");
-var mimeTypeCheck = /* @__PURE__ */ __name((accessors2, options) => {
-  const allowed = new Set(options.mimeTypes.map((mimeType) => mimeType.toLowerCase()));
-  return (payload) => {
-    const mimeType = accessors2.mimeType(payload.value).toLowerCase();
-    if (allowed.has(mimeType)) {
-      return;
-    }
-    payload.issues.push({
-      code: "custom",
-      input: payload.value,
-      message: `Expected one of ${options.mimeTypes.join(", ")}, received ${mimeType}`
-    });
-  };
-}, "mimeTypeCheck");
-var extensionCheck = /* @__PURE__ */ __name((accessors2, options) => {
-  const allowed = new Set(options.extensions.map(normalizeExtension));
-  return (payload) => {
-    const fileName = accessors2.fileName(payload.value).toLowerCase();
-    const matched = [
-      ...allowed
-    ].some((extension) => fileName.endsWith(extension));
-    if (matched) {
-      return;
-    }
-    payload.issues.push({
-      code: "custom",
-      input: payload.value,
-      message: `Expected a file ending in ${options.extensions.map(normalizeExtension).join(", ")}, received ${fileName}`
-    });
-  };
-}, "extensionCheck");
-var sizeCheck = /* @__PURE__ */ __name((readSize, options) => {
-  return (payload) => {
-    const size = readSize(payload.value);
-    if (size <= options.maxSize) {
-      return;
-    }
-    payload.issues.push({
-      code: "custom",
-      input: payload.value,
-      message: `Expected at most ${options.maxSize} bytes, received ${size}`
-    });
-  };
-}, "sizeCheck");
-
-// src/multipart/file-marker.ts
-var fileSchemas = /* @__PURE__ */ new WeakSet();
-var isZodType = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && "_zod" in value, "isZodType");
-var innerOf = /* @__PURE__ */ __name((def) => {
-  if ("innerType" in def) {
-    return def.innerType;
-  }
-  if ("element" in def) {
-    return def.element;
-  }
-  return void 0;
-}, "innerOf");
-var unwrapOnce = /* @__PURE__ */ __name((schema) => {
-  const inner = innerOf(schema._zod.def);
-  return isZodType(inner) ? inner : void 0;
-}, "unwrapOnce");
-var markFileSchema = /* @__PURE__ */ __name((schema) => {
-  fileSchemas.add(schema);
-  return schema;
-}, "markFileSchema");
-var isFileSchema = /* @__PURE__ */ __name((schema) => {
-  if (fileSchemas.has(schema)) {
-    return true;
-  }
-  const inner = unwrapOnce(schema);
-  if (inner === void 0) {
-    return false;
-  }
-  return isFileSchema(inner);
-}, "isFileSchema");
-
-// src/multipart/build-file-schema.ts
-var resolveFragment = /* @__PURE__ */ __name((options) => {
-  const contentMediaType = options?.contentMediaType ?? singleMimeType(options?.mimeTypes);
-  return binary({
-    ...options?.description !== void 0 ? {
-      description: options.description
-    } : {},
-    ...contentMediaType !== void 0 ? {
-      contentMediaType
-    } : {}
-  });
-}, "resolveFragment");
-var singleMimeType = /* @__PURE__ */ __name((mimeTypes) => {
-  if (mimeTypes === void 0 || mimeTypes.length !== 1) {
-    return void 0;
-  }
-  return mimeTypes[0];
-}, "singleMimeType");
-var collectChecks = /* @__PURE__ */ __name((params) => {
-  const { accessors: accessors2, options, maxSize } = params;
-  const checks = [];
-  if (options?.mimeTypes !== void 0) {
-    checks.push(mimeTypeCheck(accessors2, {
-      mimeTypes: options.mimeTypes
-    }));
-  }
-  if (options?.extensions !== void 0) {
-    checks.push(extensionCheck(accessors2, {
-      extensions: options.extensions
-    }));
-  }
-  if (maxSize !== void 0 && accessors2.size !== void 0) {
-    checks.push(sizeCheck(accessors2.size, {
-      maxSize
-    }));
-  }
-  return checks;
-}, "collectChecks");
-var withId = /* @__PURE__ */ __name((schema, options, fragment) => {
-  if (options?.id === void 0) {
-    return schema;
-  }
-  return overrideJSONSchema(schema.meta({
-    id: options.id
-  }), fragment);
-}, "withId");
-var buildFileSchema = /* @__PURE__ */ __name((params) => {
-  const fragment = resolveFragment(params.options);
-  const base = overrideJSONSchema(zod.z.custom(params.predicate), fragment);
-  const checks = collectChecks(params);
-  const checked = checks.length === 0 ? base : overrideJSONSchema(base.check(...checks), fragment);
-  return markFileSchema(withId(checked, params.options, fragment));
-}, "buildFileSchema");
-
-// src/multipart/metadata.ts
-var MultipartFilesIn = {
-  Request: "request",
-  Body: "body"
-};
-var ZOD_MULTIPART_METADATA_KEY = /* @__PURE__ */ Symbol.for("zod-nest.multipart");
-var INNER_TYPE_WRAPPERS = /* @__PURE__ */ new Set([
-  "optional",
-  "nullable",
-  "default",
-  "prefault",
-  "catch",
-  "nonoptional",
-  "success",
-  "readonly",
-  "promise"
-]);
-var readId = /* @__PURE__ */ __name((schema) => {
-  const meta = zod.z.globalRegistry.get(schema);
-  if (meta === void 0) {
-    return void 0;
-  }
-  const id = meta.id;
-  return typeof id === "string" ? id : void 0;
-}, "readId");
-var resolveLazyTarget = /* @__PURE__ */ __name((getter) => {
-  try {
-    return [
-      getter()
-    ];
-  } catch (error) {
-    if (error instanceof ReferenceError) {
-      return [];
-    }
-    throw error;
-  }
-}, "resolveLazyTarget");
-var collectChildren = /* @__PURE__ */ __name((schema) => {
-  const def = schema._zod.def;
-  if (def.type === "object") {
-    const out = [];
-    const shape = def.shape;
-    if (shape !== void 0) {
-      for (const value of Object.values(shape)) {
-        out.push(value);
-      }
-    }
-    if (def.catchall !== void 0) {
-      out.push(def.catchall);
-    }
-    return out;
-  }
-  if (def.type === "array") {
-    return [
-      def.element
-    ];
-  }
-  if (def.type === "union") {
-    return def.options.map((opt) => opt);
-  }
-  if (def.type === "intersection") {
-    return [
-      def.left,
-      def.right
-    ];
-  }
-  if (def.type === "tuple") {
-    const out = def.items.map((it) => it);
-    if (def.rest !== null) {
-      out.push(def.rest);
-    }
-    return out;
-  }
-  if (def.type === "record" || def.type === "map") {
-    return [
-      def.keyType,
-      def.valueType
-    ];
-  }
-  if (def.type === "set") {
-    return [
-      def.valueType
-    ];
-  }
-  if (def.type === "pipe") {
-    return [
-      def.in,
-      def.out
-    ];
-  }
-  if (def.type === "lazy") {
-    return resolveLazyTarget(() => def.getter());
-  }
-  if (INNER_TYPE_WRAPPERS.has(def.type)) {
-    return [
-      def.innerType
-    ];
-  }
-  return [];
-}, "collectChildren");
-var discoverDependents = /* @__PURE__ */ __name((schema) => {
-  const visited = /* @__PURE__ */ new WeakSet();
-  const out = [];
-  const stack = [
-    schema
-  ];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    if (visited.has(current)) {
-      continue;
-    }
-    visited.add(current);
-    for (const child of collectChildren(current)) {
-      if (child === void 0 || visited.has(child)) {
-        continue;
-      }
-      const id = readId(child);
-      if (id !== void 0) {
-        out.push([
-          child,
-          id
-        ]);
-      }
-      stack.push(child);
-    }
-  }
-  return out;
-}, "discoverDependents");
-
-// src/schema/constants.ts
-var COMPONENTS_SCHEMAS_PREFIX = "#/components/schemas/";
-var DEFS_PREFIX = "#/$defs/";
-var ZOD_NEST_ERROR_EXTENSION = "x-zod-nest-error";
-var ZOD_NEST_ERROR_DUPLICATE_ID = "duplicate-id";
-var createRegistry = /* @__PURE__ */ __name(() => {
-  const seen = /* @__PURE__ */ new Map();
-  const forceExposed = /* @__PURE__ */ new Set();
-  const anonymous = /* @__PURE__ */ new Set();
-  const pendingRoots = [];
-  const recordOnce = /* @__PURE__ */ __name((schema, id) => {
-    let set = seen.get(id);
-    if (set === void 0) {
-      set = /* @__PURE__ */ new Set();
-      seen.set(id, set);
-    }
-    if (set.has(schema)) {
-      return false;
-    }
-    set.add(schema);
-    return true;
-  }, "recordOnce");
-  const flushPendingDiscovery = /* @__PURE__ */ __name(() => {
-    for (const root of pendingRoots.splice(0)) {
-      for (const [child, childId] of discoverDependents(root)) {
-        recordOnce(child, childId);
-      }
-    }
-  }, "flushPendingDiscovery");
-  return {
-    zodRegistry: zod.z.globalRegistry,
-    register: /* @__PURE__ */ __name((schema, id, flags) => {
-      if (flags?.expose === true) {
-        forceExposed.add(id);
-      }
-      if (flags?.anonymous === true) {
-        anonymous.add(id);
-      }
-      if (zod.z.globalRegistry.has(schema)) {
-        const existing = zod.z.globalRegistry.get(schema);
-        if (existing?.id !== id) {
-          zod.z.globalRegistry.add(schema, {
-            ...existing ?? {},
-            id
-          });
-        }
-      } else {
-        zod.z.globalRegistry.add(schema, {
-          id
-        });
-      }
-      if (!recordOnce(schema, id)) {
-        return;
-      }
-      pendingRoots.push(schema);
-    }, "register"),
-    hasCollision: /* @__PURE__ */ __name((id) => {
-      flushPendingDiscovery();
-      const set = seen.get(id);
-      return set !== void 0 && set.size > 1;
-    }, "hasCollision"),
-    getCollisions: /* @__PURE__ */ __name(() => {
-      flushPendingDiscovery();
-      const out = /* @__PURE__ */ new Map();
-      for (const [id, set] of seen) {
-        if (set.size <= 1) {
-          continue;
-        }
-        out.set(id, set);
-      }
-      return out;
-    }, "getCollisions"),
-    ids: /* @__PURE__ */ __name(() => {
-      flushPendingDiscovery();
-      return [
-        ...seen.keys()
-      ];
-    }, "ids"),
-    forceExposedIds: /* @__PURE__ */ __name(() => [
-      ...forceExposed
-    ], "forceExposedIds"),
-    anonymousIds: /* @__PURE__ */ __name(() => [
-      ...anonymous
-    ], "anonymousIds")
-  };
-}, "createRegistry");
-var defaultRegistry = createRegistry();
-var registerSchema = /* @__PURE__ */ __name((schema, registry = defaultRegistry, options) => {
-  const flags = {
-    expose: options?.expose,
-    anonymous: options?.anonymous
-  };
-  const explicit = options?.id;
-  if (typeof explicit === "string" && explicit !== "") {
-    registry.register(schema, explicit, flags);
-    return explicit;
-  }
-  const meta = registry.zodRegistry.get(schema);
-  const metaId = meta === void 0 ? void 0 : meta.id;
-  if (typeof metaId !== "string" || metaId === "") {
-    return void 0;
-  }
-  registry.register(schema, metaId, flags);
-  return metaId;
-}, "registerSchema");
-
-// src/schema/composition.ts
-var lineageMap = /* @__PURE__ */ new WeakMap();
-var propsMap = /* @__PURE__ */ new WeakMap();
-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;
-    const entry = lineageMap.get(zodSchema);
-    if (entry === void 0) {
-      return;
-    }
-    const parentCache = propsMap.get(entry.parent);
-    if (parentCache === void 0) {
-      return;
-    }
-    const parentId = registry.zodRegistry.get(entry.parent)?.id;
-    if (parentId === void 0) {
-      return;
-    }
-    registerSchema(entry.parent, registry);
-    const childProps = jsonSchema.properties ?? {};
-    const childRequired = jsonSchema.required ?? [];
-    const parentPropSet = new Set(parentCache.properties);
-    const parentReqSet = new Set(parentCache.required);
-    const deltaProps = {};
-    for (const [key, value] of Object.entries(childProps)) {
-      if (parentPropSet.has(key) && !entry.overriddenKeys.has(key)) {
-        continue;
-      }
-      deltaProps[key] = value;
-    }
-    const deltaRequired = childRequired.filter((key) => !parentReqSet.has(key) || entry.overriddenKeys.has(key));
-    const delta = {
-      type: "object",
-      properties: deltaProps
-    };
-    if (deltaRequired.length > 0) {
-      delta.required = deltaRequired;
-    }
-    delete jsonSchema.properties;
-    delete jsonSchema.required;
-    delete jsonSchema.additionalProperties;
-    jsonSchema.type = "object";
-    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.`);
-    this.name = "ZodNestUnrepresentableError";
-    this.path = path;
-    this.zodType = zodType;
-  }
-};
-var formatPath = /* @__PURE__ */ __name((path) => {
-  if (path.length === 0) {
-    return "<root>";
-  }
-  return "/" + path.map(String).join("/");
-}, "formatPath");
-
-// src/schema/override.ts
-var primitiveOverride = /* @__PURE__ */ __name(({ zodSchema, jsonSchema }) => {
-  const type = zodSchema._zod.def.type;
-  if (type === "bigint") {
-    jsonSchema.type = "integer";
-    return;
-  }
-  if (type === "date") {
-    jsonSchema.type = "string";
-    jsonSchema.format = "date-time";
-    return;
-  }
-}, "primitiveOverride");
-var combine = /* @__PURE__ */ __name((...overrides) => {
-  const list = [];
-  for (const candidate of overrides) {
-    if (typeof candidate !== "function") {
-      continue;
-    }
-    list.push(candidate);
-  }
-  return (ctx) => {
-    for (const o of list) {
-      o(ctx);
-    }
-  };
-}, "combine");
-
-// src/schema/post-process.ts
-var rewriteRefs = /* @__PURE__ */ __name((node, rootRef) => {
-  if (Array.isArray(node)) {
-    for (const item of node) {
-      rewriteRefs(item, rootRef);
-    }
-    return;
-  }
-  if (node === null || typeof node !== "object") {
-    return;
-  }
-  const obj = node;
-  const ref = obj.$ref;
-  if (typeof ref === "string" && ref.startsWith(DEFS_PREFIX)) {
-    obj.$ref = COMPONENTS_SCHEMAS_PREFIX + ref.slice(DEFS_PREFIX.length);
-  } else if (ref === "#" && rootRef !== void 0) {
-    obj.$ref = rootRef;
-  }
-  for (const value of Object.values(obj)) {
-    rewriteRefs(value, rootRef);
-  }
-}, "rewriteRefs");
-var refsIn = /* @__PURE__ */ __name(function* (node) {
-  if (Array.isArray(node)) {
-    for (const item of node) {
-      yield* refsIn(item);
-    }
-    return;
-  }
-  if (node === null || typeof node !== "object") {
-    return;
-  }
-  const obj = node;
-  if (typeof obj.$ref === "string") {
-    yield obj.$ref;
-  }
-  for (const value of Object.values(obj)) {
-    yield* refsIn(value);
-  }
-}, "refsIn");
-var rootDefId = /* @__PURE__ */ __name((raw) => {
-  const ref = raw.$ref;
-  if (typeof ref !== "string" || !ref.startsWith(DEFS_PREFIX)) {
-    return void 0;
-  }
-  return ref.slice(DEFS_PREFIX.length);
-}, "rootDefId");
-var isReferenced = /* @__PURE__ */ __name((defs, id) => {
-  const ownRef = `${DEFS_PREFIX}${id}`;
-  for (const ref of refsIn(defs)) {
-    if (ref === "#" || ref === ownRef) {
-      return true;
-    }
-  }
-  return false;
-}, "isReferenced");
-var referencesRoot = /* @__PURE__ */ __name((raw) => {
-  for (const ref of refsIn(raw)) {
-    if (ref === "#") {
-      return true;
-    }
-  }
-  return false;
-}, "referencesRoot");
-var stripEnvelope = /* @__PURE__ */ __name((raw) => {
-  const root = {
-    ...raw
-  };
-  delete root.$schema;
-  delete root.$defs;
-  return root;
-}, "stripEnvelope");
-var resolveRoot = /* @__PURE__ */ __name((raw, refs, options) => {
-  const liftedId = rootDefId(raw);
-  if (liftedId !== void 0) {
-    const body = refs.get(liftedId);
-    if (body !== void 0 && !isReferenced(raw.$defs, liftedId)) {
-      refs.delete(liftedId);
-      return {
-        schema: body,
-        rootRef: void 0
-      };
-    }
-    return {
-      schema: stripEnvelope(raw),
-      rootRef: `${COMPONENTS_SCHEMAS_PREFIX}${liftedId}`
-    };
-  }
-  const root = stripEnvelope(raw);
-  if (!referencesRoot(raw)) {
-    return {
-      schema: root,
-      rootRef: void 0
-    };
-  }
-  const rootId = options?.rootId;
-  if (rootId === void 0) {
-    if (options?.strict ?? true) {
-      throw new ZodNestError('A schema referenced from inside its own emission has no id, so the reference cannot be resolved. Add `.meta({ id: "\u2026" })` to the root schema, or set strict: false to leave the reference unresolved.');
-    }
-    return {
-      schema: root,
-      rootRef: void 0
-    };
-  }
-  refs.set(rootId, root);
-  const rootRef = `${COMPONENTS_SCHEMAS_PREFIX}${rootId}`;
-  return {
-    schema: {
-      $ref: rootRef
-    },
-    rootRef
-  };
-}, "resolveRoot");
-var postProcess = /* @__PURE__ */ __name((raw, options) => {
-  const refs = /* @__PURE__ */ new Map();
-  const rawDefs = raw.$defs;
-  if (rawDefs !== void 0) {
-    for (const [id, body] of Object.entries(rawDefs)) {
-      refs.set(id, body);
-    }
-  }
-  const { schema, rootRef } = resolveRoot(raw, refs, options);
-  rewriteRefs(schema, rootRef);
-  for (const body of refs.values()) {
-    rewriteRefs(body, rootRef);
-  }
-  return {
-    schema,
-    refs
-  };
-}, "postProcess");
-
-// src/schema/engine.ts
-var STRICT_REQUIRES_OVERRIDE = /* @__PURE__ */ new Set([
-  "bigint",
-  "date",
-  "symbol",
-  "undefined",
-  "void",
-  "map",
-  "set",
-  "transform",
-  "nan",
-  "custom"
-]);
-var ANNOTATION_ONLY_KEYS = /* @__PURE__ */ new Set([
-  "title",
-  "description",
-  "deprecated",
-  "examples",
-  "default",
-  "readOnly",
-  "writeOnly",
-  "$id",
-  "$schema",
-  "$comment",
-  "id"
-]);
-var isStrictlyUnrepresentable = /* @__PURE__ */ __name((jsonSchema, zodSchema) => {
-  if (!STRICT_REQUIRES_OVERRIDE.has(zodSchema._zod.def.type)) {
-    return false;
-  }
-  return Object.keys(jsonSchema).every((key) => ANNOTATION_ONLY_KEYS.has(key));
-}, "isStrictlyUnrepresentable");
-var markPipeCoverage = /* @__PURE__ */ __name((schema, io, covered) => {
-  const def = schema._zod.def;
-  if (def.type !== "pipe" || def.in === void 0 || def.out === void 0) {
-    return;
-  }
-  const target = io === "output" ? def.out : def.in._zod.traits.has("$ZodTransform") ? def.out : def.in;
-  if (covered.has(target)) {
-    return;
-  }
-  covered.add(target);
-  markPipeCoverage(target, io, covered);
-}, "markPipeCoverage");
-var buildToJsonSchemaOptions = /* @__PURE__ */ __name((params) => {
-  const strict = params.strict ?? true;
-  const compositionOverride = createCompositionOverride({
-    buildRef: params.uri ?? DEFAULT_BUILD_REF,
-    registry: params.registry
-  });
-  const customOverride = createCustomOverride(params.io);
-  const merged = combine(primitiveOverride, compositionOverride, customOverride, params.override);
-  const unrepresentableHits = [];
-  const coveredByPipe = /* @__PURE__ */ new WeakSet();
-  const wrapped = /* @__PURE__ */ __name((ctx) => {
-    merged(ctx);
-    if (ctx.zodSchema._zod.def.type === "pipe") {
-      const record = peekRegistration(ctx.zodSchema);
-      if (record !== void 0 && record[params.io] !== void 0) {
-        markPipeCoverage(ctx.zodSchema, params.io, coveredByPipe);
-      }
-    }
-    if (!strict || !isStrictlyUnrepresentable(ctx.jsonSchema, ctx.zodSchema)) {
-      return;
-    }
-    unrepresentableHits.push({
-      path: [
-        ...ctx.path
-      ],
-      zodType: ctx.zodSchema._zod.def.type,
-      zodSchema: ctx.zodSchema
-    });
-  }, "wrapped");
-  const options = {
-    target: "draft-2020-12",
-    io: params.io,
-    unrepresentable: "any",
-    metadata: params.registry.zodRegistry,
-    override: wrapped,
-    cycles: "ref",
-    reused: params.reused
-  };
-  if (params.uri !== void 0) {
-    options.uri = params.uri;
-  }
-  return {
-    options,
-    consumeUnrepresentable: /* @__PURE__ */ __name(() => {
-      const firstHit = unrepresentableHits.find((hit) => !coveredByPipe.has(hit.zodSchema));
-      if (firstHit !== void 0) {
-        throw new ZodNestUnrepresentableError(firstHit.path, firstHit.zodType);
-      }
-    }, "consumeUnrepresentable")
-  };
-}, "buildToJsonSchemaOptions");
-var resolveRootId = /* @__PURE__ */ __name((schema, registry) => {
-  const id = registry.zodRegistry.get(schema)?.id;
-  return typeof id === "string" && id !== "" ? id : void 0;
-}, "resolveRootId");
-var toOpenApi = /* @__PURE__ */ __name((schema, opts) => {
-  const built = buildToJsonSchemaOptions({
-    registry: opts.registry,
-    io: opts.io,
-    override: opts.override,
-    strict: opts.strict,
-    reused: "inline"
-  });
-  const raw = zod.z.toJSONSchema(schema, built.options);
-  built.consumeUnrepresentable();
-  const result = postProcess(raw, {
-    rootId: resolveRootId(schema, opts.registry),
-    strict: opts.strict
-  });
-  for (const [id] of opts.registry.getCollisions()) {
-    if (!result.refs.has(id)) {
-      continue;
-    }
-    result.refs.set(id, {
-      description: `ERROR: duplicate zod-nest id <${id}>`,
-      [ZOD_NEST_ERROR_EXTENSION]: ZOD_NEST_ERROR_DUPLICATE_ID
-    });
-  }
-  return result;
-}, "toOpenApi");
-
-// src/schema/anon-id.ts
-var ANON_BODY_PREFIX = "_AnonBodySchema_";
-var anonIdCache = /* @__PURE__ */ new WeakMap();
-var counter = 0;
-var resolveAnonId = /* @__PURE__ */ __name((schema, prefix) => {
-  const cached = anonIdCache.get(schema);
-  if (cached !== void 0) {
-    return cached;
-  }
-  counter += 1;
-  const id = `${prefix}${counter}`;
-  anonIdCache.set(schema, id);
-  return id;
-}, "resolveAnonId");
-
-// src/decorators/internal/zod-schema-ref.ts
-function resolveSchemaRef(schema, options) {
-  const registry = options?.registry ?? defaultRegistry;
-  const id = registerSchema(schema, registry, {
-    id: options?.id
-  });
-  if (id !== void 0) {
-    return {
-      kind: "ref",
-      ref: {
-        $ref: `${COMPONENTS_SCHEMAS_PREFIX}${id}`
-      }
-    };
-  }
-  if (options?.deferAnonInline === true) {
-    const anonId = resolveAnonId(schema, ANON_BODY_PREFIX);
-    registerSchema(schema, registry, {
-      id: anonId,
-      anonymous: true
-    });
-    return {
-      kind: "ref",
-      ref: {
-        $ref: `${COMPONENTS_SCHEMAS_PREFIX}${anonId}`
-      }
-    };
-  }
-  for (const [child, childId] of discoverDependents(schema)) {
-    registry.register(child, childId);
-  }
-  const { schema: body } = toOpenApi(schema, {
-    io: "input",
-    registry
-  });
-  return {
-    kind: "inline",
-    schema: body
-  };
-}
-__name(resolveSchemaRef, "resolveSchemaRef");
-
-// src/decorators/internal/zod-param-expand.ts
-var isZodObject = /* @__PURE__ */ __name((schema) => schema._zod.def.type === "object", "isZodObject");
-
-// src/decorators/internal/flatten-intersection.ts
-var intersectionArms = /* @__PURE__ */ __name((schema) => {
-  if (schema._zod.def.type !== "intersection") {
-    return null;
-  }
-  const def = schema._zod.def;
-  return {
-    left: def.left,
-    right: def.right
-  };
-}, "intersectionArms");
-var unionOptions = /* @__PURE__ */ __name((schema) => {
-  if (schema._zod.def.type !== "union") {
-    return null;
-  }
-  const def = schema._zod.def;
-  return def.options;
-}, "unionOptions");
-var collectObjectShapes = /* @__PURE__ */ __name((schema) => {
-  if (isZodObject(schema)) {
-    return {
-      shapes: [
-        schema.shape
-      ],
-      unionCrossed: false
-    };
-  }
-  const options = unionOptions(schema);
-  if (options !== null) {
-    const allShapes = [];
-    for (const variant of options) {
-      const variantResult = collectObjectShapes(variant);
-      if (variantResult === null) {
-        return null;
-      }
-      allShapes.push(...variantResult.shapes);
-    }
-    return {
-      shapes: allShapes,
-      unionCrossed: true
-    };
-  }
-  const arms = intersectionArms(schema);
-  if (arms === null) {
-    return null;
-  }
-  const left = collectObjectShapes(arms.left);
-  if (left === null) {
-    return null;
-  }
-  const right = collectObjectShapes(arms.right);
-  if (right === null) {
-    return null;
-  }
-  return {
-    shapes: [
-      ...left.shapes,
-      ...right.shapes
-    ],
-    unionCrossed: left.unionCrossed || right.unionCrossed
-  };
-}, "collectObjectShapes");
-var flattenObjectIntersection = /* @__PURE__ */ __name((schema, registry, decoratorName) => {
-  const collected = collectObjectShapes(schema);
-  if (collected === null) {
-    throw new ZodNestError(`${decoratorName} \`flatten: true\` requires every leaf of the schema to be a \`z.object({...})\` \u2014 intersections and unions of objects are supported, but primitives, tuples, transforms, and other non-object leaves are not. Drop \`flatten: true\` to emit the original schema with its composition intact.`);
-  }
-  const mergedShape = {};
-  for (const shape of collected.shapes) {
-    Object.assign(mergedShape, shape);
-  }
-  if (collected.unionCrossed) {
-    for (const key of Object.keys(mergedShape)) {
-      const value = mergedShape[key];
-      if (value !== void 0) {
-        mergedShape[key] = value.optional();
-      }
-    }
-  }
-  const merged = zod.z.object(mergedShape);
-  registerSchema(schema, registry);
-  for (const [child, childId] of discoverDependents(schema)) {
-    registry.register(child, childId);
-  }
-  const { schema: body } = toOpenApi(merged, {
-    io: "input",
-    registry
-  });
-  return body;
-}, "flattenObjectIntersection");
-var isZodSchema = /* @__PURE__ */ __name((value) => value instanceof zod.z.ZodType, "isZodSchema");
-
-// src/multipart/zod-multipart.decorator.ts
-var MULTIPART_CONTENT_TYPE = "multipart/form-data";
-var toSchema = /* @__PURE__ */ __name((body) => isZodSchema(body) ? body : zod.z.object({
-  ...body
-}), "toSchema");
-var toShape = /* @__PURE__ */ __name((body) => {
-  if (!isZodSchema(body)) {
-    return body;
-  }
-  return isZodObject(body) ? body.shape : void 0;
-}, "toShape");
-var partitionKeys = /* @__PURE__ */ __name((shape) => {
-  const fileKeys = [];
-  const textKeys = [];
-  for (const [key, schema] of Object.entries(shape ?? {})) {
-    if (isFileSchema(schema)) {
-      fileKeys.push(key);
-      continue;
-    }
-    textKeys.push(key);
-  }
-  return {
-    fileKeys,
-    textKeys
-  };
-}, "partitionKeys");
-var resolveBody = /* @__PURE__ */ __name((schema, options, registry) => {
-  if (options?.flatten === true) {
-    return flattenObjectIntersection(schema, registry, "@ZodMultipart");
-  }
-  const resolved = resolveSchemaRef(schema, {
-    ...options?.id !== void 0 ? {
-      id: options.id
-    } : {},
-    registry
-  });
-  return resolved.kind === "ref" ? resolved.ref : resolved.schema;
-}, "resolveBody");
-var createZodMultipart = /* @__PURE__ */ __name((defaultFilesIn) => {
-  return (body, options) => {
-    const registry = options?.registry ?? defaultRegistry;
-    const shape = toShape(body);
-    const metadata = {
-      shape,
-      ...partitionKeys(shape),
-      filesIn: options?.filesIn ?? defaultFilesIn
-    };
-    const schema = resolveBody(toSchema(body), options, registry);
-    return (target, propertyKey, descriptor) => {
-      const handler = descriptor.value;
-      if (typeof handler !== "function") {
-        throw new TypeError("[zod-nest] @ZodMultipart can only be applied to methods.");
-      }
-      Reflect.defineMetadata(ZOD_MULTIPART_METADATA_KEY, metadata, handler);
-      const swaggerDescriptor = descriptor;
-      swagger.ApiConsumes(MULTIPART_CONTENT_TYPE)(target, propertyKey, swaggerDescriptor);
-      swagger.ApiBody({
-        schema,
-        ...options?.description !== void 0 ? {
-          description: options.description
-        } : {},
-        required: options?.required ?? true
-      })(target, propertyKey, swaggerDescriptor);
-    };
-  };
-}, "createZodMultipart");
-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
-    });
-    this.zodError = zodError;
-    this.argMetadata = argMetadata;
-  }
-};
-
-// src/multipart/param-decorators.ts
-var readMetadata = /* @__PURE__ */ __name((ctx, decorator) => {
-  const metadata = Reflect.getMetadata(ZOD_MULTIPART_METADATA_KEY, ctx.getHandler());
-  if (!isMultipartMetadata(metadata)) {
-    throw new Error(`[zod-nest] ${decorator} requires @ZodMultipart on the same handler \u2014 it reads the declared shape from there.`);
-  }
-  return metadata;
-}, "readMetadata");
-var isMultipartMetadata = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && "shape" in value && "filesIn" in value, "isMultipartMetadata");
-var requireShape = /* @__PURE__ */ __name((metadata, decorator) => {
-  if (metadata.shape !== void 0) {
-    return metadata.shape;
-  }
-  throw new Error(`[zod-nest] ${decorator} needs a flat body shape, but @ZodMultipart was given a composite schema (an intersection or union). Validate it with @Body(new ZodValidationPipe(schema)) instead.`);
-}, "requireShape");
-var schemaFor = /* @__PURE__ */ __name((metadata, name, decorator) => {
-  const shape = requireShape(metadata, decorator);
-  const schema = shape[name];
-  if (schema === void 0) {
-    throw new Error(`[zod-nest] ${decorator}('${name}') has no matching property in the @ZodMultipart shape. Declared: ${Object.keys(shape).join(", ")}.`);
-  }
-  return schema;
-}, "schemaFor");
-var pick = /* @__PURE__ */ __name((shape, keys) => {
-  const wanted = new Set(keys);
-  const picked = {};
-  for (const [key, schema] of Object.entries(shape)) {
-    if (wanted.has(key)) {
-      picked[key] = schema;
-    }
-  }
-  return zod.z.object(picked);
-}, "pick");
-var validate = /* @__PURE__ */ __name(async (schema, value, argType) => {
-  const result = await schema.safeParseAsync(value);
-  if (result.success) {
-    return result.data;
-  }
-  throw new ZodValidationException(result.error, {
-    type: argType,
-    metatype: void 0,
-    data: void 0
-  });
-}, "validate");
-var assertFilesOnRequest = /* @__PURE__ */ __name((metadata, decorator) => {
-  if (metadata.filesIn === MultipartFilesIn.Request) {
-    return;
-  }
-  throw new Error(`[zod-nest] ${decorator} is unavailable under filesIn: 'body' \u2014 the parser puts files in the request body, so read them with @ZodMultipartBody().`);
-}, "assertFilesOnRequest");
-var resolveUploadedFile = /* @__PURE__ */ __name(async (name, ctx) => {
-  const metadata = readMetadata(ctx, "@ZodUploadedFile");
-  assertFilesOnRequest(metadata, "@ZodUploadedFile");
-  const request = ctx.switchToHttp().getRequest();
-  return validate(schemaFor(metadata, name, "@ZodUploadedFile"), request.file, "custom");
-}, "resolveUploadedFile");
-var resolveUploadedFiles = /* @__PURE__ */ __name(async (name, ctx) => {
-  const metadata = readMetadata(ctx, "@ZodUploadedFiles");
-  assertFilesOnRequest(metadata, "@ZodUploadedFiles");
-  const request = ctx.switchToHttp().getRequest();
-  const schema = name === void 0 ? pick(requireShape(metadata, "@ZodUploadedFiles"), metadata.fileKeys) : schemaFor(metadata, name, "@ZodUploadedFiles");
-  return validate(schema, request.files, "custom");
-}, "resolveUploadedFiles");
-var resolveMultipartBody = /* @__PURE__ */ __name(async (_data, ctx) => {
-  const metadata = readMetadata(ctx, "@ZodMultipartBody");
-  const shape = requireShape(metadata, "@ZodMultipartBody");
-  const request = ctx.switchToHttp().getRequest();
-  const keys = metadata.filesIn === MultipartFilesIn.Body ? Object.keys(shape) : metadata.textKeys;
-  return validate(pick(shape, keys), request.body, "body");
-}, "resolveMultipartBody");
-common.createParamDecorator(resolveUploadedFile);
-common.createParamDecorator(resolveUploadedFiles);
-var ZodMultipartBody = common.createParamDecorator(resolveMultipartBody);
+var chunk26E2XEJU_js = require('../chunk-26E2XEJU.js');
+require('../chunk-FKXVNCDD.js');
+require('../chunk-LXRBMFWD.js');
+var chunk4RXGLSPP_js = require('../chunk-4RXGLSPP.js');
 
 // src/fastify/index.ts
-var isFastifyMultipartFile = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && "type" in value && value.type === "file" && "mimetype" in value && "filename" in value && "toBuffer" in value && typeof value.toBuffer === "function", "isFastifyMultipartFile");
+var isFastifyMultipartFile = /* @__PURE__ */ chunk4RXGLSPP_js.__name((value) => value !== null && typeof value === "object" && "type" in value && value.type === "file" && "mimetype" in value && "filename" in value && "toBuffer" in value && typeof value.toBuffer === "function", "isFastifyMultipartFile");
 var accessors = {
-  mimeType: /* @__PURE__ */ __name((file) => file.mimetype, "mimeType"),
-  fileName: /* @__PURE__ */ __name((file) => file.filename, "fileName")
+  mimeType: /* @__PURE__ */ chunk4RXGLSPP_js.__name((file) => file.mimetype, "mimeType"),
+  fileName: /* @__PURE__ */ chunk4RXGLSPP_js.__name((file) => file.filename, "fileName")
 };
-var fastifyMultipartFile = /* @__PURE__ */ __name((options) => buildFileSchema({
+var fastifyMultipartFile = /* @__PURE__ */ chunk4RXGLSPP_js.__name((options) => chunk26E2XEJU_js.buildFileSchema({
   predicate: isFastifyMultipartFile,
   accessors,
   options
 }), "fastifyMultipartFile");
 var FastifyMultipartFileSchema = fastifyMultipartFile();
-var ZodMultipart = createZodMultipart(MultipartFilesIn.Body);
-
+var ZodMultipart = chunk26E2XEJU_js.createZodMultipart(chunk26E2XEJU_js.MultipartFilesIn.Body);
+
+Object.defineProperty(exports, "MULTIPART_CONTENT_TYPE", {
+  enumerable: true,
+  get: function () { return chunk26E2XEJU_js.MULTIPART_CONTENT_TYPE; }
+});
+Object.defineProperty(exports, "ZodMultipartBody", {
+  enumerable: true,
+  get: function () { return chunk26E2XEJU_js.ZodMultipartBody; }
+});
 exports.FastifyMultipartFileSchema = FastifyMultipartFileSchema;
-exports.MULTIPART_CONTENT_TYPE = MULTIPART_CONTENT_TYPE;
 exports.ZodMultipart = ZodMultipart;
-exports.ZodMultipartBody = ZodMultipartBody;
 exports.fastifyMultipartFile = fastifyMultipartFile;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map