nestjs-openapi 0.1.0

package/dist/shared/nestjs-openapi.B1bBy_tG.mjs

@@ -0,0 +1,1529 @@
+import { Schema, Option, Effect } from 'effect';
+import { ts, Node } from 'ts-morph';
+
+class ProjectInitError extends Schema.TaggedError()(
+  "ProjectInitError",
+  {
+    tsconfig: Schema.String,
+    message: Schema.String,
+    cause: Schema.optional(Schema.Unknown)
+  }
+) {
+  static create(tsconfig, cause) {
+    return new ProjectInitError({
+      tsconfig,
+      message: `Failed to initialize project with tsconfig: ${tsconfig}`,
+      cause
+    });
+  }
+}
+class EntryNotFoundError extends Schema.TaggedError()(
+  "EntryNotFoundError",
+  {
+    entry: Schema.String,
+    className: Schema.String,
+    message: Schema.String
+  }
+) {
+  static fileNotFound(entry) {
+    return new EntryNotFoundError({
+      entry,
+      className: "AppModule",
+      message: `Source file not found: ${entry}`
+    });
+  }
+  static classNotFound(entry, className) {
+    return new EntryNotFoundError({
+      entry,
+      className,
+      message: `Entry class '${className}' not found in ${entry}`
+    });
+  }
+}
+class ConfigNotFoundError extends Schema.TaggedError()(
+  "ConfigNotFoundError",
+  {
+    path: Schema.optional(Schema.String),
+    searchDir: Schema.optional(Schema.String),
+    message: Schema.String
+  }
+) {
+  static notFound(searchDir) {
+    return new ConfigNotFoundError({
+      searchDir,
+      message: "No configuration file found. Create an openapi.config.ts file or specify a path."
+    });
+  }
+  static pathNotFound(path) {
+    return new ConfigNotFoundError({
+      path,
+      message: `Configuration file not found: ${path}`
+    });
+  }
+}
+class ConfigLoadError extends Schema.TaggedError()(
+  "ConfigLoadError",
+  {
+    path: Schema.String,
+    message: Schema.String,
+    cause: Schema.optional(Schema.Unknown)
+  }
+) {
+  static importFailed(path, cause) {
+    return new ConfigLoadError({
+      path,
+      message: `Failed to load configuration from ${path}`,
+      cause
+    });
+  }
+  static noExport(path) {
+    return new ConfigLoadError({
+      path,
+      message: `Configuration file must export a default config or named 'config' export: ${path}`
+    });
+  }
+}
+class ConfigValidationError extends Schema.TaggedError()(
+  "ConfigValidationError",
+  {
+    path: Schema.String,
+    message: Schema.String,
+    issues: Schema.Array(Schema.String)
+  }
+) {
+  static fromIssues(path, issues) {
+    const issuesList = issues.length > 0 ? `
+  ${issues.join("\n  ")}` : "";
+    return new ConfigValidationError({
+      path,
+      message: `Configuration validation failed: ${path}${issuesList}`,
+      issues: [...issues]
+    });
+  }
+}
+class InvalidMethodError extends Schema.TaggedError()(
+  "InvalidMethodError",
+  {
+    controllerName: Schema.String,
+    methodName: Schema.String,
+    message: Schema.String
+  }
+) {
+  static create(controllerName, methodName, reason) {
+    return new InvalidMethodError({
+      controllerName,
+      methodName,
+      message: `Invalid method ${controllerName}.${methodName}: ${reason}`
+    });
+  }
+}
+
+const resolveClassFromSymbol = (sym) => {
+  const target = sym.getAliasedSymbol?.() ?? sym;
+  const declarations = target.getDeclarations() ?? [];
+  const classDecl = declarations.find(
+    (d) => d.getKind?.() === ts.SyntaxKind.ClassDeclaration
+  );
+  return Option.fromNullable(classDecl);
+};
+const getArrayInitializer = (objectLiteral, propertyName) => {
+  const initializer = objectLiteral.getProperty(propertyName)?.asKind(ts.SyntaxKind.PropertyAssignment)?.getInitializer();
+  return Option.fromNullable(initializer);
+};
+const getStringLiteralValue = (expr) => {
+  if (!expr) return Option.none();
+  const stringLit = expr.asKind?.(ts.SyntaxKind.StringLiteral);
+  return Option.fromNullable(stringLit?.getLiteralValue());
+};
+const getSymbolFromIdentifier = (expr) => {
+  if (!expr) return Option.none();
+  const id = expr.asKind?.(ts.SyntaxKind.Identifier);
+  const symbol = id?.getSymbol() ?? id?.getDefinitionNodes()[0]?.getSymbol();
+  return Option.fromNullable(symbol);
+};
+
+const isModuleClass = (cls) => cls?.getDecorators().some((d) => d.getName() === "Module") ?? false;
+const getModuleDecoratorArg = (cls) => {
+  const decorator = cls.getDecorators().find((d) => d.getName() === "Module");
+  const arg = decorator?.getArguments()?.[0]?.asKind?.(ts.SyntaxKind.ObjectLiteralExpression);
+  return Option.fromNullable(arg);
+};
+const resolveClassFromExpression = (expr) => {
+  if (!expr) return Option.none();
+  const id = expr.asKind?.(ts.SyntaxKind.Identifier);
+  const symbol = id?.getSymbol() ?? id?.getDefinitionNodes()[0]?.getSymbol();
+  if (symbol) return resolveClassFromSymbol(symbol);
+  const call = expr.asKind?.(ts.SyntaxKind.CallExpression);
+  if (call && call.getExpression().getText().endsWith("forwardRef")) {
+    const args = call.getArguments();
+    if (args.length === 0) return Option.none();
+    const arrow = args[0]?.asKind(ts.SyntaxKind.ArrowFunction);
+    if (!arrow) return Option.none();
+    const body = arrow.getBody();
+    const bodyId = body.asKind?.(ts.SyntaxKind.Identifier);
+    if (bodyId) return resolveClassFromExpression(bodyId);
+    const block = body.asKind?.(ts.SyntaxKind.Block);
+    const retExpr = block?.getStatements().find((s) => s.getKind() === ts.SyntaxKind.ReturnStatement)?.asKind(ts.SyntaxKind.ReturnStatement)?.getExpression();
+    return resolveClassFromExpression(retExpr);
+  }
+  const pae = expr.asKind?.(ts.SyntaxKind.PropertyAccessExpression);
+  if (pae) return resolveClassFromExpression(pae.getNameNode());
+  return Option.none();
+};
+const resolveArrayOfClasses = (propInit) => {
+  const arr = propInit?.asKind?.(ts.SyntaxKind.ArrayLiteralExpression);
+  if (!arr) return [];
+  return arr.getElements().flatMap((element) => {
+    if (element.isKind(ts.SyntaxKind.SpreadElement)) return [];
+    const candidate = resolveClassFromExpression(
+      element
+    );
+    return Option.isSome(candidate) ? [candidate.value] : [];
+  });
+};
+const getModuleMetadata = (mod) => {
+  const modArgOpt = getModuleDecoratorArg(mod);
+  if (Option.isNone(modArgOpt)) {
+    return { controllers: [], imports: [] };
+  }
+  const obj = modArgOpt.value;
+  const controllersInit = Option.getOrUndefined(getArrayInitializer(obj, "controllers")) ?? Option.getOrUndefined(getArrayInitializer(obj, "controller"));
+  const importsInit = Option.getOrUndefined(
+    getArrayInitializer(obj, "imports")
+  );
+  const controllers = resolveArrayOfClasses(controllersInit).filter(
+    (cls) => cls.getName() !== void 0
+  );
+  const imports = resolveArrayOfClasses(importsInit).filter(isModuleClass);
+  return { controllers, imports };
+};
+
+const moduleKey = (mod) => `${mod.getSourceFile().getFilePath()}::${mod.getName() ?? "<anonymous>"}`;
+const getModules = Effect.fn("Modules.getModules")(function* (root) {
+  if (!isModuleClass(root)) {
+    yield* Effect.logWarning("Root is not a NestJS module").pipe(
+      Effect.annotateLogs({
+        className: root.getName() ?? "<anonymous>",
+        file: root.getSourceFile().getFilePath()
+      })
+    );
+    return [];
+  }
+  yield* Effect.logDebug("Starting module traversal").pipe(
+    Effect.annotateLogs({
+      root: root.getName() ?? "<anonymous>",
+      file: root.getSourceFile().getFilePath()
+    })
+  );
+  const results = [];
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [root];
+  while (stack.length > 0) {
+    const mod = stack.pop();
+    const key = moduleKey(mod);
+    if (visited.has(key)) continue;
+    visited.add(key);
+    const { controllers, imports } = getModuleMetadata(mod);
+    if (controllers.length > 0) {
+      results.push({ declaration: mod, controllers });
+    }
+    stack.push(...imports);
+  }
+  yield* Effect.logDebug("Module traversal complete").pipe(
+    Effect.annotateLogs({
+      modulesWithControllers: results.length,
+      totalVisited: visited.size
+    })
+  );
+  return results;
+});
+const getAllControllers = Effect.fn("Modules.getAllControllers")(
+  function* (root) {
+    const modules = yield* getModules(root);
+    return modules.flatMap((m) => m.controllers);
+  }
+);
+
+const HTTP_DECORATORS = /* @__PURE__ */ new Set([
+  "Get",
+  "Post",
+  "Put",
+  "Patch",
+  "Delete",
+  "Options",
+  "Head",
+  "All"
+]);
+const normalizePath = (path) => {
+  if (!path) return "/";
+  let out = path.startsWith("/") ? path : `/${path}`;
+  if (out !== "/" && out.endsWith("/")) out = out.slice(0, -1);
+  return out;
+};
+const getControllerPrefix = (controller) => {
+  const decorator = controller.getDecorators().find((d) => d.getName() === "Controller");
+  if (!decorator) return "/";
+  const arg = decorator.getArguments()[0];
+  const value = arg?.asKind?.(ts.SyntaxKind.StringLiteral)?.getLiteralValue();
+  return value ? normalizePath(value) : "/";
+};
+const getControllerName = (controller) => controller.getName() ?? "<anonymous>";
+const isHttpMethod = (method) => method.getDecorators().some((d) => HTTP_DECORATORS.has(d.getName()));
+const getHttpMethods = (controller) => controller.getMethods().filter(isHttpMethod);
+const getDecoratorName$1 = (decorator) => {
+  const expr = decorator.getExpression();
+  if (expr.getKind() === ts.SyntaxKind.CallExpression) {
+    const call = expr.asKindOrThrow(ts.SyntaxKind.CallExpression);
+    const exprText = call.getExpression().getText();
+    return exprText.split(".").pop();
+  }
+  return expr.getText().split(".").pop();
+};
+const getControllerTags = (controller) => {
+  const apiTagsDecorator = controller.getDecorators().find((d) => getDecoratorName$1(d) === "ApiTags");
+  if (!apiTagsDecorator) {
+    const name = getControllerName(controller);
+    return [name.replace(/Controller$/i, "")];
+  }
+  const tags = apiTagsDecorator.getArguments().flatMap((arg) => {
+    const stringLit = arg.asKind?.(ts.SyntaxKind.StringLiteral);
+    return stringLit ? [stringLit.getLiteralValue()] : [];
+  });
+  return tags.length > 0 ? tags : [
+    // Keep PascalCase, just remove 'Controller' suffix
+    getControllerName(controller).replace(/Controller$/i, "")
+  ];
+};
+const isHttpDecorator = (decorator) => HTTP_DECORATORS.has(decorator.getName());
+const getHttpDecorator = (method) => method.getDecorators().find((d) => HTTP_DECORATORS.has(d.getName()));
+
+const DEFAULT_SCHEME_NAMES = {
+  ApiBearerAuth: "bearer",
+  ApiBasicAuth: "basic",
+  ApiOAuth2: "oauth2",
+  ApiCookieAuth: "cookie"
+};
+const SECURITY_DECORATORS = /* @__PURE__ */ new Set([
+  "ApiBearerAuth",
+  "ApiBasicAuth",
+  "ApiOAuth2",
+  "ApiSecurity",
+  "ApiCookieAuth"
+]);
+const extractFirstStringArg = (decorator) => {
+  const args = decorator.getArguments();
+  if (args.length === 0) return void 0;
+  const firstArg = args[0];
+  const stringLit = firstArg.asKind?.(ts.SyntaxKind.StringLiteral);
+  return stringLit?.getLiteralValue();
+};
+const extractStringArray = (decorator) => {
+  const args = decorator.getArguments();
+  if (args.length === 0) return [];
+  const firstArg = args[0];
+  const arrayLit = firstArg.asKind?.(ts.SyntaxKind.ArrayLiteralExpression);
+  if (!arrayLit) return [];
+  const scopes = [];
+  for (const element of arrayLit.getElements()) {
+    const stringLit = element.asKind?.(ts.SyntaxKind.StringLiteral);
+    if (stringLit) {
+      scopes.push(stringLit.getLiteralValue());
+    }
+  }
+  return scopes;
+};
+const extractSecondStringArg = (decorator) => {
+  const args = decorator.getArguments();
+  if (args.length < 2) return void 0;
+  const secondArg = args[1];
+  const stringLit = secondArg.asKind?.(ts.SyntaxKind.StringLiteral);
+  return stringLit?.getLiteralValue();
+};
+const parseSecurityDecorator = (decorator) => {
+  const decoratorName = getDecoratorName$1(decorator);
+  if (!SECURITY_DECORATORS.has(decoratorName)) {
+    return void 0;
+  }
+  switch (decoratorName) {
+    case "ApiBearerAuth":
+    case "ApiBasicAuth":
+    case "ApiCookieAuth": {
+      const schemeName = extractFirstStringArg(decorator) ?? DEFAULT_SCHEME_NAMES[decoratorName];
+      return { schemeName, scopes: [] };
+    }
+    case "ApiOAuth2": {
+      const scopes = extractStringArray(decorator);
+      const schemeName = extractSecondStringArg(decorator) ?? DEFAULT_SCHEME_NAMES[decoratorName];
+      return { schemeName, scopes: [...scopes] };
+    }
+    case "ApiSecurity": {
+      const schemeName = extractFirstStringArg(decorator);
+      if (!schemeName) return void 0;
+      const args = decorator.getArguments();
+      const scopes = [];
+      if (args.length >= 2) {
+        const secondArg = args[1];
+        const arrayLit = secondArg.asKind?.(
+          ts.SyntaxKind.ArrayLiteralExpression
+        );
+        if (arrayLit) {
+          for (const element of arrayLit.getElements()) {
+            const stringLit = element.asKind?.(ts.SyntaxKind.StringLiteral);
+            if (stringLit) {
+              scopes.push(stringLit.getLiteralValue());
+            }
+          }
+        }
+      }
+      return { schemeName, scopes };
+    }
+    default:
+      return void 0;
+  }
+};
+const extractSecurityFromDecorators = (decorators) => {
+  const requirements = [];
+  for (const decorator of decorators) {
+    const requirement = parseSecurityDecorator(decorator);
+    if (requirement) {
+      requirements.push(requirement);
+    }
+  }
+  return requirements;
+};
+const extractControllerSecurity = (controller) => extractSecurityFromDecorators(controller.getDecorators());
+const extractMethodSecurity = (method) => extractSecurityFromDecorators(method.getDecorators());
+const hasMethodSecurityDecorators = (method) => method.getDecorators().some((d) => SECURITY_DECORATORS.has(getDecoratorName$1(d)));
+const combineSecurityRequirements = (controllerSecurity, methodSecurity, hasMethodDecorators) => {
+  if (hasMethodDecorators) {
+    return methodSecurity;
+  }
+  return controllerSecurity;
+};
+
+const getDecoratorName = (decorator) => {
+  const callExpr = decorator.getCallExpression();
+  if (!callExpr) {
+    const nameNode = decorator.getName();
+    return Option.fromNullable(nameNode);
+  }
+  const expr = callExpr.getExpression();
+  if (expr.getKind() === ts.SyntaxKind.Identifier) {
+    return Option.some(expr.getText());
+  }
+  return Option.none();
+};
+const DECORATOR_MAPPINGS = {
+  // Type validators
+  IsString: () => ({ type: "string" }),
+  IsNumber: () => ({ type: "number" }),
+  IsInt: () => ({ type: "integer" }),
+  IsBoolean: () => ({ type: "boolean" }),
+  IsArray: () => ({ type: "array" }),
+  IsObject: () => ({ type: "object" }),
+  IsDate: () => ({ type: "string", format: "date-time" }),
+  // String format validators
+  IsEmail: () => ({ format: "email" }),
+  IsUrl: () => ({ format: "uri" }),
+  IsUUID: () => ({ format: "uuid" }),
+  IsDateString: () => ({ format: "date-time" }),
+  IsISO8601: () => ({ format: "date-time" }),
+  IsPhoneNumber: () => ({ format: "phone" }),
+  IsCreditCard: () => ({ format: "credit-card" }),
+  IsIP: () => ({ format: "ipv4" }),
+  IsJSON: () => ({ format: "json" }),
+  // String length validators
+  MinLength: (args) => ({ minLength: parseNumber(args[0]) }),
+  MaxLength: (args) => ({ maxLength: parseNumber(args[0]) }),
+  Length: (args) => ({
+    minLength: parseNumber(args[0]),
+    maxLength: parseNumber(args[1]) ?? parseNumber(args[0])
+  }),
+  // String pattern validators
+  Matches: (args) => {
+    const pattern = args[0];
+    if (pattern) {
+      const cleanPattern = pattern.replace(/^\/(.*)\/[gimsuvy]*$/, "$1");
+      return { pattern: cleanPattern };
+    }
+    return {};
+  },
+  // Number validators
+  Min: (args) => ({ minimum: parseNumber(args[0]) }),
+  Max: (args) => ({ maximum: parseNumber(args[0]) }),
+  IsPositive: () => ({ exclusiveMinimum: 0 }),
+  IsNegative: () => ({ exclusiveMaximum: 0 }),
+  // Array validators
+  ArrayMinSize: (args) => ({ minItems: parseNumber(args[0]) }),
+  ArrayMaxSize: (args) => ({ maxItems: parseNumber(args[0]) }),
+  // Enum validator - static analysis can't easily extract enum values
+  IsEnum: () => ({}),
+  // Other validators (these don't map directly to OpenAPI but inform the schema)
+  IsOptional: () => ({}),
+  // Handled separately via required array
+  IsNotEmpty: () => ({ minLength: 1 }),
+  IsDefined: () => ({}),
+  IsEmpty: () => ({}),
+  // Nested/type validators
+  ValidateNested: () => ({}),
+  Type: () => ({})
+};
+const parseNumber = (value) => {
+  if (value === void 0) return void 0;
+  const num = Number(value);
+  return isNaN(num) ? void 0 : num;
+};
+const getDecoratorArgs = (decorator) => {
+  const callExpr = decorator.getCallExpression();
+  if (!callExpr) return [];
+  return callExpr.getArguments().map((arg) => arg.getText());
+};
+const extractEnumValues = (enumDecl) => {
+  const values = [];
+  let currentValue = 0;
+  for (const member of enumDecl.getMembers()) {
+    const initializer = member.getInitializer();
+    if (initializer) {
+      if (Node.isStringLiteral(initializer)) {
+        values.push(initializer.getLiteralValue());
+      } else if (Node.isNumericLiteral(initializer)) {
+        const numValue = initializer.getLiteralValue();
+        values.push(numValue);
+        currentValue = numValue + 1;
+      } else {
+        const text = initializer.getText();
+        const num = Number(text);
+        if (!isNaN(num)) {
+          values.push(num);
+          currentValue = num + 1;
+        } else {
+          values.push(text);
+        }
+      }
+    } else {
+      values.push(currentValue);
+      currentValue++;
+    }
+  }
+  return values;
+};
+const resolveEnumFromDecorator = (decorator) => {
+  const callExpr = decorator.getCallExpression();
+  if (!callExpr) return void 0;
+  const args = callExpr.getArguments();
+  if (args.length === 0) return void 0;
+  const firstArg = args[0];
+  if (!Node.isIdentifier(firstArg)) return void 0;
+  const symbol = firstArg.getSymbol();
+  if (!symbol) return void 0;
+  const declarations = symbol.getDeclarations();
+  if (!declarations || declarations.length === 0) return void 0;
+  for (const decl of declarations) {
+    if (Node.isEnumDeclaration(decl)) {
+      return extractEnumValues(decl);
+    }
+  }
+  for (const decl of declarations) {
+    if (Node.isImportSpecifier(decl)) {
+      const localSymbol = decl.getSymbol();
+      const aliasedSymbol = localSymbol?.getAliasedSymbol();
+      if (aliasedSymbol) {
+        const aliasedDecls = aliasedSymbol.getDeclarations();
+        for (const aliasedDecl of aliasedDecls ?? []) {
+          if (Node.isEnumDeclaration(aliasedDecl)) {
+            return extractEnumValues(aliasedDecl);
+          }
+        }
+      }
+    }
+  }
+  return void 0;
+};
+const extractPropertyConstraints = (property) => {
+  const constraints = {};
+  for (const decorator of property.getDecorators()) {
+    const nameOpt = getDecoratorName(decorator);
+    if (Option.isNone(nameOpt)) continue;
+    if (nameOpt.value === "IsEnum") {
+      const enumValues = resolveEnumFromDecorator(decorator);
+      if (enumValues && enumValues.length > 0) {
+        Object.assign(constraints, { enum: enumValues });
+      }
+      continue;
+    }
+    const mapper = DECORATOR_MAPPINGS[nameOpt.value];
+    if (!mapper) continue;
+    Object.assign(constraints, mapper(getDecoratorArgs(decorator)));
+  }
+  return constraints;
+};
+const isPropertyOptional = (property) => {
+  const decorators = property.getDecorators();
+  return decorators.some((d) => {
+    const nameOpt = getDecoratorName(d);
+    return Option.isSome(nameOpt) && nameOpt.value === "IsOptional";
+  });
+};
+const extractPropertyValidationInfo = (property) => {
+  const constraints = {};
+  let isOptional = false;
+  for (const decorator of property.getDecorators()) {
+    const nameOpt = getDecoratorName(decorator);
+    if (Option.isNone(nameOpt)) continue;
+    const name = nameOpt.value;
+    if (name === "IsOptional") {
+      isOptional = true;
+      continue;
+    }
+    if (name === "IsEnum") {
+      const enumValues = resolveEnumFromDecorator(decorator);
+      if (enumValues && enumValues.length > 0) {
+        Object.assign(constraints, { enum: enumValues });
+      }
+      continue;
+    }
+    const mapper = DECORATOR_MAPPINGS[name];
+    if (!mapper) continue;
+    Object.assign(constraints, mapper(getDecoratorArgs(decorator)));
+  }
+  return { isOptional, constraints };
+};
+const extractClassConstraints = (classDecl) => {
+  const result = {};
+  const properties = classDecl.getProperties();
+  for (const property of properties) {
+    const name = property.getName();
+    const constraints = extractPropertyConstraints(property);
+    if (Object.keys(constraints).length > 0) {
+      result[name] = constraints;
+    }
+  }
+  return result;
+};
+const getRequiredProperties = (classDecl) => {
+  const properties = classDecl.getProperties();
+  const required = [];
+  for (const property of properties) {
+    if (!isPropertyOptional(property)) {
+      required.push(property.getName());
+    }
+  }
+  return required;
+};
+const applyConstraintsToSchema = (schema, propertyConstraints, requiredProperties) => {
+  const updated = { ...schema };
+  if (schema.properties && Object.keys(propertyConstraints).length > 0) {
+    const updatedProperties = {};
+    for (const [propName, propSchema] of Object.entries(schema.properties)) {
+      const constraints = propertyConstraints[propName];
+      if (constraints) {
+        updatedProperties[propName] = {
+          ...propSchema,
+          ...constraints
+        };
+      } else {
+        updatedProperties[propName] = propSchema;
+      }
+    }
+    updated.properties = updatedProperties;
+  }
+  if (requiredProperties && requiredProperties.length > 0) {
+    const existingRequired = new Set(schema.required ?? []);
+    for (const prop of requiredProperties) {
+      existingRequired.add(prop);
+    }
+    updated.required = [...existingRequired];
+  }
+  return updated;
+};
+const mergeValidationConstraints = (schemas, classConstraints, classRequired) => {
+  const updatedDefinitions = {};
+  for (const [name, schema] of Object.entries(schemas.definitions)) {
+    const constraints = classConstraints.get(name);
+    const required = classRequired.get(name);
+    if (constraints || required) {
+      updatedDefinitions[name] = applyConstraintsToSchema(
+        schema,
+        constraints ?? {},
+        required
+      );
+    } else {
+      updatedDefinitions[name] = schema;
+    }
+  }
+  return { definitions: updatedDefinitions };
+};
+
+const HTTP_METHOD_MAP = {
+  Get: "GET",
+  Post: "POST",
+  Put: "PUT",
+  Patch: "PATCH",
+  Delete: "DELETE",
+  Options: "OPTIONS",
+  Head: "HEAD",
+  All: "ALL"
+};
+const PARAMETER_DECORATOR_MAP = {
+  Param: "path",
+  Query: "query",
+  Body: "body",
+  Headers: "header"
+};
+const PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "any",
+  "unknown",
+  "void",
+  "null",
+  "undefined",
+  "never",
+  "object",
+  "String",
+  "Number",
+  "Boolean",
+  "Date"
+]);
+const buildFullPath = (controllerPrefix, methodPath) => {
+  const prefix = controllerPrefix.replace(/\/+$/, "");
+  const normalizedPath = methodPath.replace(/^\/+/, "");
+  if (!prefix && !normalizedPath) return "/";
+  if (!normalizedPath) return prefix || "/";
+  if (!prefix) return `/${normalizedPath}`;
+  return `${prefix}/${normalizedPath}`.replace(/\/+/g, "/");
+};
+const getRoutePath = (decorator) => {
+  const arg = decorator.getArguments()[0];
+  const stringLit = arg?.asKind?.(ts.SyntaxKind.StringLiteral);
+  return normalizePath(stringLit?.getLiteralValue() ?? "/");
+};
+const parseTypeText = (text) => {
+  const trimmed = text.trim();
+  return trimmed.startsWith("{") && trimmed.endsWith("}") ? { type: Option.none(), inline: Option.some(trimmed) } : { type: Option.some(trimmed), inline: Option.none() };
+};
+const getReturnTypeInfo = (method) => {
+  const returnType = method.getReturnType();
+  const awaited = returnType.getAwaitedType?.() ?? returnType;
+  const symbol = awaited.getSymbol?.();
+  const getOriginalTypeName = () => {
+    if (!symbol) return null;
+    const aliased = symbol.getAliasedSymbol?.();
+    if (aliased) {
+      const name = aliased.getName();
+      if (name && !name.startsWith("__")) return name;
+    }
+    return null;
+  };
+  let text = getOriginalTypeName() ?? awaited.getText(method);
+  const promiseMatch = text.match(/^Promise<(.+)>$/);
+  if (promiseMatch) text = promiseMatch[1].trim();
+  text = text.replace(/\bimport\([^)]*\)\./g, "");
+  const resolveFilePath = () => {
+    if (symbol) {
+      const decls = symbol.getDeclarations();
+      if (decls && decls.length > 0) {
+        return Option.some(decls[0].getSourceFile().getFilePath());
+      }
+    }
+    return Option.none();
+  };
+  if (text.endsWith("[]")) {
+    const baseType = text.slice(0, -2);
+    const base = parseTypeText(baseType);
+    return {
+      ...base,
+      container: Option.some("array"),
+      filePath: Option.isSome(base.type) ? resolveFilePath() : Option.none()
+    };
+  }
+  const arrayMatch = text.match(/^(?:Readonly)?Array<(.+)>$/);
+  if (arrayMatch) {
+    const base = parseTypeText(arrayMatch[1]);
+    return {
+      ...base,
+      container: Option.some("array"),
+      filePath: Option.isSome(base.type) ? resolveFilePath() : Option.none()
+    };
+  }
+  const parsed = parseTypeText(text);
+  return {
+    ...parsed,
+    container: Option.none(),
+    filePath: Option.isSome(parsed.type) ? resolveFilePath() : Option.none()
+  };
+};
+const extractDescriptionFromDecorator = (decorator) => {
+  for (const arg of decorator.getArguments()) {
+    const objLit = arg.asKind?.(ts.SyntaxKind.ObjectLiteralExpression);
+    if (!objLit) continue;
+    const descProperty = objLit.getProperty("description");
+    if (!descProperty) continue;
+    const propAssignment = descProperty.asKind?.(
+      ts.SyntaxKind.PropertyAssignment
+    );
+    if (!propAssignment) continue;
+    const initializer = propAssignment.getInitializer();
+    const stringLit = initializer?.asKind?.(ts.SyntaxKind.StringLiteral);
+    if (!stringLit) continue;
+    return Option.some(stringLit.getLiteralValue());
+  }
+  return Option.none();
+};
+const extractDescriptionByName = (decorator, paramName) => {
+  for (const arg of decorator.getArguments()) {
+    const objLit = arg.asKind?.(ts.SyntaxKind.ObjectLiteralExpression);
+    if (!objLit) continue;
+    const nameProperty = objLit.getProperty("name");
+    if (!nameProperty) continue;
+    const namePropAssignment = nameProperty.asKind?.(
+      ts.SyntaxKind.PropertyAssignment
+    );
+    if (!namePropAssignment) continue;
+    const nameInitializer = namePropAssignment.getInitializer();
+    const nameStringLit = nameInitializer?.asKind?.(
+      ts.SyntaxKind.StringLiteral
+    );
+    if (nameStringLit?.getLiteralValue() !== paramName) continue;
+    const descProperty = objLit.getProperty("description");
+    if (!descProperty) continue;
+    const descPropAssignment = descProperty.asKind?.(
+      ts.SyntaxKind.PropertyAssignment
+    );
+    if (!descPropAssignment) continue;
+    const descInitializer = descPropAssignment.getInitializer();
+    const descStringLit = descInitializer?.asKind?.(
+      ts.SyntaxKind.StringLiteral
+    );
+    if (!descStringLit) continue;
+    return Option.some(descStringLit.getLiteralValue());
+  }
+  return Option.none();
+};
+const extractParameterDescription = (method, param, paramName, paramLocation) => {
+  const apiDecoratorNames = ["ApiQuery", "ApiParam", "ApiBody", "ApiHeader"];
+  for (const decorator of param.getDecorators()) {
+    const decoratorName = getDecoratorName$1(decorator);
+    if (apiDecoratorNames.includes(decoratorName)) {
+      const desc = extractDescriptionFromDecorator(decorator);
+      if (Option.isSome(desc)) return desc;
+    }
+  }
+  const decoratorMap = {
+    query: "ApiQuery",
+    path: "ApiParam",
+    header: "ApiHeader",
+    body: "ApiBody"
+  };
+  for (const decorator of method.getDecorators()) {
+    const decoratorName = getDecoratorName$1(decorator);
+    if (decoratorName === decoratorMap[paramLocation]) {
+      const desc = extractDescriptionByName(decorator, paramName);
+      if (Option.isSome(desc)) return desc;
+    }
+  }
+  return Option.none();
+};
+const BUILT_IN_TYPES = /* @__PURE__ */ new Set([
+  "Array",
+  "ReadonlyArray",
+  "Promise",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Record",
+  "Partial",
+  "Required",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "ReturnType",
+  "InstanceType",
+  "Parameters"
+]);
+const isExpandableType = (typeName) => {
+  if (PRIMITIVE_TYPES.has(typeName)) return false;
+  if (BUILT_IN_TYPES.has(typeName.split("<")[0])) return false;
+  if (typeName.includes(" | ") || typeName.includes(" & ")) return false;
+  if (typeName.endsWith("[]")) return false;
+  return /^[A-Z][a-zA-Z0-9]*$/.test(typeName);
+};
+const tsTypeToString = (typeText) => {
+  const trimmed = typeText.trim();
+  if (trimmed === "string" || trimmed === "String") return "string";
+  if (trimmed === "number" || trimmed === "Number") return "number";
+  if (trimmed === "boolean" || trimmed === "Boolean") return "boolean";
+  if (trimmed === "Date") return "Date";
+  if (trimmed.includes(" | undefined")) {
+    return trimmed.replace(" | undefined", "").trim();
+  }
+  return trimmed;
+};
+const expandQueryDtoProperties = (method, param, paramType) => {
+  const expandedParams = [];
+  const properties = paramType.getProperties();
+  for (const prop of properties) {
+    const propName = prop.getName();
+    if (propName.startsWith("_")) continue;
+    const declarations = prop.getDeclarations();
+    let propTypeText = "unknown";
+    let isOptional = false;
+    let constraints = void 0;
+    if (declarations.length > 0) {
+      const decl = declarations[0];
+      const propDecl = decl.asKind?.(ts.SyntaxKind.PropertyDeclaration);
+      const propSig = decl.asKind?.(ts.SyntaxKind.PropertySignature);
+      if (propDecl) {
+        propTypeText = tsTypeToString(propDecl.getType().getText(propDecl));
+        const validationInfo = extractPropertyValidationInfo(propDecl);
+        isOptional = propDecl.hasQuestionToken() || propDecl.hasInitializer?.() || validationInfo.isOptional;
+        if (Object.keys(validationInfo.constraints).length > 0) {
+          constraints = validationInfo.constraints;
+        }
+      } else if (propSig) {
+        propTypeText = tsTypeToString(propSig.getType().getText(propSig));
+        isOptional = propSig.hasQuestionToken();
+      }
+    }
+    const description = extractDescriptionByName(
+      method.getDecorators().find((d) => getDecoratorName$1(d) === "ApiQuery") ?? param.getDecorators()[0],
+      propName
+    );
+    expandedParams.push({
+      name: propName,
+      location: "query",
+      tsType: propTypeText,
+      required: !isOptional,
+      description,
+      constraints
+    });
+  }
+  return expandedParams;
+};
+const extractParameters = (method, options = {}) => method.getParameters().reduce((params, param) => {
+  const relevantDecorator = param.getDecorators().find((d) => d.getName() in PARAMETER_DECORATOR_MAP);
+  if (!relevantDecorator) return params;
+  const decoratorName = relevantDecorator.getName();
+  const args = relevantDecorator.getArguments();
+  let paramName = param.getName();
+  let hasExplicitName = false;
+  for (const arg of args) {
+    const stringLit = arg.asKind?.(ts.SyntaxKind.StringLiteral);
+    if (stringLit) {
+      paramName = stringLit.getLiteralValue();
+      hasExplicitName = true;
+      break;
+    }
+  }
+  const location = PARAMETER_DECORATOR_MAP[decoratorName] ?? "query";
+  const paramType = param.getType();
+  let tsType = paramType.getText(param);
+  const symbol = paramType.getSymbol?.();
+  if (symbol) {
+    const symbolName = symbol.getName();
+    if (symbolName && !symbolName.startsWith("__") && !BUILT_IN_TYPES.has(symbolName)) {
+      tsType = symbolName;
+    }
+  }
+  tsType = tsType.replace(/\bimport\([^)]*\)\./g, "");
+  if (decoratorName === "Query" && !hasExplicitName && options.query?.style !== "ref" && isExpandableType(tsType)) {
+    const expandedParams = expandQueryDtoProperties(method, param, paramType);
+    if (expandedParams.length > 0) {
+      params.push(...expandedParams);
+      return params;
+    }
+  }
+  const isOptional = param.hasQuestionToken() || param.hasInitializer();
+  const description = extractParameterDescription(
+    method,
+    param,
+    paramName,
+    location
+  );
+  params.push({
+    name: paramName,
+    location,
+    tsType,
+    required: !isOptional,
+    description
+  });
+  return params;
+}, []);
+const extractDecoratorNames = (method) => method.getDecorators().map((d) => getDecoratorName$1(d));
+const extractStringArguments = (decorator) => {
+  const args = decorator.getArguments();
+  const results = [];
+  for (const arg of args) {
+    const stringLit = arg.asKind?.(ts.SyntaxKind.StringLiteral);
+    if (stringLit) {
+      results.push(stringLit.getLiteralValue());
+    }
+  }
+  return results;
+};
+const extractApiConsumes = (method) => {
+  for (const decorator of method.getDecorators()) {
+    const decoratorName = getDecoratorName$1(decorator);
+    if (decoratorName === "ApiConsumes") {
+      return extractStringArguments(decorator);
+    }
+  }
+  return [];
+};
+const extractApiProduces = (method) => {
+  for (const decorator of method.getDecorators()) {
+    const decoratorName = getDecoratorName$1(decorator);
+    if (decoratorName === "ApiProduces") {
+      return extractStringArguments(decorator);
+    }
+  }
+  return [];
+};
+const extractStringPropertyFromObjectLiteral = (decorator, propertyName) => {
+  const arg = decorator.getArguments()[0];
+  const objLit = arg?.asKind?.(ts.SyntaxKind.ObjectLiteralExpression);
+  if (!objLit) return Option.none();
+  const property = objLit.getProperty(propertyName);
+  if (!property) return Option.none();
+  const propAssignment = property.asKind?.(ts.SyntaxKind.PropertyAssignment);
+  if (!propAssignment) return Option.none();
+  const initializer = propAssignment.getInitializer();
+  const stringLit = initializer?.asKind?.(ts.SyntaxKind.StringLiteral);
+  if (stringLit) {
+    return Option.some(stringLit.getLiteralValue());
+  }
+  return Option.none();
+};
+const extractBooleanPropertyFromDecorator = (decorator, propertyName) => {
+  const arg = decorator.getArguments()[0];
+  const objLit = arg?.asKind?.(ts.SyntaxKind.ObjectLiteralExpression);
+  if (!objLit) return Option.none();
+  const property = objLit.getProperty(propertyName);
+  if (!property) return Option.none();
+  const propAssignment = property.asKind?.(ts.SyntaxKind.PropertyAssignment);
+  if (!propAssignment) return Option.none();
+  const initializer = propAssignment.getInitializer();
+  if (initializer?.getKind() === ts.SyntaxKind.TrueKeyword) {
+    return Option.some(true);
+  }
+  if (initializer?.getKind() === ts.SyntaxKind.FalseKeyword) {
+    return Option.some(false);
+  }
+  return Option.none();
+};
+const HTTP_STATUS_MAP = {
+  CONTINUE: 100,
+  SWITCHING_PROTOCOLS: 101,
+  PROCESSING: 102,
+  EARLYHINTS: 103,
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NON_AUTHORITATIVE_INFORMATION: 203,
+  NO_CONTENT: 204,
+  RESET_CONTENT: 205,
+  PARTIAL_CONTENT: 206,
+  AMBIGUOUS: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  REQUESTED_RANGE_NOT_SATISFIABLE: 416,
+  EXPECTATION_FAILED: 417,
+  I_AM_A_TEAPOT: 418,
+  MISDIRECTED: 421,
+  UNPROCESSABLE_ENTITY: 422,
+  FAILED_DEPENDENCY: 424,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505
+};
+const extractNumberPropertyFromDecorator = (decorator, propertyName) => {
+  const arg = decorator.getArguments()[0];
+  const objLit = arg?.asKind?.(ts.SyntaxKind.ObjectLiteralExpression);
+  if (!objLit) return Option.none();
+  const property = objLit.getProperty(propertyName);
+  if (!property) return Option.none();
+  const propAssignment = property.asKind?.(ts.SyntaxKind.PropertyAssignment);
+  if (!propAssignment) return Option.none();
+  const initializer = propAssignment.getInitializer();
+  const numLit = initializer?.asKind?.(ts.SyntaxKind.NumericLiteral);
+  if (numLit) {
+    return Option.some(Number(numLit.getLiteralValue()));
+  }
+  const propAccess = initializer?.asKind?.(
+    ts.SyntaxKind.PropertyAccessExpression
+  );
+  if (propAccess) {
+    const statusName = propAccess.getName();
+    if (statusName && HTTP_STATUS_MAP[statusName] !== void 0) {
+      return Option.some(HTTP_STATUS_MAP[statusName]);
+    }
+  }
+  return Option.none();
+};
+const extractHttpCode = (method) => {
+  for (const decorator of method.getDecorators()) {
+    const decoratorName = getDecoratorName$1(decorator);
+    if (decoratorName === "HttpCode") {
+      const arg = decorator.getArguments()[0];
+      if (!arg) continue;
+      const numLit = arg.asKind?.(ts.SyntaxKind.NumericLiteral);
+      if (numLit) {
+        return Option.some(Number(numLit.getLiteralValue()));
+      }
+      const propAccess = arg.asKind?.(ts.SyntaxKind.PropertyAccessExpression);
+      if (propAccess) {
+        const statusName = propAccess.getName();
+        if (statusName && HTTP_STATUS_MAP[statusName] !== void 0) {
+          return Option.some(HTTP_STATUS_MAP[statusName]);
+        }
+      }
+    }
+  }
+  return Option.none();
+};
+const extractResponseType = (decorator) => {
+  const arg = decorator.getArguments()[0];
+  const objLit = arg?.asKind?.(ts.SyntaxKind.ObjectLiteralExpression);
+  if (!objLit) return { type: Option.none(), isArray: false };
+  const typeProperty = objLit.getProperty("type");
+  if (!typeProperty) return { type: Option.none(), isArray: false };
+  const propAssignment = typeProperty.asKind?.(
+    ts.SyntaxKind.PropertyAssignment
+  );
+  if (!propAssignment) return { type: Option.none(), isArray: false };
+  const initializer = propAssignment.getInitializer();
+  if (!initializer) return { type: Option.none(), isArray: false };
+  const arrayLit = initializer.asKind?.(ts.SyntaxKind.ArrayLiteralExpression);
+  if (arrayLit) {
+    const elements = arrayLit.getElements();
+    if (elements.length > 0) {
+      const firstElement = elements[0];
+      const identifier2 = firstElement.asKind?.(ts.SyntaxKind.Identifier);
+      if (identifier2) {
+        return { type: Option.some(identifier2.getText()), isArray: true };
+      }
+    }
+    return { type: Option.none(), isArray: true };
+  }
+  const identifier = initializer.asKind?.(ts.SyntaxKind.Identifier);
+  if (identifier) {
+    return { type: Option.some(identifier.getText()), isArray: false };
+  }
+  return { type: Option.none(), isArray: false };
+};
+const extractApiResponses = (method) => {
+  const responses = [];
+  for (const decorator of method.getDecorators()) {
+    const decoratorName = getDecoratorName$1(decorator);
+    if (decoratorName === "ApiResponse") {
+      const statusCode = extractNumberPropertyFromDecorator(
+        decorator,
+        "status"
+      );
+      if (Option.isNone(statusCode)) continue;
+      const description = extractStringPropertyFromObjectLiteral(
+        decorator,
+        "description"
+      );
+      const { type, isArray } = extractResponseType(decorator);
+      responses.push({
+        statusCode: statusCode.value,
+        description,
+        type,
+        isArray
+      });
+    }
+  }
+  return responses;
+};
+const extractApiOperationMetadata = (method) => {
+  for (const decorator of method.getDecorators()) {
+    const decoratorName = getDecoratorName$1(decorator);
+    if (decoratorName === "ApiOperation") {
+      return {
+        summary: extractStringPropertyFromObjectLiteral(decorator, "summary"),
+        description: extractStringPropertyFromObjectLiteral(
+          decorator,
+          "description"
+        ),
+        operationId: extractStringPropertyFromObjectLiteral(
+          decorator,
+          "operationId"
+        ),
+        deprecated: extractBooleanPropertyFromDecorator(
+          decorator,
+          "deprecated"
+        )
+      };
+    }
+  }
+  return {
+    summary: Option.none(),
+    description: Option.none(),
+    operationId: Option.none(),
+    deprecated: Option.none()
+  };
+};
+const getMethodInfo = (controller, method, options = {}) => {
+  const httpDecorator = getHttpDecorator(method);
+  if (!httpDecorator) return Option.none();
+  const decoratorName = httpDecorator.getName();
+  const httpMethod = HTTP_METHOD_MAP[decoratorName];
+  if (!httpMethod) return Option.none();
+  const controllerPrefix = getControllerPrefix(controller);
+  const methodPath = getRoutePath(httpDecorator);
+  const fullPath = buildFullPath(controllerPrefix, methodPath);
+  const controllerSecurity = extractControllerSecurity(controller);
+  const methodSecurity = extractMethodSecurity(method);
+  const hasMethodSecurity = hasMethodSecurityDecorators(method);
+  const security = combineSecurityRequirements(
+    controllerSecurity,
+    methodSecurity,
+    hasMethodSecurity
+  );
+  return Option.some({
+    httpMethod,
+    path: fullPath,
+    methodName: method.getName(),
+    controllerName: getControllerName(controller),
+    controllerTags: [...getControllerTags(controller)],
+    returnType: getReturnTypeInfo(method),
+    parameters: extractParameters(method, options),
+    decorators: [...extractDecoratorNames(method)],
+    operation: extractApiOperationMetadata(method),
+    responses: [...extractApiResponses(method)],
+    httpCode: extractHttpCode(method),
+    consumes: [...extractApiConsumes(method)],
+    produces: [...extractApiProduces(method)],
+    security: [...security]
+  });
+};
+const getControllerMethodInfos = (controller, options = {}) => controller.getMethods().map((method) => getMethodInfo(controller, method, options)).filter(Option.isSome).map((opt) => opt.value);
+
+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 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 properties = {};
+  const required = [];
+  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());
+      }
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  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);
+    }
+  }
+  return { properties, required };
+};
+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 };
+      }
+      return schema;
+    }
+  }
+  if (trimmed.includes(" | ")) {
+    const types = trimmed.split(" | ").map((t) => t.trim());
+    return {
+      oneOf: types.map((type) => tsTypeToOpenApiSchema(type))
+    };
+  }
+  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":
+      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-Z][a-zA-Z0-9]*(<[^>]+>)?$/)) {
+    return { $ref: `#/components/schemas/${trimmed}` };
+  }
+  return { type: "object" };
+};
+const getParameterLocation = (location) => {
+  switch (location) {
+    case "path":
+      return "path";
+    case "header":
+      return "header";
+    case "cookie":
+      return "cookie";
+    default:
+      return "query";
+  }
+};
+const transformParameter = (param) => {
+  const baseSchema = tsTypeToOpenApiSchema(param.tsType);
+  const schema = param.constraints ? { ...baseSchema, ...param.constraints } : baseSchema;
+  return {
+    name: param.name,
+    in: getParameterLocation(param.location),
+    description: Option.getOrElse(
+      param.description,
+      () => `${param.location} parameter: ${param.name}`
+    ),
+    required: param.location === "path" ? true : param.required,
+    schema
+  };
+};
+const buildResponseSchema = (returnType) => {
+  if (Option.isSome(returnType.container) && returnType.container.value === "array") {
+    if (Option.isSome(returnType.inline)) {
+      return {
+        type: "array",
+        items: tsTypeToOpenApiSchema(returnType.inline.value)
+      };
+    }
+    return {
+      type: "array",
+      items: Option.isSome(returnType.type) ? tsTypeToOpenApiSchema(returnType.type.value) : { type: "object" }
+    };
+  }
+  if (Option.isSome(returnType.type)) {
+    return tsTypeToOpenApiSchema(returnType.type.value);
+  }
+  if (Option.isSome(returnType.inline)) {
+    return tsTypeToOpenApiSchema(returnType.inline.value);
+  }
+  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 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) };
+};
+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
+  );
+  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 buildOpenApiPath = (path) => path.replace(/:([^/]+)/g, "{$1}") || "/";
+const transformMethod = (methodInfo) => {
+  const path = buildOpenApiPath(methodInfo.path);
+  const method = methodInfo.httpMethod.toLowerCase();
+  const bodyParams = methodInfo.parameters.filter((p) => p.location === "body");
+  const nonBodyParams = methodInfo.parameters.filter(
+    (p) => p.location !== "body"
+  );
+  const parameters = nonBodyParams.map(transformParameter);
+  const requestContentTypes = getRequestContentTypes(methodInfo);
+  const requestBody = bodyParams.length > 0 ? {
+    description: `Request body parameter: ${bodyParams[0].name}`,
+    required: bodyParams[0].required,
+    content: buildContentObject(
+      requestContentTypes,
+      tsTypeToOpenApiSchema(bodyParams[0].tsType)
+    )
+  } : void 0;
+  const operationId = Option.getOrElse(
+    methodInfo.operation.operationId,
+    () => `${methodInfo.controllerName}_${methodInfo.methodName}`
+  );
+  const summary = Option.getOrUndefined(methodInfo.operation.summary);
+  const description = Option.getOrUndefined(methodInfo.operation.description);
+  const deprecated = Option.getOrUndefined(methodInfo.operation.deprecated);
+  const security = buildSecurityRequirements(methodInfo.security);
+  const operation = {
+    operationId,
+    // Always include parameters array (even if empty) to match NestJS Swagger
+    parameters,
+    ...requestBody ? { requestBody } : {},
+    responses: buildResponses(methodInfo),
+    ...summary !== void 0 ? { summary } : {},
+    ...description !== void 0 ? { description } : {},
+    ...deprecated !== void 0 ? { deprecated } : {},
+    tags: methodInfo.controllerTags.length > 0 ? [...methodInfo.controllerTags] : void 0,
+    ...security !== void 0 ? { security } : {}
+  };
+  return {
+    [path]: {
+      [method]: operation
+    }
+  };
+};
+const transformMethods = (methodInfos) => methodInfos.reduce((acc, methodInfo) => {
+  const endpoint = transformMethod(methodInfo);
+  for (const path in endpoint) {
+    if (!acc[path]) acc[path] = {};
+    Object.assign(acc[path], endpoint[path]);
+  }
+  return acc;
+}, {});
+
+export { extractClassConstraints as A, getRequiredProperties as B, ConfigNotFoundError as C, mergeValidationConstraints as D, EntryNotFoundError as E, InvalidMethodError as I, ProjectInitError as P, ConfigLoadError as a, ConfigValidationError as b, getAllControllers as c, getControllerPrefix as d, getControllerName as e, getHttpMethods as f, getModules as g, getDecoratorName$1 as h, isHttpMethod as i, getControllerTags as j, getHttpDecorator as k, isHttpDecorator as l, getMethodInfo as m, normalizePath as n, getControllerMethodInfos as o, transformMethods as p, getArrayInitializer as q, resolveClassFromSymbol as r, getStringLiteralValue as s, transformMethod as t, getSymbolFromIdentifier as u, isModuleClass as v, getModuleDecoratorArg as w, resolveClassFromExpression as x, resolveArrayOfClasses as y, getModuleMetadata as z };