@buenojs/bueno 0.8.4 → 0.8.6

package/dist/openapi/index.js

@@ -0,0 +1,795 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/openapi/metadata.ts
+var exports_metadata = {};
+__export(exports_metadata, {
+  setApiPropertyMetadata: () => setApiPropertyMetadata,
+  setApiMethodMetadata: () => setApiMethodMetadata,
+  setApiMetadata: () => setApiMetadata,
+  getApiPropertyMetadata: () => getApiPropertyMetadata,
+  getApiPropertyKeys: () => getApiPropertyKeys,
+  getApiMethodMetadata: () => getApiMethodMetadata,
+  getApiMetadata: () => getApiMetadata
+});
+function setApiMetadata(target, key, value) {
+  if (!classMetadataStore.has(target)) {
+    classMetadataStore.set(target, new Map);
+  }
+  classMetadataStore.get(target)?.set(key, value);
+}
+function getApiMetadata(target, key) {
+  return classMetadataStore.get(target)?.get(key);
+}
+function setApiMethodMetadata(target, key, value) {
+  if (!methodMetadataStore.has(target)) {
+    methodMetadataStore.set(target, new Map);
+  }
+  methodMetadataStore.get(target)?.set(key, value);
+}
+function getApiMethodMetadata(target, key) {
+  return methodMetadataStore.get(target)?.get(key);
+}
+function setApiPropertyMetadata(target, propertyKey, value) {
+  if (!propertyMetadataStore.has(target)) {
+    propertyMetadataStore.set(target, new Map);
+  }
+  const key = typeof propertyKey === "symbol" ? propertyKey.toString() : propertyKey;
+  propertyMetadataStore.get(target)?.set(key, value);
+}
+function getApiPropertyMetadata(target, propertyKey) {
+  const key = typeof propertyKey === "symbol" ? propertyKey.toString() : propertyKey;
+  return propertyMetadataStore.get(target)?.get(key);
+}
+function getApiPropertyKeys(target) {
+  const metaMap = propertyMetadataStore.get(target);
+  if (!metaMap)
+    return [];
+  return Array.from(metaMap.keys());
+}
+var classMetadataStore, methodMetadataStore, propertyMetadataStore;
+var init_metadata = __esm(() => {
+  classMetadataStore = new WeakMap;
+  methodMetadataStore = new WeakMap;
+  propertyMetadataStore = new WeakMap;
+});
+
+// src/openapi/document-builder.ts
+class DocumentBuilder {
+  document = {
+    openapi: "3.1.0",
+    info: {
+      title: "API",
+      version: "1.0.0"
+    },
+    paths: {},
+    components: {
+      schemas: {},
+      securitySchemes: {}
+    },
+    tags: []
+  };
+  setTitle(title) {
+    if (!this.document.info) {
+      this.document.info = { title, version: "1.0.0" };
+    } else {
+      this.document.info.title = title;
+    }
+    return this;
+  }
+  setDescription(description) {
+    if (!this.document.info) {
+      this.document.info = { title: "API", version: "1.0.0", description };
+    } else {
+      this.document.info.description = description;
+    }
+    return this;
+  }
+  setVersion(version) {
+    if (!this.document.info) {
+      this.document.info = { title: "API", version };
+    } else {
+      this.document.info.version = version;
+    }
+    return this;
+  }
+  setContact(name, url, email) {
+    if (!this.document.info) {
+      this.document.info = { title: "API", version: "1.0.0" };
+    }
+    this.document.info.contact = { name, url, email };
+    return this;
+  }
+  setLicense(name, url) {
+    if (!this.document.info) {
+      this.document.info = { title: "API", version: "1.0.0" };
+    }
+    this.document.info.license = { name, url };
+    return this;
+  }
+  addServer(url, description) {
+    if (!this.document.servers) {
+      this.document.servers = [];
+    }
+    this.document.servers.push({ url, description });
+    return this;
+  }
+  addBearerAuth(name = "bearer", options) {
+    if (!this.document.components) {
+      this.document.components = { schemas: {}, securitySchemes: {} };
+    }
+    if (!this.document.components.securitySchemes) {
+      this.document.components.securitySchemes = {};
+    }
+    const scheme = {
+      type: "http",
+      scheme: "bearer",
+      bearerFormat: options?.bearerFormat ?? "JWT"
+    };
+    if (options?.description) {
+      scheme.description = options.description;
+    }
+    this.document.components.securitySchemes[name] = scheme;
+    return this;
+  }
+  addBasicAuth(name = "basic", options) {
+    if (!this.document.components) {
+      this.document.components = { schemas: {}, securitySchemes: {} };
+    }
+    if (!this.document.components.securitySchemes) {
+      this.document.components.securitySchemes = {};
+    }
+    const scheme = {
+      type: "http",
+      scheme: "basic"
+    };
+    if (options?.description) {
+      scheme.description = options.description;
+    }
+    this.document.components.securitySchemes[name] = scheme;
+    return this;
+  }
+  addApiKey(options, name = "api_key") {
+    if (!this.document.components) {
+      this.document.components = { schemas: {}, securitySchemes: {} };
+    }
+    if (!this.document.components.securitySchemes) {
+      this.document.components.securitySchemes = {};
+    }
+    const scheme = {
+      type: "apiKey",
+      name: options.name,
+      in: options.in
+    };
+    if (options.description) {
+      scheme.description = options.description;
+    }
+    this.document.components.securitySchemes[name] = scheme;
+    return this;
+  }
+  addOAuth2(name, authorizationUrl, tokenUrl, refreshUrl) {
+    if (!this.document.components) {
+      this.document.components = { schemas: {}, securitySchemes: {} };
+    }
+    if (!this.document.components.securitySchemes) {
+      this.document.components.securitySchemes = {};
+    }
+    this.document.components.securitySchemes[name] = {
+      type: "oauth2",
+      flows: {
+        authorizationCode: {
+          authorizationUrl,
+          tokenUrl: tokenUrl || "",
+          refreshUrl,
+          scopes: {}
+        }
+      }
+    };
+    return this;
+  }
+  addOpenIdConnect(name, url) {
+    if (!this.document.components) {
+      this.document.components = { schemas: {}, securitySchemes: {} };
+    }
+    if (!this.document.components.securitySchemes) {
+      this.document.components.securitySchemes = {};
+    }
+    this.document.components.securitySchemes[name] = {
+      type: "openIdConnect",
+      openIdConnectUrl: url
+    };
+    return this;
+  }
+  addTag(name, description) {
+    if (!this.document.tags) {
+      this.document.tags = [];
+    }
+    const tag = { name };
+    if (description) {
+      tag.description = description;
+    }
+    this.document.tags.push(tag);
+    return this;
+  }
+  build() {
+    return this.document;
+  }
+}
+// src/openapi/schema-generator.ts
+init_metadata();
+
+class SchemaGenerator {
+  schemas = new Map;
+  typeNames = new Map;
+  typeCounter = 0;
+  generateSchema(type) {
+    if (typeof type === "string") {
+      return this.generatePrimitiveSchema(type);
+    }
+    if (typeof type === "function") {
+      const typeName = this.getTypeName(type);
+      if (this.schemas.has(typeName)) {
+        return { $ref: `#/components/schemas/${typeName}` };
+      }
+      if (this.isBuiltInType(type)) {
+        return this.generatePrimitiveSchema(type);
+      }
+      if (type === Array) {
+        return { type: "array", items: { type: "object" } };
+      }
+      return this.generateObjectSchema(type);
+    }
+    return { type: "object" };
+  }
+  generateObjectSchema(type) {
+    const typeName = this.getTypeName(type);
+    const properties = {};
+    const required = [];
+    const propertyKeys = getApiPropertyKeys(type.prototype);
+    for (const key of propertyKeys) {
+      const propName = typeof key === "symbol" ? key.toString() : key;
+      const propOptions = getApiPropertyMetadata(type.prototype, key);
+      if (propOptions) {
+        properties[propName] = this.generatePropertySchema(propOptions);
+        if (propOptions.required !== false) {
+          required.push(propName);
+        }
+      }
+    }
+    const schema = {
+      type: "object",
+      properties: Object.keys(properties).length > 0 ? properties : undefined,
+      required: required.length > 0 ? required : undefined
+    };
+    this.schemas.set(typeName, schema);
+    return { $ref: `#/components/schemas/${typeName}` };
+  }
+  generatePropertySchema(options) {
+    const schema = {};
+    if (options.type) {
+      if (typeof options.type === "string") {
+        const typeSchema = this.mapStringType(options.type);
+        Object.assign(schema, typeSchema);
+      } else if (typeof options.type === "function") {
+        const nested = this.generateSchema(options.type);
+        Object.assign(schema, nested);
+      }
+    }
+    if (options.minLength !== undefined)
+      schema.minLength = options.minLength;
+    if (options.maxLength !== undefined)
+      schema.maxLength = options.maxLength;
+    if (options.pattern !== undefined)
+      schema.pattern = options.pattern;
+    if (options.minimum !== undefined)
+      schema.minimum = options.minimum;
+    if (options.maximum !== undefined)
+      schema.maximum = options.maximum;
+    if (options.minItems !== undefined)
+      schema.minItems = options.minItems;
+    if (options.maxItems !== undefined)
+      schema.maxItems = options.maxItems;
+    if (options.items !== undefined)
+      schema.items = options.items;
+    if (options.enum !== undefined) {
+      schema.enum = options.enum;
+    }
+    if (options.format !== undefined)
+      schema.format = options.format;
+    if (options.title !== undefined)
+      schema.title = options.title;
+    if (options.description !== undefined)
+      schema.description = options.description;
+    if (options.example !== undefined)
+      schema.example = options.example;
+    if (options.default !== undefined)
+      schema.default = options.default;
+    if (options.nullable !== undefined)
+      schema.nullable = options.nullable;
+    if (options.readOnly !== undefined)
+      schema.readOnly = options.readOnly;
+    if (options.writeOnly !== undefined)
+      schema.writeOnly = options.writeOnly;
+    return schema;
+  }
+  generatePrimitiveSchema(type) {
+    if (typeof type === "string") {
+      return this.mapStringType(type);
+    }
+    if (type === String)
+      return { type: "string" };
+    if (type === Number)
+      return { type: "number" };
+    if (type === Boolean)
+      return { type: "boolean" };
+    if (type === Date)
+      return { type: "string", format: "date-time" };
+    if (type === Array)
+      return { type: "array", items: {} };
+    return { type: "object" };
+  }
+  mapStringType(type) {
+    switch (type.toLowerCase()) {
+      case "string":
+        return { type: "string" };
+      case "number":
+        return { type: "number" };
+      case "integer":
+        return { type: "integer" };
+      case "boolean":
+        return { type: "boolean" };
+      case "date":
+        return { type: "string", format: "date" };
+      case "datetime":
+      case "date-time":
+        return { type: "string", format: "date-time" };
+      case "email":
+        return { type: "string", format: "email" };
+      case "uuid":
+        return { type: "string", format: "uuid" };
+      case "url":
+      case "uri":
+        return { type: "string", format: "uri" };
+      case "object":
+        return { type: "object" };
+      case "array":
+        return { type: "array", items: {} };
+      default:
+        return { type: "string" };
+    }
+  }
+  isBuiltInType(type) {
+    return type === String || type === Number || type === Boolean || type === Date || type === Array || type === Object;
+  }
+  getTypeName(type) {
+    if (this.typeNames.has(type)) {
+      return this.typeNames.get(type);
+    }
+    let name = type.name;
+    if (!name || name === "Object" || name === "Function") {
+      name = `Schema_${++this.typeCounter}`;
+    }
+    this.typeNames.set(type, name);
+    return name;
+  }
+  getSchemas() {
+    const result = {};
+    for (const [name, schema] of this.schemas) {
+      result[name] = schema;
+    }
+    return result;
+  }
+  clear() {
+    this.schemas.clear();
+    this.typeNames.clear();
+    this.typeCounter = 0;
+  }
+}
+// src/openapi/route-scanner.ts
+init_metadata();
+
+// src/modules/metadata.ts
+var metadataStore = new WeakMap;
+function setMetadata(target, key, value) {
+  if (!metadataStore.has(target)) {
+    metadataStore.set(target, new Map);
+  }
+  metadataStore.get(target)?.set(key, value);
+}
+function getMetadata(target, key) {
+  return metadataStore.get(target)?.get(key);
+}
+var prototypeMetadataStore = new WeakMap;
+function setPrototypeMetadata(target, key, value) {
+  if (!prototypeMetadataStore.has(target)) {
+    prototypeMetadataStore.set(target, new Map);
+  }
+  prototypeMetadataStore.get(target)?.set(key, value);
+}
+function getPrototypeMetadata(target, key) {
+  return prototypeMetadataStore.get(target)?.get(key);
+}
+function Injectable() {
+  return (target) => {
+    setMetadata(target, "injectable", true);
+    return target;
+  };
+}
+function Controller(path = "") {
+  return (target) => {
+    setMetadata(target, "controller", true);
+    setMetadata(target, "path", path);
+    return target;
+  };
+}
+function Module(metadata) {
+  return (target) => {
+    setMetadata(target, "module", metadata);
+    return target;
+  };
+}
+
+// src/openapi/route-scanner.ts
+class RouteScanner {
+  schemaGenerator;
+  constructor(schemaGenerator) {
+    this.schemaGenerator = schemaGenerator;
+  }
+  scanControllers(controllers) {
+    const paths = {};
+    for (const controller of controllers) {
+      if (getApiMetadata(controller, "api:exclude")) {
+        continue;
+      }
+      const basePath = getMetadata(controller, "path") ?? "";
+      const routes = getPrototypeMetadata(controller.prototype, "routes") ?? [];
+      const classLevelTags = getApiMetadata(controller, "api:tags") ?? [];
+      const classLevelSecurity = getApiMetadata(controller, "api:security") ?? [];
+      for (const route of routes) {
+        const prototype = controller.prototype;
+        const handlerKey = route.handler;
+        if (getApiMethodMetadata(prototype, `api:exclude:${String(handlerKey)}`)) {
+          continue;
+        }
+        const fullPath = this.convertPathToOpenAPI(basePath + route.path);
+        if (!paths[fullPath]) {
+          paths[fullPath] = {};
+        }
+        const operation = this.generateOperation(controller, route, classLevelTags, classLevelSecurity, basePath);
+        paths[fullPath][route.method.toLowerCase()] = operation;
+      }
+    }
+    return paths;
+  }
+  generateOperation(controller, route, classLevelTags, classLevelSecurity, basePath) {
+    const prototype = controller.prototype;
+    const handlerKey = String(route.handler);
+    const getMethodMeta = (key) => getApiMethodMetadata(prototype, `${key}:${handlerKey}`);
+    const operationMeta = getMethodMeta("api:operation");
+    const responseMeta = getMethodMeta("api:responses") ?? [];
+    const paramMeta = getMethodMeta("api:params") ?? [];
+    const queryMeta = getMethodMeta("api:query") ?? [];
+    const headerMeta = getMethodMeta("api:headers") ?? [];
+    const bodyMeta = getMethodMeta("api:body");
+    const methodLevelTags = getMethodMeta("api:tags") ?? [];
+    const methodLevelSecurity = getMethodMeta("api:security") ?? [];
+    const parameters = [
+      ...paramMeta.map((p) => ({
+        name: p.name,
+        in: "path",
+        description: p.description,
+        required: p.required ?? true,
+        example: p.example,
+        schema: p.schema
+      })),
+      ...queryMeta.map((q) => ({
+        name: q.name,
+        in: "query",
+        description: q.description,
+        required: q.required ?? false,
+        example: q.example,
+        schema: q.schema
+      })),
+      ...headerMeta.map((h) => ({
+        name: h.name,
+        in: "header",
+        description: h.description,
+        required: h.required,
+        schema: h.schema
+      }))
+    ];
+    const responses = {};
+    for (const resp of responseMeta) {
+      const statusCode = String(resp.status);
+      const response = { description: resp.description };
+      if (resp.type || resp.schema) {
+        let schema = resp.schema ?? {};
+        if (resp.type) {
+          if (Array.isArray(resp.type)) {
+            const itemSchema = this.schemaGenerator.generateSchema(resp.type[0]);
+            schema = { type: "array", items: itemSchema };
+          } else {
+            schema = this.schemaGenerator.generateSchema(resp.type);
+          }
+        }
+        const mediaType = { schema };
+        response.content = { "application/json": mediaType };
+      }
+      responses[statusCode] = response;
+    }
+    if (Object.keys(responses).length === 0) {
+      responses["200"] = { description: "Success" };
+    }
+    const requestBody = bodyMeta ? {
+      description: bodyMeta.description,
+      required: bodyMeta.required ?? true,
+      content: {
+        "application/json": {
+          schema: bodyMeta.schema ?? (bodyMeta.type ? this.schemaGenerator.generateSchema(bodyMeta.type) : { type: "object" })
+        }
+      }
+    } : undefined;
+    const tags = [...new Set([...classLevelTags, ...methodLevelTags])];
+    const security = [...classLevelSecurity, ...methodLevelSecurity];
+    const operation = {
+      operationId: operationMeta?.operationId ?? `${route.method.toLowerCase()}_${basePath.replace(/\//g, "_")}_${handlerKey}`,
+      summary: operationMeta?.summary,
+      description: operationMeta?.description,
+      tags: tags.length > 0 ? tags : undefined,
+      parameters: parameters.length > 0 ? parameters : undefined,
+      requestBody,
+      responses,
+      deprecated: operationMeta?.deprecated,
+      security: security.length > 0 ? security : undefined
+    };
+    return operation;
+  }
+  convertPathToOpenAPI(pattern) {
+    return pattern.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)\??(?:<[^>]+>)?/g, "{$1}");
+  }
+  getSchemaGenerator() {
+    return this.schemaGenerator;
+  }
+}
+// src/openapi/swagger-module.ts
+class SwaggerModule {
+  static createDocument(app, config, controllers) {
+    const schemaGenerator = new SchemaGenerator;
+    const scanner = new RouteScanner(schemaGenerator);
+    const paths = scanner.scanControllers(controllers);
+    const schemas = schemaGenerator.getSchemas();
+    return {
+      ...config,
+      paths: {
+        ...config.paths,
+        ...paths
+      },
+      components: {
+        ...config.components,
+        schemas: {
+          ...config.components?.schemas ?? {},
+          ...schemas
+        }
+      }
+    };
+  }
+  static setup(path, app, document, options) {
+    app.router.get(`${path}-json`, (ctx) => {
+      return ctx.json(document);
+    });
+    app.router.get(path, (ctx) => {
+      const html = this.generateSwaggerUI(path, document, options);
+      return ctx.html(html);
+    });
+  }
+  static generateSwaggerUI(jsonPath, document, options) {
+    const title = options?.title ?? "API Documentation";
+    const customCss = options?.customCss ?? "";
+    const customSiteTitle = options?.customSiteTitle ?? title;
+    const favicon = options?.customfavIcon ?? "";
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${customSiteTitle}</title>
+  <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css">
+  <style>
+    html {
+      box-sizing: border-box;
+      overflow: -moz-scrollbars-vertical;
+      overflow-y: scroll;
+    }
+    *, *:before, *:after {
+      box-sizing: inherit;
+    }
+    body {
+      margin: 0;
+      padding: 0;
+      font-family: sans-serif;
+    }
+    ${customCss}
+  </style>
+  ${favicon ? `<link rel="icon" href="${favicon}">` : ""}
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+  <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-standalone-preset.js"></script>
+  <script>
+    window.onload = function() {
+      SwaggerUIBundle({
+        url: '${jsonPath}-json',
+        dom_id: '#swagger-ui',
+        deepLinking: true,
+        presets: [
+          SwaggerUIBundle.presets.apis,
+          SwaggerUIStandalonePreset
+        ],
+        plugins: [
+          SwaggerUIBundle.plugins.DownloadUrl
+        ],
+        layout: 'StandaloneLayout',
+        defaultModelsExpandDepth: 1,
+        defaultModelExpandDepth: 1,
+      });
+    };
+  </script>
+</body>
+</html>`;
+  }
+}
+// src/openapi/decorators.ts
+init_metadata();
+function ApiTags(...tags) {
+  return (target) => {
+    const existingTags = getApiMetadata(target, "api:tags") ?? [];
+    const combined = [...new Set([...existingTags, ...tags])];
+    setApiMetadata(target, "api:tags", combined);
+    return target;
+  };
+}
+function ApiBearerAuth(name = "bearer", options) {
+  return function(target, propertyKey) {
+    const security = [{ [name]: [] }];
+    const targetObj = propertyKey ? target : target;
+    const store = propertyKey ? getApiMethodMetadata : getApiMetadata;
+    const setSt = propertyKey ? setApiMethodMetadata : setApiMetadata;
+    const existingSecurity = store(targetObj, "api:security") ?? [];
+    setSt(targetObj, "api:security", [...existingSecurity, ...security]);
+    return propertyKey ? descriptor : target;
+  };
+}
+function ApiBasicAuth(name = "basic") {
+  return function(target, propertyKey) {
+    const security = [{ [name]: [] }];
+    const targetObj = propertyKey ? target : target;
+    const store = propertyKey ? getApiMethodMetadata : getApiMetadata;
+    const setSt = propertyKey ? setApiMethodMetadata : setApiMetadata;
+    const existingSecurity = store(targetObj, "api:security") ?? [];
+    setSt(targetObj, "api:security", [...existingSecurity, ...security]);
+    return propertyKey ? descriptor : target;
+  };
+}
+function ApiApiKey(options, name = "api_key") {
+  return function(target, propertyKey) {
+    const security = [{ [name]: [] }];
+    const targetObj = propertyKey ? target : target;
+    const store = propertyKey ? getApiMethodMetadata : getApiMetadata;
+    const setSt = propertyKey ? setApiMethodMetadata : setApiMetadata;
+    const existingSecurity = store(targetObj, "api:security") ?? [];
+    setSt(targetObj, `api:security:scheme:${name}`, options);
+    setSt(targetObj, "api:security", [...existingSecurity, ...security]);
+    return propertyKey ? descriptor : target;
+  };
+}
+function ApiExcludeController() {
+  return (target) => {
+    setApiMetadata(target, "api:exclude", true);
+    return target;
+  };
+}
+function ApiOperation(options) {
+  return (target, propertyKey) => {
+    setApiMethodMetadata(target, `api:operation:${String(propertyKey)}`, options);
+  };
+}
+function ApiResponse(options) {
+  return (target, propertyKey) => {
+    const key = `api:responses:${String(propertyKey)}`;
+    const existing = getApiMethodMetadata(target, key) ?? [];
+    existing.push(options);
+    setApiMethodMetadata(target, key, existing);
+  };
+}
+function ApiParam(options) {
+  return (target, propertyKey) => {
+    const key = `api:params:${String(propertyKey)}`;
+    const existing = getApiMethodMetadata(target, key) ?? [];
+    existing.push(options);
+    setApiMethodMetadata(target, key, existing);
+  };
+}
+function ApiQuery(options) {
+  return (target, propertyKey) => {
+    const key = `api:query:${String(propertyKey)}`;
+    const existing = getApiMethodMetadata(target, key) ?? [];
+    existing.push(options);
+    setApiMethodMetadata(target, key, existing);
+  };
+}
+function ApiHeader(options) {
+  return (target, propertyKey) => {
+    const key = `api:headers:${String(propertyKey)}`;
+    const existing = getApiMethodMetadata(target, key) ?? [];
+    existing.push(options);
+    setApiMethodMetadata(target, key, existing);
+  };
+}
+function ApiBody(options) {
+  return (target, propertyKey) => {
+    setApiMethodMetadata(target, `api:body:${String(propertyKey)}`, options);
+  };
+}
+function ApiExcludeEndpoint() {
+  return (target, propertyKey) => {
+    setApiMethodMetadata(target, `api:exclude:${String(propertyKey)}`, true);
+  };
+}
+function ApiProperty(options) {
+  return (target, propertyKey) => {
+    const opts = { ...options, required: options?.required !== false };
+    setApiPropertyMetadata(target, propertyKey, opts);
+  };
+}
+function ApiPropertyOptional(options) {
+  return (target, propertyKey) => {
+    const opts = { ...options, required: false };
+    setApiPropertyMetadata(target, propertyKey, opts);
+  };
+}
+export {
+  SwaggerModule,
+  SchemaGenerator,
+  RouteScanner,
+  DocumentBuilder,
+  ApiTags,
+  ApiResponse,
+  ApiQuery,
+  ApiPropertyOptional,
+  ApiProperty,
+  ApiParam,
+  ApiOperation,
+  ApiHeader,
+  ApiExcludeEndpoint,
+  ApiExcludeController,
+  ApiBody,
+  ApiBearerAuth,
+  ApiBasicAuth,
+  ApiApiKey
+};