nestjs-openapi 0.3.1 → 0.4.0

package/dist/shared/{nestjs-openapi.CU_zMKfF.mjs → nestjs-openapi.zDlSJGHz.mjs}

@@ -850,88 +850,89 @@ const resolveEnumMemberValue = (initializerText, nextValue) => {
   const numericValue = parseNumber(initializerText);
   return numericValue === void 0 ? { value: initializerText, nextValue } : { value: numericValue, nextValue: numericValue + 1 };
 };
-const extractEnumValues = (enumDecl) => enumDecl.getMembers().reduce(
-  (state, member) => {
-    const initializer = member.getInitializer();
-    if (!initializer) {
-      return {
-        values: [...state.values, state.nextValue],
-        nextValue: state.nextValue + 1
-      };
-    }
-    const stringLiteral = initializer.asKind?.(ts.SyntaxKind.StringLiteral);
-    if (stringLiteral) {
-      return {
-        values: [...state.values, stringLiteral.getLiteralValue()],
-        nextValue: state.nextValue
-      };
-    }
-    const numericLiteral = initializer.asKind?.(ts.SyntaxKind.NumericLiteral);
-    if (numericLiteral) {
-      const numericValue = numericLiteral.getLiteralValue();
-      return {
-        values: [...state.values, numericValue],
-        nextValue: numericValue + 1
-      };
-    }
-    const resolved = resolveEnumMemberValue(
-      initializer.getText(),
-      state.nextValue
-    );
-    return {
-      values: [...state.values, resolved.value],
-      nextValue: resolved.nextValue
-    };
-  },
-  {
-    values: [],
-    nextValue: 0
-  }
-).values;
-const resolveEnumFromIdentifier = (identifier) => {
-  const symbol = identifier.getSymbol();
-  if (!symbol) return void 0;
-  const declarations = symbol.getDeclarations();
-  if (!declarations || declarations.length === 0) return void 0;
-  const directEnumDecl = declarations.find(
-    (decl) => Node.isEnumDeclaration(decl)
-  );
-  if (directEnumDecl) {
-    return extractEnumValues(directEnumDecl);
+const appendEnumValue = (state, value, nextValue) => ({
+  values: [...state.values, value],
+  nextValue
+});
+const resolveEnumInitializerValue = (initializer, nextValue) => {
+  const stringLiteral = initializer.asKind?.(ts.SyntaxKind.StringLiteral);
+  if (stringLiteral) {
+    return { value: stringLiteral.getLiteralValue(), nextValue };
   }
-  const importedEnumDecl = declarations.filter(Node.isImportSpecifier).flatMap(
-    (decl) => decl.getSymbol()?.getAliasedSymbol()?.getDeclarations() ?? []
-  ).find((decl) => Node.isEnumDeclaration(decl));
-  return importedEnumDecl ? extractEnumValues(importedEnumDecl) : void 0;
+  const numericLiteral = initializer.asKind?.(ts.SyntaxKind.NumericLiteral);
+  if (numericLiteral) {
+    const value = numericLiteral.getLiteralValue();
+    return { value, nextValue: value + 1 };
+  }
+  return resolveEnumMemberValue(initializer.getText(), nextValue);
 };
+const resolveEnumMember = (state, member) => Option.fromNullable(member.getInitializer()).pipe(
+  Option.match({
+    onNone: () => appendEnumValue(state, state.nextValue, state.nextValue + 1),
+    onSome: (initializer) => {
+      const resolved = resolveEnumInitializerValue(
+        initializer,
+        state.nextValue
+      );
+      return appendEnumValue(state, resolved.value, resolved.nextValue);
+    }
+  })
+);
+const extractEnumValues = (enumDecl) => enumDecl.getMembers().reduce(resolveEnumMember, {
+  values: [],
+  nextValue: 0
+}).values;
+const findDirectEnumDeclaration = (declarations) => declarations.find(
+  (decl) => Node.isEnumDeclaration(decl)
+);
+const findImportedEnumSpecifierDeclaration = (declarations) => declarations.filter(Node.isImportSpecifier).flatMap(
+  (decl) => decl.getSymbol()?.getAliasedSymbol()?.getDeclarations() ?? []
+).find((decl) => Node.isEnumDeclaration(decl));
+const findEnumDeclaration = (declarations) => findDirectEnumDeclaration(declarations) ?? findImportedEnumSpecifierDeclaration(declarations);
+const resolveEnumFromIdentifier = (identifier) => Option.fromNullable(identifier.getSymbol()).pipe(
+  Option.map((symbol) => symbol.getDeclarations()),
+  Option.filter((declarations) => declarations.length > 0),
+  Option.flatMap(
+    (declarations) => Option.fromNullable(findEnumDeclaration(declarations))
+  ),
+  Option.map(extractEnumValues),
+  Option.getOrUndefined
+);
 const resolveEnumFromDecorator = (decorator) => {
   const firstArg = decorator.getCallExpression()?.getArguments()?.[0];
   return firstArg && Node.isIdentifier(firstArg) ? resolveEnumFromIdentifier(firstArg) : void 0;
 };
 const getPropertyInitializer = (objLit, name) => objLit.getProperty(name)?.asKind?.(ts.SyntaxKind.PropertyAssignment)?.getInitializer();
 const getStringProp = (objLit, name) => getPropertyInitializer(objLit, name)?.asKind?.(ts.SyntaxKind.StringLiteral)?.getLiteralValue();
+const readNumericInitializer = (initializer) => {
+  const numericLiteral = initializer.asKind?.(ts.SyntaxKind.NumericLiteral);
+  if (numericLiteral) {
+    return numericLiteral.getLiteralValue();
+  }
+  return Node.isPrefixUnaryExpression(initializer) ? parseNumber(initializer.getText()) : void 0;
+};
 const getNumericProp = (objLit, name) => {
   const initializer = getPropertyInitializer(objLit, name);
-  const numericLiteral = initializer?.asKind?.(ts.SyntaxKind.NumericLiteral);
-  if (numericLiteral) return numericLiteral.getLiteralValue();
-  return initializer && Node.isPrefixUnaryExpression(initializer) ? parseNumber(initializer.getText()) : void 0;
+  return initializer ? readNumericInitializer(initializer) : void 0;
 };
 const getBooleanProp = (objLit, name) => {
   const text = getPropertyInitializer(objLit, name)?.getText();
   return text === "true" ? true : text === "false" ? false : void 0;
 };
-const getPrimitiveValue = (objLit, name) => {
-  const initializer = getPropertyInitializer(objLit, name);
-  if (!initializer) return void 0;
+const PRIMITIVE_LITERAL_VALUES = {
+  true: true,
+  false: false,
+  null: null
+};
+const readPrimitiveInitializer = (initializer) => {
   if (Node.isStringLiteral(initializer) || Node.isNumericLiteral(initializer)) {
     return initializer.getLiteralValue();
   }
-  const primitiveLiterals = {
-    true: true,
-    false: false,
-    null: null
-  };
-  return primitiveLiterals[initializer.getText()];
+  return PRIMITIVE_LITERAL_VALUES[initializer.getText()];
+};
+const getPrimitiveValue = (objLit, name) => {
+  const initializer = getPropertyInitializer(objLit, name);
+  return initializer ? readPrimitiveInitializer(initializer) : void 0;
 };
 const API_STRING_KEYS = ["description", "title", "format", "pattern"];
 const API_NUMBER_KEYS = [
@@ -954,65 +955,94 @@ const API_BOOLEAN_KEYS = [
   "isArray"
 ];
 const API_PRIMITIVE_KEYS = ["example", "default"];
+const API_TYPE_IDENTIFIERS = {
+  String: { type: "string" },
+  Number: { type: "number" },
+  Boolean: { type: "boolean" },
+  Object: { type: "object" },
+  Array: { type: "array" },
+  Date: { type: "string", format: "date-time" }
+};
 const buildConstraintsFromKeys = (objectLiteral, keys, read) => Object.fromEntries(
   keys.flatMap((key) => {
     const value = read(objectLiteral, key);
     return value === void 0 ? [] : [[key, value]];
   })
 );
-const extractApiPropertyEnum = (objLit) => {
-  const initializer = getPropertyInitializer(objLit, "enum");
-  if (!initializer) return void 0;
+const readEnumArrayElement = (element) => {
+  if (Node.isStringLiteral(element) || Node.isNumericLiteral(element)) {
+    return element.getLiteralValue();
+  }
+  return Node.isPrefixUnaryExpression(element) ? parseNumber(element.getText()) : void 0;
+};
+const readEnumArrayLiteral = (initializer) => {
   const arrayLiteral = initializer.asKind?.(
     ts.SyntaxKind.ArrayLiteralExpression
   );
-  if (arrayLiteral) {
-    const values = arrayLiteral.getElements().reduce((acc, element) => {
-      if (Node.isStringLiteral(element)) {
-        return [...acc, element.getLiteralValue()];
-      }
-      if (Node.isNumericLiteral(element)) {
-        return [...acc, element.getLiteralValue()];
-      }
-      if (Node.isPrefixUnaryExpression(element)) {
-        const numericValue = parseNumber(element.getText());
-        return numericValue === void 0 ? acc : [...acc, numericValue];
-      }
-      return acc;
-    }, []);
-    return values.length > 0 ? values : void 0;
+  if (!arrayLiteral) {
+    return void 0;
   }
-  return Node.isIdentifier(initializer) ? resolveEnumFromIdentifier(initializer) : void 0;
+  const values = arrayLiteral.getElements().map(readEnumArrayElement).filter((value) => value !== void 0);
+  return values.length > 0 ? values : void 0;
 };
-const extractApiPropertyConstraints = (decorator) => {
-  const objectLiteral = decorator.getCallExpression()?.getArguments()[0]?.asKind?.(ts.SyntaxKind.ObjectLiteralExpression);
-  if (!objectLiteral) return void 0;
-  const enumValues = extractApiPropertyEnum(objectLiteral);
-  const result = {
-    ...enumValues ? { enum: enumValues } : {},
-    ...buildConstraintsFromKeys(
-      objectLiteral,
-      API_STRING_KEYS,
-      (obj, key) => getStringProp(obj, key)
-    ),
-    ...buildConstraintsFromKeys(
-      objectLiteral,
-      API_NUMBER_KEYS,
-      (obj, key) => getNumericProp(obj, key)
-    ),
-    ...buildConstraintsFromKeys(
-      objectLiteral,
-      API_BOOLEAN_KEYS,
-      (obj, key) => getBooleanProp(obj, key)
-    ),
-    ...buildConstraintsFromKeys(
-      objectLiteral,
-      API_PRIMITIVE_KEYS,
-      (obj, key) => getPrimitiveValue(obj, key)
-    )
-  };
-  return Object.keys(result).length > 0 ? result : void 0;
+const readEnumIdentifier = (initializer) => Node.isIdentifier(initializer) ? resolveEnumFromIdentifier(initializer) : void 0;
+const extractApiPropertyEnum = (objLit) => {
+  const initializer = getPropertyInitializer(objLit, "enum");
+  if (!initializer) {
+    return void 0;
+  }
+  return readEnumArrayLiteral(initializer) ?? readEnumIdentifier(initializer);
 };
+const readApiTypeIdentifier = (initializer) => Node.isIdentifier(initializer) ? API_TYPE_IDENTIFIERS[initializer.getText()] : void 0;
+const readApiTypeArrayElement = (initializer) => {
+  const firstArrayElement = initializer.asKind?.(ts.SyntaxKind.ArrayLiteralExpression)?.getElements()[0];
+  if (!firstArrayElement || !Node.isIdentifier(firstArrayElement)) {
+    return void 0;
+  }
+  const itemType = API_TYPE_IDENTIFIERS[firstArrayElement.getText()];
+  return itemType ? { ...itemType, isArray: true } : void 0;
+};
+const extractApiPropertyType = (objLit) => {
+  const initializer = getPropertyInitializer(objLit, "type");
+  if (!initializer) {
+    return void 0;
+  }
+  return readApiTypeIdentifier(initializer) ?? readApiTypeArrayElement(initializer);
+};
+const extractApiPropertyConstraints = (decorator) => Option.fromNullable(
+  decorator.getCallExpression()?.getArguments()[0]?.asKind?.(ts.SyntaxKind.ObjectLiteralExpression)
+).pipe(
+  Option.map((objectLiteral) => {
+    const enumValues = extractApiPropertyEnum(objectLiteral);
+    const typeConstraints = extractApiPropertyType(objectLiteral);
+    return {
+      ...enumValues ? { enum: enumValues } : {},
+      ...typeConstraints ?? {},
+      ...buildConstraintsFromKeys(
+        objectLiteral,
+        API_STRING_KEYS,
+        (obj, key) => getStringProp(obj, key)
+      ),
+      ...buildConstraintsFromKeys(
+        objectLiteral,
+        API_NUMBER_KEYS,
+        (obj, key) => getNumericProp(obj, key)
+      ),
+      ...buildConstraintsFromKeys(
+        objectLiteral,
+        API_BOOLEAN_KEYS,
+        (obj, key) => getBooleanProp(obj, key)
+      ),
+      ...buildConstraintsFromKeys(
+        objectLiteral,
+        API_PRIMITIVE_KEYS,
+        (obj, key) => getPrimitiveValue(obj, key)
+      )
+    };
+  }),
+  Option.filter((result) => Object.keys(result).length > 0),
+  Option.getOrUndefined
+);
 const compactConstraints = (constraints) => Object.fromEntries(
   Object.entries(constraints).filter(([, value]) => value !== void 0)
 );
@@ -1099,21 +1129,93 @@ const collectHiddenProperties = (propertyConstraints) => new Set(
     ([propertyName, constraints]) => constraints.hidden ? [propertyName] : []
   )
 );
+const cleanPropertyConstraints = (constraints) => {
+  const {
+    hidden: _hidden,
+    isArray: _isArray,
+    ...cleanConstraints
+  } = constraints;
+  return cleanConstraints;
+};
+const hasNullableArraySchema = (schema) => schema.anyOf?.some((member) => member.type === "array") === true;
+const isItemTypeOverride = (typeOverride) => typeof typeOverride === "string" && typeOverride !== "array";
+const shouldApplyNullableArrayItemConstraints = (propertySchema, isArray, typeOverride, enumValues) => hasNullableArraySchema(propertySchema) && (isArray === true && isItemTypeOverride(typeOverride) || enumValues !== void 0);
+const applyNullableArrayItemConstraints = (propertySchema, isArray, typeOverride, enumValues, restConstraints) => {
+  const hasItemTypeOverride = isArray === true && isItemTypeOverride(typeOverride);
+  const itemConstraints = {
+    ...hasItemTypeOverride ? { type: typeOverride } : {},
+    ...enumValues ? { enum: enumValues } : {}
+  };
+  return {
+    ...propertySchema,
+    ...restConstraints,
+    anyOf: propertySchema.anyOf?.map(
+      (member) => member.type === "array" ? {
+        ...member,
+        items: {
+          ...hasItemTypeOverride ? {} : member.items,
+          ...itemConstraints
+        }
+      } : member
+    )
+  };
+};
+const shouldApplyArrayItemConstraints = (propertySchema, typeOverride, enumValues) => propertySchema.type === "array" && (isItemTypeOverride(typeOverride) || enumValues !== void 0);
+const applyArrayItemConstraints = (propertySchema, typeOverride, enumValues, restConstraints) => {
+  const hasItemTypeOverride = isItemTypeOverride(typeOverride);
+  return {
+    ...propertySchema,
+    ...restConstraints,
+    items: {
+      ...hasItemTypeOverride ? {} : propertySchema.items,
+      ...hasItemTypeOverride ? { type: typeOverride } : {},
+      ...enumValues ? { enum: enumValues } : {}
+    }
+  };
+};
+const applyDirectPropertyConstraints = (propertySchema, typeOverride, enumValues, restConstraints) => ({
+  ...propertySchema,
+  ...typeOverride === void 0 ? {} : { type: typeOverride },
+  ...restConstraints,
+  ...enumValues === void 0 ? {} : { enum: enumValues }
+});
 const applyPropertyConstraintsToSchema = (propertySchema, constraints) => Option.fromNullable(constraints).pipe(
   Option.map((propertyConstraints) => {
-    const { hidden: _hidden, ...cleanConstraints } = propertyConstraints;
-    if (propertySchema.type === "array" && cleanConstraints.enum) {
-      const { enum: enumValues, ...restConstraints } = cleanConstraints;
-      return {
-        ...propertySchema,
-        ...restConstraints,
-        items: { ...propertySchema.items, enum: enumValues }
-      };
+    const isArray = propertyConstraints.isArray;
+    const {
+      type: typeOverride,
+      enum: enumValues,
+      ...restConstraints
+    } = cleanPropertyConstraints(propertyConstraints);
+    if (shouldApplyNullableArrayItemConstraints(
+      propertySchema,
+      isArray,
+      typeOverride,
+      enumValues
+    )) {
+      return applyNullableArrayItemConstraints(
+        propertySchema,
+        isArray,
+        typeOverride,
+        enumValues,
+        restConstraints
+      );
     }
-    return {
-      ...propertySchema,
-      ...cleanConstraints
-    };
+    return shouldApplyArrayItemConstraints(
+      propertySchema,
+      typeOverride,
+      enumValues
+    ) ? applyArrayItemConstraints(
+      propertySchema,
+      typeOverride,
+      enumValues,
+      restConstraints
+    ) : applyDirectPropertyConstraints(
+      propertySchema,
+      typeOverride,
+      enumValues,
+      restConstraints
+    );
   }),
   Option.getOrElse(() => propertySchema)
 );
@@ -1179,8 +1281,8 @@ const mergeValidationConstraints = (schemas, classConstraints, classRequired) =>
   );
   return { definitions };
 };
-const extractClassValidationInfoEffect = Effect.fn(
-  "ValidationMapper.extractClassValidationInfo"
+const serviceExtractClassValidationInfo = Effect.fn(
+  "ValidationMapperService.extractClassValidationInfo"
 )(function* (classDecl) {
   const className = classDecl.getName() ?? "<anonymous>";
   const filePath = classDecl.getSourceFile().getFilePath();
@@ -1200,8 +1302,8 @@ const extractClassValidationInfoEffect = Effect.fn(
   );
   return info;
 });
-const mergeValidationConstraintsEffect = Effect.fn(
-  "ValidationMapper.mergeValidationConstraints"
+const serviceMergeValidationConstraints = Effect.fn(
+  "ValidationMapperService.mergeValidationConstraints"
 )(function* (schemas, classConstraints, classRequired) {
   const merged = mergeValidationConstraints(
     schemas,
@@ -1223,6 +1325,18 @@ const mergeValidationConstraintsEffect = Effect.fn(
   yield* Effect.annotateCurrentSpan("classRequiredCount", classRequired.size);
   return merged;
 });
+class ValidationMapperService extends Effect.Service()(
+  "ValidationMapperService",
+  {
+    effect: Effect.succeed({
+      extractClassValidationInfo: serviceExtractClassValidationInfo,
+      mergeValidationConstraints: serviceMergeValidationConstraints
+    })
+  }
+) {
+}
+const extractClassValidationInfoEffect = serviceExtractClassValidationInfo;
+const mergeValidationConstraintsEffect = serviceMergeValidationConstraints;
 
 const methodInfoCache = /* @__PURE__ */ new WeakMap();
 const returnTypeInfoCache = /* @__PURE__ */ new WeakMap();
@@ -2021,152 +2135,200 @@ class MethodExtractionService extends Effect.Service()(
 ) {
 }
 
-const buildSecurityRequirements = (requirements) => {
-  if (requirements.length === 0) return void 0;
-  const combined = {};
-  for (const req of requirements) {
-    combined[req.schemeName] = [...req.scopes];
-  }
-  return [combined];
-};
+const buildSecurityRequirements = (requirements) => requirements.length === 0 ? void 0 : [
+  Object.fromEntries(
+    requirements.map((req) => [req.schemeName, [...req.scopes]])
+  )
+];
 const getRequestContentTypes = (methodInfo) => methodInfo.consumes.length > 0 ? methodInfo.consumes : ["application/json"];
 const getResponseContentTypes = (methodInfo) => methodInfo.produces.length > 0 ? methodInfo.produces : ["application/json"];
 const buildContentObject = (contentTypes, schema) => Object.fromEntries(contentTypes.map((type) => [type, { schema }]));
-const parseInlineObjectType = (typeStr) => {
-  const trimmed = typeStr.trim();
-  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
-    return null;
-  }
-  const content = trimmed.slice(1, -1).trim();
-  if (!content) {
-    return { properties: {}, required: [] };
+const INLINE_OBJECT_BOUNDARY_PATTERN = /^\s*\{[\s\S]*\}\s*$/;
+const INLINE_OBJECT_SEPARATORS = /* @__PURE__ */ new Set([";", ","]);
+const BRACE_DEPTH_CHANGE = {
+  "{": 1,
+  "}": -1
+};
+const pushInlinePart = (parts, part) => {
+  const trimmed = part.trim();
+  if (trimmed) {
+    parts.push(trimmed);
   }
-  const properties = {};
-  const required = [];
+};
+const splitInlineObjectParts = (content) => {
   const parts = [];
   let current = "";
   let braceDepth = 0;
   for (const char of content) {
-    if (char === "{") {
-      braceDepth++;
-      current += char;
-    } else if (char === "}") {
-      braceDepth--;
-      current += char;
-    } else if ((char === ";" || char === ",") && braceDepth === 0) {
-      if (current.trim()) {
-        parts.push(current.trim());
-      }
+    if (INLINE_OBJECT_SEPARATORS.has(char) && braceDepth === 0) {
+      pushInlinePart(parts, current);
       current = "";
-    } else {
-      current += char;
+      continue;
     }
+    current += char;
+    braceDepth += BRACE_DEPTH_CHANGE[char] ?? 0;
   }
-  if (current.trim()) {
-    parts.push(current.trim());
-  }
-  for (const part of parts) {
-    const colonIndex = part.indexOf(":");
-    if (colonIndex === -1) continue;
-    let propName = part.slice(0, colonIndex).trim();
-    const propType = part.slice(colonIndex + 1).trim();
-    const isOptional = propName.endsWith("?");
-    if (isOptional) {
-      propName = propName.slice(0, -1).trim();
-    }
-    if (!propName || !propType) continue;
-    properties[propName] = tsTypeToOpenApiSchema(propType);
-    if (!isOptional) {
-      required.push(propName);
-    }
+  pushInlinePart(parts, current);
+  return parts;
+};
+const parseInlineProperty = (part) => {
+  const colonIndex = part.indexOf(":");
+  const rawName = colonIndex === -1 ? "" : part.slice(0, colonIndex).trim();
+  const type = colonIndex === -1 ? "" : part.slice(colonIndex + 1).trim();
+  const isOptional = rawName.endsWith("?");
+  const name = (isOptional ? rawName.slice(0, -1) : rawName).trim();
+  return name && type ? { name, type, isOptional } : void 0;
+};
+const parseInlineObjectType = (typeStr) => {
+  const trimmed = typeStr.trim();
+  if (!INLINE_OBJECT_BOUNDARY_PATTERN.test(trimmed)) {
+    return null;
+  }
+  const content = trimmed.slice(1, -1).trim();
+  const properties = splitInlineObjectParts(content).map(parseInlineProperty).filter((property) => property !== void 0);
+  return {
+    properties: Object.fromEntries(
+      properties.map((property) => [
+        property.name,
+        tsTypeToOpenApiSchema(property.type)
+      ])
+    ),
+    required: properties.flatMap(
+      (property) => property.isOptional ? [] : [property.name]
+    )
+  };
+};
+const OBJECT_SCHEMA = { type: "object" };
+const PRIMITIVE_TYPE_SCHEMAS = {
+  string: { type: "string" },
+  number: { type: "number" },
+  boolean: { type: "boolean" },
+  date: { type: "string", format: "date-time" },
+  void: OBJECT_SCHEMA,
+  undefined: OBJECT_SCHEMA,
+  never: OBJECT_SCHEMA,
+  null: OBJECT_SCHEMA,
+  unknown: OBJECT_SCHEMA,
+  any: OBJECT_SCHEMA,
+  object: OBJECT_SCHEMA
+};
+const BINARY_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "StreamableFile",
+  "Buffer",
+  "Readable",
+  "ReadableStream"
+]);
+const RECORD_TYPE_PATTERN = /^Record<string,\s*(.+)>$/;
+const TYPE_REFERENCE_PATTERN = /^[a-zA-Z_$][a-zA-Z0-9_$]*(<[^>]+>)?$/;
+const buildInlineObjectSchema = (parsed) => ({
+  type: "object",
+  properties: parsed.properties,
+  ...parsed.required.length > 0 ? { required: parsed.required } : {}
+});
+const withNullable = (schema) => schema.$ref ? { allOf: [{ $ref: schema.$ref }], nullable: true } : { ...schema, nullable: true };
+const resolveInlineObjectSchema = (tsType) => Option.fromNullable(parseInlineObjectType(tsType)).pipe(
+  Option.map(buildInlineObjectSchema),
+  Option.getOrUndefined
+);
+const parseUnionType = (tsType) => {
+  if (!tsType.includes(" | ")) {
+    return void 0;
+  }
+  const members = tsType.split(" | ").map((member) => member.trim());
+  return {
+    hasNull: members.includes("null"),
+    types: members.filter(
+      (member) => member !== "undefined" && member !== "null"
+    )
+  };
+};
+const buildUnionSchema = (types) => {
+  if (types.length === 0) {
+    return { type: "object" };
+  }
+  if (types.length === 1) {
+    return tsTypeToOpenApiSchema(types[0]);
   }
-  return { properties, required };
+  return { oneOf: types.map((type) => tsTypeToOpenApiSchema(type)) };
 };
+const resolveUnionSchema = (tsType) => Option.fromNullable(parseUnionType(tsType)).pipe(
+  Option.map(({ types, hasNull }) => {
+    const schema = buildUnionSchema(types);
+    return hasNull && types.length > 0 ? withNullable(schema) : schema;
+  }),
+  Option.getOrUndefined
+);
+const resolvePrimitiveSchema = (tsType) => Option.fromNullable(PRIMITIVE_TYPE_SCHEMAS[tsType.toLowerCase()]).pipe(
+  Option.map((schema) => ({ ...schema })),
+  Option.getOrUndefined
+);
+const resolveBinarySchema = (tsType) => BINARY_TYPE_NAMES.has(tsType) ? { type: "string", format: "binary" } : void 0;
+const resolveArraySchema = (tsType) => tsType.endsWith("[]") ? {
+  type: "array",
+  items: tsTypeToOpenApiSchema(tsType.slice(0, -2))
+} : void 0;
+const resolveRecordSchema = (tsType) => RECORD_TYPE_PATTERN.test(tsType) ? { type: "object" } : void 0;
+const resolveReferenceSchema = (tsType) => TYPE_REFERENCE_PATTERN.test(tsType) ? { $ref: `#/components/schemas/${tsType}` } : void 0;
+const TYPE_SCHEMA_RESOLVERS = [
+  resolveInlineObjectSchema,
+  resolveUnionSchema,
+  resolvePrimitiveSchema,
+  resolveBinarySchema,
+  resolveArraySchema,
+  resolveRecordSchema,
+  resolveReferenceSchema
+];
 const tsTypeToOpenApiSchema = (tsType) => {
   const trimmed = tsType.trim();
-  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
-    const parsed = parseInlineObjectType(trimmed);
-    if (parsed) {
-      const schema = {
-        type: "object",
-        properties: parsed.properties
-      };
-      if (parsed.required.length > 0) {
-        return { ...schema, required: parsed.required };
-      }
+  for (const resolver of TYPE_SCHEMA_RESOLVERS) {
+    const schema = resolver(trimmed);
+    if (schema !== void 0) {
       return schema;
     }
   }
-  if (trimmed.includes(" | ")) {
-    const allMembers = trimmed.split(" | ").map((t) => t.trim());
-    const hasNull = allMembers.includes("null");
-    const types = allMembers.filter((t) => t !== "undefined" && t !== "null");
-    if (types.length === 0) return { type: "object" };
-    const schema = types.length === 1 ? tsTypeToOpenApiSchema(types[0]) : { oneOf: types.map((type) => tsTypeToOpenApiSchema(type)) };
-    if (!hasNull) return schema;
-    if (schema.$ref) {
-      return { allOf: [{ $ref: schema.$ref }], nullable: true };
-    }
-    return { ...schema, nullable: true };
-  }
-  switch (trimmed.toLowerCase()) {
-    case "string":
-      return { type: "string" };
-    case "number":
-      return { type: "number" };
-    case "boolean":
-      return { type: "boolean" };
-    case "date":
-      return { type: "string", format: "date-time" };
-    case "void":
-    case "undefined":
-    case "never":
-    case "null":
-      return { type: "object" };
-    case "unknown":
-    case "any":
-    case "object":
-      return { type: "object" };
-  }
-  if (trimmed === "StreamableFile" || trimmed === "Buffer" || trimmed === "Readable" || trimmed === "ReadableStream") {
-    return { type: "string", format: "binary" };
-  }
-  if (trimmed.endsWith("[]")) {
-    const itemType = trimmed.slice(0, -2);
-    return {
-      type: "array",
-      items: tsTypeToOpenApiSchema(itemType)
-    };
-  }
-  const recordMatch = trimmed.match(/^Record<string,\s*(.+)>$/);
-  if (recordMatch) {
-    return {
-      type: "object"
-    };
-  }
-  if (trimmed.match(/^[a-zA-Z_$][a-zA-Z0-9_$]*(<[^>]+>)?$/)) {
-    return { $ref: `#/components/schemas/${trimmed}` };
-  }
   return { type: "object" };
 };
 const isNodeModulesPath = (filePath) => filePath.includes("/node_modules/") || filePath.includes("\\node_modules\\");
 const shouldFallbackExternalReturnRef = (returnType) => Option.isSome(returnType.filePath) && isNodeModulesPath(returnType.filePath.value);
 const responseSchemaOrObjectFallback = (schema) => schema.$ref ? { type: "object" } : schema;
-const getParameterLocation = (location) => {
-  switch (location) {
-    case "path":
-      return "path";
-    case "header":
-      return "header";
-    case "cookie":
-      return "cookie";
-    default:
-      return "query";
+const PARAMETER_LOCATION_MAP = {
+  path: "path",
+  query: "query",
+  header: "header",
+  cookie: "cookie",
+  body: "query"
+};
+const getParameterLocation = (location) => PARAMETER_LOCATION_MAP[location];
+const applyParameterConstraints = (baseSchema, constraints) => {
+  const {
+    isArray,
+    type: typeOverride,
+    enum: enumValues,
+    ...restConstraints
+  } = constraints;
+  const shouldApplyItemConstraints = (isArray === true || baseSchema.type === "array") && typeof typeOverride === "string" && typeOverride !== "array";
+  if (shouldApplyItemConstraints || baseSchema.type === "array" && enumValues) {
+    return {
+      ...baseSchema,
+      ...restConstraints,
+      type: "array",
+      items: {
+        ...shouldApplyItemConstraints ? {} : baseSchema.items,
+        ...shouldApplyItemConstraints ? { type: typeOverride } : {},
+        ...enumValues ? { enum: enumValues } : {}
+      }
+    };
   }
+  return {
+    ...baseSchema,
+    ...restConstraints,
+    ...typeOverride === void 0 ? {} : { type: typeOverride },
+    ...enumValues === void 0 ? {} : { enum: enumValues }
+  };
 };
 const transformParameter = (param) => {
   const baseSchema = tsTypeToOpenApiSchema(param.tsType);
-  const schema = param.constraints ? { ...baseSchema, ...param.constraints } : baseSchema;
+  const schema = param.constraints ? applyParameterConstraints(baseSchema, param.constraints) : baseSchema;
   return {
     name: param.name,
     in: getParameterLocation(param.location),
@@ -2179,21 +2341,7 @@ const isInlineOptionalBodyType = (tsType) => {
   const parsed = parseInlineObjectType(tsType);
   return parsed !== null && parsed.required.length === 0;
 };
-const buildResponseSchema = (returnType) => {
-  const shouldFallback = Option.isNone(returnType.container) && shouldFallbackExternalReturnRef(returnType);
-  if (Option.isSome(returnType.container) && returnType.container.value === "array") {
-    if (Option.isSome(returnType.inline)) {
-      return {
-        type: "array",
-        items: tsTypeToOpenApiSchema(returnType.inline.value)
-      };
-    }
-    const itemSchema = Option.isSome(returnType.type) ? tsTypeToOpenApiSchema(returnType.type.value) : { type: "object" };
-    return {
-      type: "array",
-      items: shouldFallback ? responseSchemaOrObjectFallback(itemSchema) : itemSchema
-    };
-  }
+const buildScalarReturnSchema = (returnType, shouldFallback) => {
   if (Option.isSome(returnType.type)) {
     const schema = tsTypeToOpenApiSchema(returnType.type.value);
     return shouldFallback ? responseSchemaOrObjectFallback(schema) : schema;
@@ -2203,81 +2351,77 @@ const buildResponseSchema = (returnType) => {
   }
   return { type: "string" };
 };
-const buildResponseSchemaFromMetadata = (response) => {
-  if (Option.isNone(response.type)) return void 0;
-  const typeName = response.type.value;
-  if (response.isArray) {
-    return {
-      type: "array",
-      items: tsTypeToOpenApiSchema(typeName)
-    };
-  }
-  return tsTypeToOpenApiSchema(typeName);
-};
-const getDefaultSuccessCode = (methodInfo) => {
-  if (Option.isSome(methodInfo.httpCode)) {
-    return methodInfo.httpCode.value;
-  }
-  return methodInfo.httpMethod === "POST" ? 201 : 200;
-};
-const hasMeaningfulReturnType = (returnType) => {
-  if (Option.isSome(returnType.type)) {
-    const typeName = returnType.type.value.toLowerCase();
-    if (["void", "undefined", "never"].includes(typeName)) {
-      return false;
-    }
-    return true;
-  }
-  return Option.isSome(returnType.inline);
+const buildArrayReturnSchema = (returnType) => ({
+  type: "array",
+  items: Option.isSome(returnType.inline) ? tsTypeToOpenApiSchema(returnType.inline.value) : Option.match(returnType.type, {
+    onNone: () => ({ type: "object" }),
+    onSome: (typeName) => tsTypeToOpenApiSchema(typeName)
+  })
+});
+const buildResponseSchema = (returnType) => {
+  const shouldFallback = Option.isNone(returnType.container) && shouldFallbackExternalReturnRef(returnType);
+  return returnType.container.pipe(
+    Option.match({
+      onNone: () => buildScalarReturnSchema(returnType, shouldFallback),
+      onSome: () => buildArrayReturnSchema(returnType)
+    })
+  );
 };
+const buildResponseSchemaFromMetadata = (response) => response.type.pipe(
+  Option.map((typeName) => {
+    const schema = tsTypeToOpenApiSchema(typeName);
+    return response.isArray ? { type: "array", items: schema } : schema;
+  }),
+  Option.getOrUndefined
+);
+const getDefaultSuccessCode = (methodInfo) => Option.getOrElse(
+  methodInfo.httpCode,
+  () => methodInfo.httpMethod === "POST" ? 201 : 200
+);
+const hasMeaningfulReturnType = (returnType) => returnType.type.pipe(
+  Option.match({
+    onNone: () => Option.isSome(returnType.inline),
+    onSome: (typeName) => !["void", "undefined", "never"].includes(typeName.toLowerCase())
+  })
+);
 const isSuccessWithContent = (statusCode) => statusCode >= 200 && statusCode < 300 && statusCode !== 204;
 const buildResponseEntry = (response, returnType, hasReturnType, contentTypes) => {
   const schema = buildResponseSchemaFromMetadata(response) ?? (hasReturnType && isSuccessWithContent(response.statusCode) ? buildResponseSchema(returnType) : void 0);
   const description = Option.getOrElse(response.description, () => "");
-  if (!schema) return { description };
-  return { description, content: buildContentObject(contentTypes, schema) };
+  return schema ? { description, content: buildContentObject(contentTypes, schema) } : { description };
 };
+const buildDefaultResponseEntry = (returnType, hasReturnType, contentTypes) => ({
+  description: "",
+  ...hasReturnType ? {
+    content: buildContentObject(
+      contentTypes,
+      buildResponseSchema(returnType)
+    )
+  } : {}
+});
+const hasDeclaredSuccessResponse = (responses) => responses.some(
+  (response) => response.statusCode >= 200 && response.statusCode < 300
+);
 const buildResponses = (methodInfo) => {
   const contentTypes = getResponseContentTypes(methodInfo);
   const returnType = methodInfo.returnType;
   const hasReturnType = hasMeaningfulReturnType(returnType);
   const statusCode = getDefaultSuccessCode(methodInfo);
-  if (methodInfo.responses.length === 0) {
-    if (!hasReturnType) {
-      return { [statusCode.toString()]: { description: "" } };
-    }
-    return {
-      [statusCode.toString()]: {
-        description: "",
-        content: buildContentObject(
-          contentTypes,
-          buildResponseSchema(returnType)
-        )
-      }
-    };
-  }
-  const result = {};
-  const hasSuccessResponse = methodInfo.responses.some(
-    (r) => r.statusCode >= 200 && r.statusCode < 300
+  const defaultSuccessEntry = buildDefaultResponseEntry(
+    returnType,
+    hasReturnType,
+    contentTypes
   );
-  if (!hasSuccessResponse && hasReturnType) {
-    result[statusCode.toString()] = {
-      description: "",
-      content: buildContentObject(
-        contentTypes,
-        buildResponseSchema(returnType)
-      )
-    };
-  }
-  for (const response of methodInfo.responses) {
-    result[response.statusCode.toString()] = buildResponseEntry(
-      response,
-      returnType,
-      hasReturnType,
-      contentTypes
-    );
-  }
-  return result;
+  const declaredResponses = Object.fromEntries(
+    methodInfo.responses.map((response) => [
+      response.statusCode.toString(),
+      buildResponseEntry(response, returnType, hasReturnType, contentTypes)
+    ])
+  );
+  return {
+    ...methodInfo.responses.length === 0 || !hasDeclaredSuccessResponse(methodInfo.responses) && hasReturnType ? { [statusCode.toString()]: defaultSuccessEntry } : {},
+    ...declaredResponses
+  };
 };
 const buildOpenApiPath = (path) => path.replace(/:([^/]+)/g, "{$1}") || "/";
 const transformMethodInternal = (methodInfo) => {
@@ -2323,33 +2467,49 @@ const transformMethodInternal = (methodInfo) => {
   };
 };
 const transformMethod = (methodInfo) => transformMethodInternal(methodInfo);
-const transformMethodEffect = Effect.fn("Transformer.transformMethod")(
-  function* (methodInfo) {
-    return yield* Effect.succeed(transformMethodInternal(methodInfo));
-  }
-);
-const transformMethods = (methodInfos) => methodInfos.reduce((acc, methodInfo) => {
-  const endpoint = transformMethodInternal(methodInfo);
+const mergeOpenApiPaths = (endpoints) => endpoints.reduce((acc, endpoint) => {
   for (const path in endpoint) {
-    if (!acc[path]) acc[path] = {};
-    Object.assign(acc[path], endpoint[path]);
+    acc[path] = { ...acc[path] ?? {}, ...endpoint[path] };
   }
   return acc;
 }, {});
-const transformMethodsEffect = Effect.fn(
-  "Transformer.transformMethods"
+const transformMethods = (methodInfos) => mergeOpenApiPaths(methodInfos.map(transformMethodInternal));
+const serviceTransformMethod = Effect.fn("TransformerService.transformMethod")(
+  function* (methodInfo) {
+    const paths = yield* Effect.sync(() => transformMethodInternal(methodInfo));
+    yield* Effect.annotateCurrentSpan(
+      "controllerName",
+      methodInfo.controllerName
+    );
+    yield* Effect.annotateCurrentSpan("methodName", methodInfo.methodName);
+    yield* Effect.annotateCurrentSpan("httpMethod", methodInfo.httpMethod);
+    yield* Effect.annotateCurrentSpan("path", methodInfo.path);
+    return paths;
+  }
+);
+const serviceTransformMethods = Effect.fn(
+  "TransformerService.transformMethods"
 )(function* (methodInfos) {
-  const endpoints = yield* Effect.forEach(methodInfos, transformMethodEffect, {
+  const endpoints = yield* Effect.forEach(methodInfos, serviceTransformMethod, {
     concurrency: "unbounded"
   });
-  return endpoints.reduce((acc, endpoint) => {
-    for (const path in endpoint) {
-      if (!acc[path]) acc[path] = {};
-      Object.assign(acc[path], endpoint[path]);
-    }
-    return acc;
-  }, {});
+  const paths = mergeOpenApiPaths(endpoints);
+  yield* Effect.annotateCurrentSpan("methodCount", methodInfos.length);
+  yield* Effect.annotateCurrentSpan("pathCount", Object.keys(paths).length);
+  return paths;
 });
+class TransformerService extends Effect.Service()(
+  "TransformerService",
+  {
+    effect: Effect.succeed({
+      transformMethod: serviceTransformMethod,
+      transformMethods: serviceTransformMethods
+    })
+  }
+) {
+}
+const transformMethodEffect = serviceTransformMethod;
+const transformMethodsEffect = serviceTransformMethods;
 
 const UGLY_NAME_PATTERN = /^(.+?)<.*>$/;
 const UGLY_NAME_PATTERN_ENCODED = /^(.+?)%3C.*%3E$/i;
@@ -4682,39 +4842,14 @@ class SchemaService extends Effect.Service()(
 ) {
 }
 
-const serviceExtractClassValidationInfo = Effect.fn(
-  "ValidationService.extractClassValidationInfo"
-)(function* (classDecl) {
-  return yield* extractClassValidationInfoEffect(classDecl);
-});
-const serviceMergeValidationConstraints = Effect.fn(
-  "ValidationService.mergeValidationConstraints"
-)(function* (schemas, classConstraints, classRequired) {
-  return yield* mergeValidationConstraintsEffect(
-    schemas,
-    classConstraints,
-    classRequired
-  );
-});
-class ValidationService extends Effect.Service()(
-  "ValidationService",
-  {
-    accessors: true,
-    effect: Effect.succeed({
-      extractClassValidationInfo: serviceExtractClassValidationInfo,
-      mergeValidationConstraints: serviceMergeValidationConstraints
-    })
-  }
-) {
-}
-
 const generatorServicesLayer = Layer.mergeAll(
   ConfigService.Default,
   ProjectService.Default,
   ModuleTraversalService.Default,
   MethodExtractionService.Default,
   SchemaService.Default,
-  ValidationService.Default,
+  TransformerService.Default,
+  ValidationMapperService.Default,
   OutputService.Default
 );
 
@@ -5006,6 +5141,7 @@ const extractValidationConstraintsEffect = Effect.fn(
   if (dtoFiles.length === 0) {
     return schemas;
   }
+  const validation = yield* ValidationMapperService;
   const project = new Project({
     tsConfigFilePath: tsconfig,
     skipAddingFilesFromTsConfig: true,
@@ -5026,7 +5162,7 @@ const extractValidationConstraintsEffect = Effect.fn(
     for (const classDecl of sourceFile.getClasses()) {
       const className = classDecl.getName();
       if (!className) continue;
-      const { constraints, required } = yield* ValidationService.extractClassValidationInfo(classDecl);
+      const { constraints, required } = yield* validation.extractClassValidationInfo(classDecl);
       if (Object.keys(constraints).length > 0) {
         classConstraints.set(className, constraints);
       }
@@ -5042,7 +5178,7 @@ const extractValidationConstraintsEffect = Effect.fn(
       classesWithRequired: classRequired.size
     })
   );
-  return yield* ValidationService.mergeValidationConstraints(
+  return yield* validation.mergeValidationConstraints(
     schemas,
     classConstraints,
     classRequired
@@ -5212,7 +5348,8 @@ const generateEffect = Effect.fn("Generate.generateEffect")(function* (configPat
     "filteredMethodCount",
     filteredMethodInfos.length
   );
-  let paths = yield* transformMethodsEffect(filteredMethodInfos);
+  const transformer = yield* TransformerService;
+  let paths = yield* transformer.transformMethods(filteredMethodInfos);
   yield* Effect.annotateCurrentSpan("initialPathCount", Object.keys(paths).length);
   if (options.basePath) {
     const prefix = options.basePath.startsWith("/") ? options.basePath : `/${options.basePath}`;
@@ -5500,4 +5637,4 @@ const generate = async (configPath, overrides) => {
   return runGeneratorApiPromise(program);
 };
 
-export { generateSchemasFromFiles as $, getControllerMethodInfosEffect as A, MethodExtractionService as B, ConfigNotFoundError as C, DtoGlobResolutionError as D, EntryNotFoundError as E, transformMethod as F, transformMethodEffect as G, transformMethods as H, InvalidMethodError as I, transformMethodsEffect as J, mergeSchemas as K, mergeSchemasEffect as L, MissingGenericSchemaTempFileCleanupError as M, mergeGeneratedSchemas as N, mergeGeneratedSchemasEffect as O, ProjectInitError as P, filterSchemas as Q, filterSchemasEffect as R, SpecFileNotFoundError as S, normalizeSchemas as T, normalizeSchemasEffect as U, filterInternalSchemas as V, filterInternalSchemasEffect as W, normalizeStructureRefs as X, normalizeStructureRefsEffect as Y, toPascalCase as Z, generateSchemas as _, SpecFileParseError as a, SchemaGenerationError as a0, SchemaService as a1, extractPropertyConstraints as a2, isPropertyOptional as a3, extractPropertyValidationInfo as a4, extractClassValidationInfo as a5, extractClassValidationInfoEffect as a6, extractClassConstraints as a7, getRequiredProperties as a8, applyConstraintsToSchema as a9, runGeneratorApiPromise as aA, mergeValidationConstraints as aa, mergeValidationConstraintsEffect as ab, ValidationService as ac, OutputService as ad, ConfigService as ae, findConfigFile as af, loadConfigFromFile as ag, loadConfig as ah, resolveConfig as ai, loadAndResolveConfig as aj, generatorServicesLayer as ak, resolveClassFromSymbol as al, getArrayInitializer as am, getStringLiteralValue as an, getSymbolFromIdentifier as ao, isModuleClass as ap, getModuleDecoratorArg as aq, resolveClassFromExpression as ar, resolveArrayOfClasses as as, getModuleMetadata as at, validateSpec as au, categorizeBrokenRefs as av, formatValidationResult as aw, generateEffect as ax, runProjectApiPromise as ay, runtimeLayerFor as az, SpecFileReadError as b, ConfigLoadError as c, defineConfig as d, ConfigValidationError as e, MissingGenericSchemaTempFileWriteError as f, generate as g, PublicApiError as h, ProjectService as i, ProjectServiceLive as j, getModules as k, getAllControllers as l, makeProjectContext as m, ModuleTraversalService as n, getControllerPrefix as o, getControllerName as p, isHttpMethod as q, getHttpMethods as r, getDecoratorName$1 as s, getControllerTags as t, getHttpDecorator as u, isHttpDecorator as v, normalizePath as w, getMethodInfo as x, getMethodInfoEffect as y, getControllerMethodInfos as z };
+export { generateSchemas as $, getControllerMethodInfosEffect as A, MethodExtractionService as B, ConfigNotFoundError as C, DtoGlobResolutionError as D, EntryNotFoundError as E, transformMethod as F, transformMethodEffect as G, transformMethods as H, InvalidMethodError as I, transformMethodsEffect as J, mergeSchemas as K, mergeSchemasEffect as L, MissingGenericSchemaTempFileCleanupError as M, mergeGeneratedSchemas as N, mergeGeneratedSchemasEffect as O, ProjectInitError as P, filterSchemas as Q, filterSchemasEffect as R, SpecFileNotFoundError as S, TransformerService as T, normalizeSchemas as U, normalizeSchemasEffect as V, filterInternalSchemas as W, filterInternalSchemasEffect as X, normalizeStructureRefs as Y, normalizeStructureRefsEffect as Z, toPascalCase as _, SpecFileParseError as a, generateSchemasFromFiles as a0, SchemaGenerationError as a1, SchemaService as a2, ValidationMapperService as a3, extractPropertyConstraints as a4, isPropertyOptional as a5, extractPropertyValidationInfo as a6, extractClassValidationInfo as a7, extractClassValidationInfoEffect as a8, extractClassConstraints as a9, runtimeLayerFor as aA, runGeneratorApiPromise as aB, getRequiredProperties as aa, applyConstraintsToSchema as ab, mergeValidationConstraints as ac, mergeValidationConstraintsEffect as ad, OutputService as ae, ConfigService as af, findConfigFile as ag, loadConfigFromFile as ah, loadConfig as ai, resolveConfig as aj, loadAndResolveConfig as ak, generatorServicesLayer as al, resolveClassFromSymbol as am, getArrayInitializer as an, getStringLiteralValue as ao, getSymbolFromIdentifier as ap, isModuleClass as aq, getModuleDecoratorArg as ar, resolveClassFromExpression as as, resolveArrayOfClasses as at, getModuleMetadata as au, validateSpec as av, categorizeBrokenRefs as aw, formatValidationResult as ax, generateEffect as ay, runProjectApiPromise as az, SpecFileReadError as b, ConfigLoadError as c, defineConfig as d, ConfigValidationError as e, MissingGenericSchemaTempFileWriteError as f, generate as g, PublicApiError as h, ProjectService as i, ProjectServiceLive as j, getModules as k, getAllControllers as l, makeProjectContext as m, ModuleTraversalService as n, getControllerPrefix as o, getControllerName as p, isHttpMethod as q, getHttpMethods as r, getDecoratorName$1 as s, getControllerTags as t, getHttpDecorator as u, isHttpDecorator as v, normalizePath as w, getMethodInfo as x, getMethodInfoEffect as y, getControllerMethodInfos as z };