nestjs-openapi 0.1.3 → 0.2.0

package/dist/shared/nestjs-openapi.D0Osp4GW.d.mts

@@ -0,0 +1,2275 @@
+import { Schema, Effect, Option, Layer } from 'effect';
+import { ClassDeclaration, MethodDeclaration, PropertyDeclaration, Project, SourceFile } from 'ts-morph';
+
+declare const ProjectInitError_base: Schema.TaggedErrorClass<ProjectInitError, "ProjectInitError", {
+    readonly _tag: Schema.tag<"ProjectInitError">;
+} & {
+    tsconfig: typeof Schema.String;
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Unknown>;
+}>;
+declare class ProjectInitError extends ProjectInitError_base {
+    static create(tsconfig: string, cause?: unknown): ProjectInitError;
+}
+declare const EntryNotFoundError_base: Schema.TaggedErrorClass<EntryNotFoundError, "EntryNotFoundError", {
+    readonly _tag: Schema.tag<"EntryNotFoundError">;
+} & {
+    entry: typeof Schema.String;
+    className: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+declare class EntryNotFoundError extends EntryNotFoundError_base {
+    static fileNotFound(entry: string): EntryNotFoundError;
+    static classNotFound(entry: string, className: string): EntryNotFoundError;
+}
+type ProjectError = ProjectInitError | EntryNotFoundError;
+declare const ConfigNotFoundError_base: Schema.TaggedErrorClass<ConfigNotFoundError, "ConfigNotFoundError", {
+    readonly _tag: Schema.tag<"ConfigNotFoundError">;
+} & {
+    path: Schema.optional<typeof Schema.String>;
+    searchDir: Schema.optional<typeof Schema.String>;
+    message: typeof Schema.String;
+}>;
+declare class ConfigNotFoundError extends ConfigNotFoundError_base {
+    static notFound(searchDir: string): ConfigNotFoundError;
+    static pathNotFound(path: string): ConfigNotFoundError;
+}
+declare const ConfigLoadError_base: Schema.TaggedErrorClass<ConfigLoadError, "ConfigLoadError", {
+    readonly _tag: Schema.tag<"ConfigLoadError">;
+} & {
+    path: typeof Schema.String;
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Unknown>;
+}>;
+declare class ConfigLoadError extends ConfigLoadError_base {
+    static importFailed(path: string, cause?: unknown): ConfigLoadError;
+    static noExport(path: string): ConfigLoadError;
+    static circularExtends(path: string): ConfigLoadError;
+}
+declare const ConfigValidationError_base: Schema.TaggedErrorClass<ConfigValidationError, "ConfigValidationError", {
+    readonly _tag: Schema.tag<"ConfigValidationError">;
+} & {
+    path: typeof Schema.String;
+    message: typeof Schema.String;
+    issues: Schema.Array$<typeof Schema.String>;
+}>;
+declare class ConfigValidationError extends ConfigValidationError_base {
+    static fromIssues(path: string, issues: readonly string[]): ConfigValidationError;
+}
+type ConfigError = ConfigNotFoundError | ConfigLoadError | ConfigValidationError;
+declare const InvalidMethodError_base: Schema.TaggedErrorClass<InvalidMethodError, "InvalidMethodError", {
+    readonly _tag: Schema.tag<"InvalidMethodError">;
+} & {
+    controllerName: typeof Schema.String;
+    methodName: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+declare class InvalidMethodError extends InvalidMethodError_base {
+    static create(controllerName: string, methodName: string, reason: string): InvalidMethodError;
+}
+type AnalysisError = InvalidMethodError;
+declare const SchemaGenerationError_base: Schema.TaggedErrorClass<SchemaGenerationError, "SchemaGenerationError", {
+    readonly _tag: Schema.tag<"SchemaGenerationError">;
+} & {
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Unknown>;
+}>;
+declare class SchemaGenerationError extends SchemaGenerationError_base {
+    static fromError(error: unknown, context?: string): SchemaGenerationError;
+    static noFilesFound(patterns: readonly string[]): SchemaGenerationError;
+}
+declare const ValidationMappingError_base: Schema.TaggedErrorClass<ValidationMappingError, "ValidationMappingError", {
+    readonly _tag: Schema.tag<"ValidationMappingError">;
+} & {
+    className: typeof Schema.String;
+    filePath: typeof Schema.String;
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Unknown>;
+}>;
+declare class ValidationMappingError extends ValidationMappingError_base {
+    static create(className: string, filePath: string, cause?: unknown): ValidationMappingError;
+}
+declare const MissingGenericSchemaTempFileWriteError_base: Schema.TaggedErrorClass<MissingGenericSchemaTempFileWriteError, "MissingGenericSchemaTempFileWriteError", {
+    readonly _tag: Schema.tag<"MissingGenericSchemaTempFileWriteError">;
+} & {
+    filePath: typeof Schema.String;
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Unknown>;
+}>;
+declare class MissingGenericSchemaTempFileWriteError extends MissingGenericSchemaTempFileWriteError_base {
+    static create(filePath: string, cause?: unknown): MissingGenericSchemaTempFileWriteError;
+}
+declare const MissingGenericSchemaTempFileCleanupError_base: Schema.TaggedErrorClass<MissingGenericSchemaTempFileCleanupError, "MissingGenericSchemaTempFileCleanupError", {
+    readonly _tag: Schema.tag<"MissingGenericSchemaTempFileCleanupError">;
+} & {
+    filePath: typeof Schema.String;
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Unknown>;
+}>;
+declare class MissingGenericSchemaTempFileCleanupError extends MissingGenericSchemaTempFileCleanupError_base {
+    static create(filePath: string, cause?: unknown): MissingGenericSchemaTempFileCleanupError;
+}
+declare const DtoGlobResolutionError_base: Schema.TaggedErrorClass<DtoGlobResolutionError, "DtoGlobResolutionError", {
+    readonly _tag: Schema.tag<"DtoGlobResolutionError">;
+} & {
+    pattern: typeof Schema.String;
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Unknown>;
+}>;
+declare class DtoGlobResolutionError extends DtoGlobResolutionError_base {
+    static create(pattern: string, cause?: unknown): DtoGlobResolutionError;
+}
+declare const PublicApiError_base: Schema.TaggedErrorClass<PublicApiError, "PublicApiError", {
+    readonly _tag: Schema.tag<"PublicApiError">;
+} & {
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Unknown>;
+}>;
+declare class PublicApiError extends PublicApiError_base {
+    static fromUnknown(cause: unknown): PublicApiError;
+}
+declare const SpecFileNotFoundError_base: Schema.TaggedErrorClass<SpecFileNotFoundError, "SpecFileNotFoundError", {
+    readonly _tag: Schema.tag<"SpecFileNotFoundError">;
+} & {
+    filePath: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+declare class SpecFileNotFoundError extends SpecFileNotFoundError_base {
+    static create(filePath: string): SpecFileNotFoundError;
+}
+declare const SpecFileReadError_base: Schema.TaggedErrorClass<SpecFileReadError, "SpecFileReadError", {
+    readonly _tag: Schema.tag<"SpecFileReadError">;
+} & {
+    filePath: typeof Schema.String;
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Unknown>;
+}>;
+declare class SpecFileReadError extends SpecFileReadError_base {
+    static create(filePath: string, cause?: unknown): SpecFileReadError;
+}
+declare const SpecFileParseError_base: Schema.TaggedErrorClass<SpecFileParseError, "SpecFileParseError", {
+    readonly _tag: Schema.tag<"SpecFileParseError">;
+} & {
+    filePath: typeof Schema.String;
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Unknown>;
+}>;
+declare class SpecFileParseError extends SpecFileParseError_base {
+    static create(filePath: string, cause?: unknown): SpecFileParseError;
+}
+declare const OutputDirectoryCreationError_base: Schema.TaggedErrorClass<OutputDirectoryCreationError, "OutputDirectoryCreationError", {
+    readonly _tag: Schema.tag<"OutputDirectoryCreationError">;
+} & {
+    outputDir: typeof Schema.String;
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Unknown>;
+}>;
+declare class OutputDirectoryCreationError extends OutputDirectoryCreationError_base {
+    static create(outputDir: string, cause?: unknown): OutputDirectoryCreationError;
+}
+declare const OutputSerializationError_base: Schema.TaggedErrorClass<OutputSerializationError, "OutputSerializationError", {
+    readonly _tag: Schema.tag<"OutputSerializationError">;
+} & {
+    outputPath: typeof Schema.String;
+    format: Schema.Literal<["json", "yaml"]>;
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Unknown>;
+}>;
+declare class OutputSerializationError extends OutputSerializationError_base {
+    static json(outputPath: string, cause?: unknown): OutputSerializationError;
+    static yaml(outputPath: string, cause?: unknown): OutputSerializationError;
+}
+declare const OutputWriteError_base: Schema.TaggedErrorClass<OutputWriteError, "OutputWriteError", {
+    readonly _tag: Schema.tag<"OutputWriteError">;
+} & {
+    outputPath: typeof Schema.String;
+    format: Schema.Literal<["json", "yaml"]>;
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Unknown>;
+}>;
+declare class OutputWriteError extends OutputWriteError_base {
+    static json(outputPath: string, cause?: unknown): OutputWriteError;
+    static yaml(outputPath: string, cause?: unknown): OutputWriteError;
+}
+type GeneratorError = ProjectError | ConfigError | AnalysisError | SchemaGenerationError | ValidationMappingError | MissingGenericSchemaTempFileWriteError | MissingGenericSchemaTempFileCleanupError | DtoGlobResolutionError | PublicApiError | SpecFileNotFoundError | SpecFileReadError | SpecFileParseError | OutputDirectoryCreationError | OutputSerializationError | OutputWriteError;
+
+/**
+ * Public types for nestjs-openapi
+ *
+ * These types are exposed to consumers of the library. Internal types
+ * should be kept in domain.ts.
+ */
+/**
+ * Contact information for the API
+ */
+interface ContactConfig {
+    readonly name?: string;
+    readonly email?: string;
+    readonly url?: string;
+}
+/**
+ * License information for the API
+ */
+interface LicenseConfig {
+    readonly name: string;
+    readonly url?: string;
+}
+/**
+ * API metadata for the OpenAPI info section
+ */
+interface InfoConfig {
+    readonly title: string;
+    readonly version: string;
+    readonly description?: string;
+    readonly contact?: ContactConfig;
+    readonly license?: LicenseConfig;
+}
+/**
+ * Server configuration for the OpenAPI servers section
+ */
+interface ServerConfig {
+    readonly url: string;
+    readonly description?: string;
+}
+/**
+ * Tag configuration for organizing API endpoints
+ */
+interface TagConfig {
+    readonly name: string;
+    readonly description?: string;
+}
+/**
+ * Security scheme type for OpenAPI 3.0
+ */
+type SecuritySchemeType = 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+/**
+ * Location for apiKey security schemes
+ */
+type SecuritySchemeIn = 'query' | 'header' | 'cookie';
+/**
+ * OAuth2 flow configuration
+ */
+interface OAuth2FlowConfig {
+    readonly authorizationUrl?: string;
+    readonly tokenUrl?: string;
+    readonly refreshUrl?: string;
+    readonly scopes?: Record<string, string>;
+}
+/**
+ * OAuth2 flows configuration
+ */
+interface OAuth2FlowsConfig {
+    readonly implicit?: OAuth2FlowConfig;
+    readonly password?: OAuth2FlowConfig;
+    readonly clientCredentials?: OAuth2FlowConfig;
+    readonly authorizationCode?: OAuth2FlowConfig;
+}
+/**
+ * Security scheme configuration for OpenAPI 3.0
+ *
+ * @example
+ * ```typescript
+ * // Bearer token (JWT)
+ * {
+ *   name: 'bearerAuth',
+ *   type: 'http',
+ *   scheme: 'bearer',
+ *   bearerFormat: 'JWT',
+ * }
+ *
+ * // API Key in header
+ * {
+ *   name: 'apiKey',
+ *   type: 'apiKey',
+ *   in: 'header',
+ *   parameterName: 'X-API-Key',
+ * }
+ *
+ * // OAuth2
+ * {
+ *   name: 'oauth2',
+ *   type: 'oauth2',
+ *   flows: {
+ *     authorizationCode: {
+ *       authorizationUrl: 'https://example.com/oauth/authorize',
+ *       tokenUrl: 'https://example.com/oauth/token',
+ *       scopes: { 'read:users': 'Read user data' },
+ *     },
+ *   },
+ * }
+ * ```
+ */
+interface SecuritySchemeConfig {
+    /** Unique name for this security scheme (used as key in securitySchemes) */
+    readonly name: string;
+    /** The type of the security scheme */
+    readonly type: SecuritySchemeType;
+    /** Description of the security scheme */
+    readonly description?: string;
+    /** The name of the HTTP Authorization scheme (for type: 'http') */
+    readonly scheme?: string;
+    /** A hint for the format of the token (for type: 'http' with scheme: 'bearer') */
+    readonly bearerFormat?: string;
+    /** The location of the API key (for type: 'apiKey') */
+    readonly in?: SecuritySchemeIn;
+    /** The name of the header, query, or cookie parameter (for type: 'apiKey') */
+    readonly parameterName?: string;
+    /** OAuth2 flows configuration (for type: 'oauth2') */
+    readonly flows?: OAuth2FlowsConfig;
+    /** OpenID Connect URL to discover OAuth2 config (for type: 'openIdConnect') */
+    readonly openIdConnectUrl?: string;
+}
+/**
+ * Security requirement - maps security scheme names to required scopes
+ *
+ * @example
+ * ```typescript
+ * // Require bearerAuth with no specific scopes
+ * { bearerAuth: [] }
+ *
+ * // Require oauth2 with specific scopes
+ * { oauth2: ['read:users', 'write:users'] }
+ * ```
+ */
+type SecurityRequirement = Record<string, readonly string[]>;
+/**
+ * Output format for the generated OpenAPI specification
+ */
+type OutputFormat = 'json' | 'yaml';
+/**
+ * OpenAPI specification version
+ * - '3.0.3': OpenAPI 3.0.3 (default, widely supported)
+ * - '3.1.0': OpenAPI 3.1.0 (full JSON Schema 2020-12 alignment, type arrays for nullable)
+ * - '3.2.0': OpenAPI 3.2.0 (when released, will include webhooks and other new features)
+ */
+type OpenApiVersion = '3.0.3' | '3.1.0' | '3.2.0';
+/**
+ * Input file configuration for nestjs-openapi.
+ * All paths are relative to the config file location.
+ */
+interface FilesConfig {
+    /**
+     * Entry module file(s).
+     * @default "src/app.module.ts"
+     */
+    readonly entry?: string | readonly string[];
+    /**
+     * Path to tsconfig.json. Auto-detected if not specified.
+     */
+    readonly tsconfig?: string;
+    /**
+     * Glob pattern(s) for DTO files to generate schemas from.
+     * @example "src/**\/*.dto.ts"
+     */
+    readonly dtoGlob?: string | readonly string[];
+    /**
+     * Glob patterns to include.
+     */
+    readonly include?: readonly string[];
+    /**
+     * Glob patterns to exclude.
+     * @default ["**\/*.spec.ts", "**\/*.test.ts", "**\/node_modules/**"]
+     */
+    readonly exclude?: readonly string[];
+}
+/**
+ * Security configuration for OpenAPI spec.
+ */
+interface SecurityConfig {
+    /**
+     * Security schemes available for the API.
+     * Defines authentication methods (bearer, apiKey, oauth2, etc.)
+     */
+    readonly schemes?: readonly SecuritySchemeConfig[];
+    /**
+     * Global security requirements applied to all operations.
+     * Can be overridden at the operation level.
+     * Each object in the array represents an alternative (OR logic).
+     * Within each object, all schemes must be satisfied (AND logic).
+     *
+     * @example
+     * ```typescript
+     * // Require bearerAuth for all operations
+     * global: [{ bearerAuth: [] }]
+     *
+     * // Allow either bearerAuth OR apiKey
+     * global: [{ bearerAuth: [] }, { apiKey: [] }]
+     * ```
+     */
+    readonly global?: readonly SecurityRequirement[];
+}
+/**
+ * OpenAPI specification metadata configuration.
+ * Maps directly to the OpenAPI spec structure.
+ */
+interface OpenApiConfig {
+    /**
+     * OpenAPI specification version.
+     * @default "3.0.3"
+     */
+    readonly version?: OpenApiVersion;
+    /**
+     * API metadata for the info section.
+     * @required
+     */
+    readonly info: InfoConfig;
+    /**
+     * Server URLs for the API.
+     */
+    readonly servers?: readonly ServerConfig[];
+    /**
+     * Tags for organizing API endpoints.
+     */
+    readonly tags?: readonly TagConfig[];
+    /**
+     * Security configuration.
+     */
+    readonly security?: SecurityConfig;
+}
+/**
+ * Generation behavior options.
+ */
+interface OptionsConfig {
+    /**
+     * Base path prefix for all routes.
+     * Equivalent to NestJS's app.setGlobalPrefix().
+     * @example "/api/v1"
+     */
+    readonly basePath?: string;
+    /**
+     * Extract validation constraints from class-validator decorators.
+     * @default true
+     */
+    readonly extractValidation?: boolean;
+    /**
+     * Decorator names that exclude endpoints from the spec.
+     * @default ["ApiExcludeEndpoint", "ApiExcludeController"]
+     */
+    readonly excludeDecorators?: readonly string[];
+    /**
+     * Filter paths by regex or predicate function.
+     * Paths matching the regex (or returning true) are INCLUDED.
+     *
+     * @example
+     * ```typescript
+     * // Exclude internal and versioned paths
+     * pathFilter: /^(?!.*(\/internal\/|\/v[\d.]+\/)).* /
+     *
+     * // Using a function
+     * pathFilter: (path) => !path.includes('/internal/')
+     * ```
+     */
+    readonly pathFilter?: RegExp | ((path: string) => boolean);
+    /**
+     * Query parameter handling options.
+     */
+    readonly query?: QueryOptions;
+    /**
+     * Schema generation and normalization options.
+     */
+    readonly schemas?: SchemaOptions;
+}
+/**
+ * Schema generation and normalization options.
+ */
+interface SchemaOptions {
+    /**
+     * How to handle schema aliases that only redirect via `$ref`.
+     * - `"collapse"`: Rewrite refs to the final target schema and remove alias entries
+     * - `"preserve"`: Keep alias schemas as-is
+     *
+     * @default "collapse"
+     */
+    readonly aliasRefs?: 'collapse' | 'preserve';
+}
+/**
+ * Query parameter handling options.
+ */
+interface QueryOptions {
+    /**
+     * How to represent query object DTOs (e.g., `@Query() dto: PaginationDto`).
+     * - `"inline"` (default): Expand DTO properties as individual query parameters
+     * - `"ref"`: Keep as a single parameter with a schema reference
+     *
+     * @default "inline"
+     *
+     * @example
+     * ```typescript
+     * // With style: "inline" (default)
+     * // @Query() dto: PaginationDto becomes:
+     * // - page: integer (query)
+     * // - limit: integer (query)
+     *
+     * // With style: "ref"
+     * // @Query() dto: PaginationDto becomes:
+     * // - dto: $ref to PaginationDto schema (query)
+     * ```
+     */
+    readonly style?: 'inline' | 'ref';
+}
+/**
+ * Configuration for nestjs-openapi.
+ * Inspired by tsconfig.json and vite.config.ts patterns.
+ *
+ * @example
+ * ```typescript
+ * import { defineConfig } from 'nestjs-openapi';
+ *
+ * export default defineConfig({
+ *   output: 'src/openapi/openapi.generated.json',
+ *
+ *   files: {
+ *     entry: 'src/app.module.ts',
+ *     dtoGlob: 'src/**\/*.dto.ts',
+ *   },
+ *
+ *   openapi: {
+ *     info: {
+ *       title: 'My API',
+ *       version: '1.0.0',
+ *     },
+ *   },
+ *
+ *   options: {
+ *     basePath: '/api',
+ *     extractValidation: true,
+ *   },
+ * });
+ * ```
+ */
+interface Config {
+    /**
+     * Extend another config file. Paths are relative to this config file.
+     * Extended config values are deeply merged, with this config taking precedence.
+     * @example extends: './configs/base-openapi.config.ts'
+     */
+    readonly extends?: string;
+    /**
+     * Input file configuration.
+     * All paths are relative to the config file location.
+     */
+    readonly files?: FilesConfig;
+    /**
+     * Output path for the generated OpenAPI specification.
+     * Path is relative to the config file location.
+     * @required
+     */
+    readonly output: string;
+    /**
+     * Output format for the specification.
+     * @default "json"
+     */
+    readonly format?: OutputFormat;
+    /**
+     * OpenAPI specification metadata.
+     * Maps directly to the OpenAPI spec structure.
+     * @required
+     */
+    readonly openapi: OpenApiConfig;
+    /**
+     * Generation behavior options.
+     */
+    readonly options?: OptionsConfig;
+}
+/**
+ * Options for the generate function to override config values.
+ * Useful for CLI overrides.
+ */
+interface GenerateOverrides {
+    /**
+     * Override the output format.
+     * Takes precedence over config.format.
+     */
+    readonly format?: OutputFormat;
+    /**
+     * Enable debug mode for verbose logging and full stack traces.
+     */
+    readonly debug?: boolean;
+    /**
+     * Optional OpenTelemetry tracing for profiling generation performance.
+     */
+    readonly telemetry?: TelemetryConfig;
+}
+/**
+ * OpenTelemetry tracing options.
+ */
+interface TelemetryConfig {
+    /**
+     * Enable OpenTelemetry tracing.
+     * @default false
+     */
+    readonly enabled?: boolean;
+    /**
+     * Span exporter backend.
+     * - "console": writes spans to stdout
+     * - "otlp": sends spans to OTLP HTTP collector
+     * @default "console"
+     */
+    readonly exporter?: 'console' | 'otlp';
+    /**
+     * OTLP HTTP endpoint.
+     * Used only when exporter is "otlp".
+     * @default "http://localhost:4318/v1/traces"
+     */
+    readonly otlpEndpoint?: string;
+    /**
+     * Service name attached to emitted traces.
+     * @default "nestjs-openapi"
+     */
+    readonly serviceName?: string;
+}
+/**
+ * OpenAPI 3.0/3.1/3.2 specification schema object
+ * Type can be a string or array of strings (for nullable in 3.1+)
+ */
+interface OpenApiSchema$1 {
+    /** Schema type - string or array for 3.1+ nullable (e.g., ['string', 'null']) */
+    readonly type?: string | readonly string[];
+    readonly format?: string;
+    readonly $ref?: string;
+    readonly oneOf?: readonly OpenApiSchema$1[];
+    readonly anyOf?: readonly OpenApiSchema$1[];
+    readonly allOf?: readonly OpenApiSchema$1[];
+    readonly items?: OpenApiSchema$1;
+    readonly properties?: Record<string, OpenApiSchema$1>;
+    readonly required?: readonly string[];
+    readonly enum?: readonly unknown[];
+    readonly description?: string;
+    /** OpenAPI 3.0 only - use type: [T, 'null'] in 3.1+ instead */
+    readonly nullable?: boolean;
+    /** Examples array for 3.1+ (replaces single 'example' field) */
+    readonly examples?: readonly unknown[];
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: string;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly exclusiveMinimum?: number;
+    readonly exclusiveMaximum?: number;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly default?: unknown;
+    readonly additionalProperties?: boolean | OpenApiSchema$1;
+}
+/**
+ * OpenAPI 3.0 parameter object
+ */
+interface OpenApiParameter {
+    readonly name: string;
+    readonly in: 'path' | 'query' | 'header' | 'cookie';
+    readonly description?: string;
+    readonly required: boolean;
+    readonly schema: OpenApiSchema$1;
+}
+/**
+ * OpenAPI 3.0 request body object
+ */
+interface OpenApiRequestBody {
+    readonly description?: string;
+    readonly required?: boolean;
+    readonly content: Record<string, {
+        readonly schema: OpenApiSchema$1;
+    }>;
+}
+/**
+ * OpenAPI 3.0 response object
+ */
+interface OpenApiResponse {
+    readonly description: string;
+    readonly content?: Record<string, {
+        readonly schema: OpenApiSchema$1;
+    }>;
+}
+/**
+ * OpenAPI 3.0 operation object
+ */
+interface OpenApiOperation$1 {
+    readonly operationId: string;
+    readonly summary?: string;
+    readonly description?: string;
+    readonly deprecated?: boolean;
+    readonly tags?: readonly string[];
+    readonly parameters?: readonly OpenApiParameter[];
+    readonly requestBody?: OpenApiRequestBody;
+    readonly responses: Record<string, OpenApiResponse>;
+    /** Per-operation security requirements (overrides global security) */
+    readonly security?: readonly SecurityRequirement[];
+}
+/**
+ * OpenAPI 3.0 paths object
+ * Maps path patterns to HTTP method operations
+ */
+interface OpenApiPaths$1 {
+    readonly [path: string]: {
+        readonly [method: string]: OpenApiOperation$1;
+    };
+}
+/**
+ * OpenAPI 3.0 OAuth2 flow object
+ */
+interface OpenApiOAuth2Flow {
+    readonly authorizationUrl?: string;
+    readonly tokenUrl?: string;
+    readonly refreshUrl?: string;
+    readonly scopes: Record<string, string>;
+}
+/**
+ * OpenAPI 3.0 OAuth2 flows object
+ */
+interface OpenApiOAuth2Flows {
+    readonly implicit?: OpenApiOAuth2Flow;
+    readonly password?: OpenApiOAuth2Flow;
+    readonly clientCredentials?: OpenApiOAuth2Flow;
+    readonly authorizationCode?: OpenApiOAuth2Flow;
+}
+/**
+ * OpenAPI 3.0 security scheme object
+ */
+interface OpenApiSecurityScheme {
+    readonly type: SecuritySchemeType;
+    readonly description?: string;
+    /** The name of the HTTP Authorization scheme (for type: 'http') */
+    readonly scheme?: string;
+    /** A hint for the format of the token (for type: 'http' with scheme: 'bearer') */
+    readonly bearerFormat?: string;
+    /** The location of the API key (for type: 'apiKey') */
+    readonly in?: SecuritySchemeIn;
+    /** The name of the header, query, or cookie parameter (for type: 'apiKey') */
+    readonly name?: string;
+    /** OAuth2 flows (for type: 'oauth2') */
+    readonly flows?: OpenApiOAuth2Flows;
+    /** OpenID Connect URL (for type: 'openIdConnect') */
+    readonly openIdConnectUrl?: string;
+}
+/**
+ * Webhook operation for OpenAPI 3.1+
+ * Similar to regular operations but accessed via events rather than HTTP methods
+ */
+interface OpenApiWebhookOperation {
+    readonly post?: OpenApiOperation$1;
+    readonly put?: OpenApiOperation$1;
+    readonly patch?: OpenApiOperation$1;
+    readonly delete?: OpenApiOperation$1;
+    readonly get?: OpenApiOperation$1;
+}
+/**
+ * Complete OpenAPI 3.0/3.1/3.2 specification
+ */
+interface OpenApiSpec {
+    readonly openapi: OpenApiVersion;
+    readonly info: {
+        readonly title: string;
+        readonly version: string;
+        readonly description?: string;
+        readonly contact?: ContactConfig;
+        readonly license?: LicenseConfig;
+    };
+    readonly servers?: readonly ServerConfig[];
+    readonly tags?: readonly TagConfig[];
+    readonly paths: OpenApiPaths$1;
+    /** Webhooks for OpenAPI 3.1+ - event-driven operations */
+    readonly webhooks?: Record<string, OpenApiWebhookOperation>;
+    readonly components?: {
+        readonly schemas?: Record<string, OpenApiSchema$1>;
+        readonly securitySchemes?: Record<string, OpenApiSecurityScheme>;
+    };
+    /** Global security requirements */
+    readonly security?: readonly SecurityRequirement[];
+}
+
+interface ModuleWithControllers {
+    readonly declaration: ClassDeclaration;
+    readonly controllers: readonly ClassDeclaration[];
+}
+/** Iterative BFS to avoid stack overflow on deep module graphs */
+declare const getModules: (root: ClassDeclaration) => Effect.Effect<readonly ModuleWithControllers[], never, never>;
+declare const getAllControllers: (root: ClassDeclaration) => Effect.Effect<ClassDeclaration[], never, never>;
+declare const ModuleTraversalService_base: Effect.Service.Class<ModuleTraversalService, "ModuleTraversalService", {
+    readonly accessors: true;
+    readonly effect: Effect.Effect<{
+        getModules: (root: ClassDeclaration) => Effect.Effect<readonly ModuleWithControllers[], never, never>;
+        getAllControllers: (root: ClassDeclaration) => Effect.Effect<ClassDeclaration[], never, never>;
+    }, never, never>;
+}>;
+declare class ModuleTraversalService extends ModuleTraversalService_base {
+}
+
+declare const ParameterLocation: Schema.Literal<["path", "query", "header", "cookie", "body"]>;
+type ParameterLocation = typeof ParameterLocation.Type;
+/** Validation constraints that can be applied to parameters (plain interface for perf) */
+interface ParameterConstraints {
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: string;
+    readonly format?: string;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly exclusiveMinimum?: number | boolean;
+    readonly exclusiveMaximum?: number | boolean;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly enum?: readonly unknown[];
+    readonly type?: string;
+}
+declare const ResolvedParameter: Schema.Struct<{
+    name: typeof Schema.String;
+    location: Schema.Literal<["path", "query", "header", "cookie", "body"]>;
+    tsType: typeof Schema.String;
+    required: typeof Schema.Boolean;
+    description: Schema.OptionFromNullOr<typeof Schema.String>;
+}>;
+interface ResolvedParameter extends Schema.Schema.Type<typeof ResolvedParameter> {
+    /** Validation constraints from decorators like @Min, @Max, @IsEnum, etc. */
+    readonly constraints?: ParameterConstraints;
+}
+declare const ReturnTypeInfo: Schema.Struct<{
+    type: Schema.OptionFromNullOr<typeof Schema.String>;
+    inline: Schema.OptionFromNullOr<typeof Schema.String>;
+    container: Schema.OptionFromNullOr<Schema.Literal<["array"]>>;
+    filePath: Schema.OptionFromNullOr<typeof Schema.String>;
+}>;
+type ReturnTypeInfo = typeof ReturnTypeInfo.Type;
+declare const HttpMethod: Schema.Literal<["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD", "ALL"]>;
+type HttpMethod = typeof HttpMethod.Type;
+declare const MethodInfo: Schema.Struct<{
+    httpMethod: Schema.Literal<["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD", "ALL"]>;
+    path: typeof Schema.String;
+    methodName: typeof Schema.String;
+    controllerName: typeof Schema.String;
+    controllerTags: Schema.Array$<typeof Schema.String>;
+    returnType: Schema.Struct<{
+        type: Schema.OptionFromNullOr<typeof Schema.String>;
+        inline: Schema.OptionFromNullOr<typeof Schema.String>;
+        container: Schema.OptionFromNullOr<Schema.Literal<["array"]>>;
+        filePath: Schema.OptionFromNullOr<typeof Schema.String>;
+    }>;
+    parameters: Schema.Array$<Schema.Struct<{
+        name: typeof Schema.String;
+        location: Schema.Literal<["path", "query", "header", "cookie", "body"]>;
+        tsType: typeof Schema.String;
+        required: typeof Schema.Boolean;
+        description: Schema.OptionFromNullOr<typeof Schema.String>;
+    }>>;
+    /** All decorator names on the method (for filtering) */
+    decorators: Schema.Array$<typeof Schema.String>;
+    /** Metadata from @ApiOperation decorator */
+    operation: Schema.Struct<{
+        /** Custom summary from @ApiOperation({ summary: '...' }) */
+        summary: Schema.OptionFromNullOr<typeof Schema.String>;
+        /** Description from @ApiOperation({ description: '...' }) */
+        description: Schema.OptionFromNullOr<typeof Schema.String>;
+        /** Custom operationId from @ApiOperation({ operationId: '...' }) */
+        operationId: Schema.OptionFromNullOr<typeof Schema.String>;
+        /** Deprecated flag from @ApiOperation({ deprecated: true }) */
+        deprecated: Schema.OptionFromNullOr<typeof Schema.Boolean>;
+    }>;
+    /** Response metadata from @ApiResponse decorators */
+    responses: Schema.Array$<Schema.Struct<{
+        /** HTTP status code (e.g., 200, 201, 400, 404) */
+        statusCode: typeof Schema.Number;
+        /** Response description */
+        description: Schema.OptionFromNullOr<typeof Schema.String>;
+        /** Response type name (e.g., "UserDto") */
+        type: Schema.OptionFromNullOr<typeof Schema.String>;
+        /** Whether the response type is an array */
+        isArray: typeof Schema.Boolean;
+    }>>;
+    /** Custom HTTP code from @HttpCode decorator */
+    httpCode: Schema.OptionFromNullOr<typeof Schema.Number>;
+    /** Content types from @ApiConsumes decorator (request body content types) */
+    consumes: Schema.Array$<typeof Schema.String>;
+    /** Content types from @ApiProduces decorator (response content types) */
+    produces: Schema.Array$<typeof Schema.String>;
+    /**
+     * Security requirements from decorators (@ApiBearerAuth, @ApiSecurity, etc.)
+     * Combines controller-level and method-level security.
+     * Multiple requirements = AND logic (all required).
+     * Empty array = no security decorators found (inherits global security).
+     */
+    security: Schema.Array$<Schema.Struct<{
+        /** Security scheme name (e.g., 'bearer', 'jwt', 'oauth2') */
+        schemeName: typeof Schema.String;
+        /** Required scopes (empty array for schemes without scopes) */
+        scopes: Schema.Array$<typeof Schema.String>;
+    }>>;
+}>;
+type MethodInfo = typeof MethodInfo.Type;
+interface OpenApiSchema {
+    readonly type?: string;
+    readonly format?: string;
+    readonly $ref?: string;
+    readonly oneOf?: readonly OpenApiSchema[];
+    readonly allOf?: readonly OpenApiSchema[];
+    readonly items?: OpenApiSchema;
+    readonly properties?: Record<string, OpenApiSchema>;
+    readonly required?: readonly string[];
+    /** OpenAPI 3.0 nullable flag */
+    readonly nullable?: boolean;
+}
+declare const OpenApiOperation: Schema.Struct<{
+    operationId: typeof Schema.String;
+    summary: Schema.optional<typeof Schema.String>;
+    description: Schema.optional<typeof Schema.String>;
+    deprecated: Schema.optional<typeof Schema.Boolean>;
+    parameters: Schema.optional<Schema.Array$<Schema.Struct<{
+        name: typeof Schema.String;
+        in: Schema.Literal<["path", "query", "header", "cookie"]>;
+        description: Schema.optional<typeof Schema.String>;
+        required: typeof Schema.Boolean;
+        schema: Schema.Schema<OpenApiSchema, OpenApiSchema, never>;
+    }>>>;
+    requestBody: Schema.optional<Schema.Struct<{
+        description: Schema.optional<typeof Schema.String>;
+        required: Schema.optional<typeof Schema.Boolean>;
+        content: Schema.Record$<typeof Schema.String, Schema.Struct<{
+            schema: typeof Schema.Unknown;
+        }>>;
+    }>>;
+    responses: Schema.Record$<typeof Schema.String, Schema.Struct<{
+        description: typeof Schema.String;
+        content: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Struct<{
+            schema: typeof Schema.Unknown;
+        }>>>;
+    }>>;
+    tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    /** Per-operation security requirements */
+    security: Schema.optional<Schema.Array$<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>>;
+}>;
+type OpenApiOperation = typeof OpenApiOperation.Type;
+/** Maps path -> method -> operation */
+interface OpenApiPaths {
+    readonly [path: string]: {
+        readonly [method: string]: OpenApiOperation;
+    };
+}
+declare const OpenApiGeneratorConfig: Schema.Struct<{
+    extends: Schema.optional<typeof Schema.String>;
+    files: Schema.optional<Schema.Struct<{
+        entry: Schema.optional<Schema.Union<[typeof Schema.String, Schema.Array$<typeof Schema.String>]>>;
+        tsconfig: Schema.optional<typeof Schema.String>;
+        dtoGlob: Schema.optional<Schema.Union<[typeof Schema.String, Schema.Array$<typeof Schema.String>]>>;
+        include: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        exclude: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    }>>;
+    output: typeof Schema.String;
+    format: Schema.optional<Schema.Literal<["json", "yaml"]>>;
+    openapi: Schema.Struct<{
+        version: Schema.optional<Schema.Literal<["3.0.3", "3.1.0", "3.2.0"]>>;
+        info: Schema.Struct<{
+            title: typeof Schema.String;
+            version: typeof Schema.String;
+            description: Schema.optional<typeof Schema.String>;
+            contact: Schema.optional<Schema.Struct<{
+                name: Schema.optional<typeof Schema.String>;
+                email: Schema.optional<typeof Schema.String>;
+                url: Schema.optional<typeof Schema.String>;
+            }>>;
+            license: Schema.optional<Schema.Struct<{
+                name: typeof Schema.String;
+                url: Schema.optional<typeof Schema.String>;
+            }>>;
+        }>;
+        servers: Schema.optional<Schema.Array$<Schema.Struct<{
+            url: typeof Schema.String;
+            description: Schema.optional<typeof Schema.String>;
+        }>>>;
+        tags: Schema.optional<Schema.Array$<Schema.Struct<{
+            name: typeof Schema.String;
+            description: Schema.optional<typeof Schema.String>;
+        }>>>;
+        security: Schema.optional<Schema.Struct<{
+            schemes: Schema.optional<Schema.Array$<Schema.Union<[Schema.Struct<{
+                name: typeof Schema.String;
+                type: Schema.Literal<["http"]>;
+                scheme: typeof Schema.String;
+                bearerFormat: Schema.optional<typeof Schema.String>;
+                description: Schema.optional<typeof Schema.String>;
+            }>, Schema.Struct<{
+                name: typeof Schema.String;
+                type: Schema.Literal<["apiKey"]>;
+                in: Schema.Literal<["query", "header", "cookie"]>;
+                parameterName: typeof Schema.String;
+                description: Schema.optional<typeof Schema.String>;
+            }>, Schema.Struct<{
+                name: typeof Schema.String;
+                type: Schema.Literal<["oauth2"]>;
+                flows: Schema.Struct<{
+                    implicit: Schema.optional<Schema.Struct<{
+                        authorizationUrl: Schema.optional<typeof Schema.String>;
+                        tokenUrl: Schema.optional<typeof Schema.String>;
+                        refreshUrl: Schema.optional<typeof Schema.String>;
+                        scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+                    }>>;
+                    password: Schema.optional<Schema.Struct<{
+                        authorizationUrl: Schema.optional<typeof Schema.String>;
+                        tokenUrl: Schema.optional<typeof Schema.String>;
+                        refreshUrl: Schema.optional<typeof Schema.String>;
+                        scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+                    }>>;
+                    clientCredentials: Schema.optional<Schema.Struct<{
+                        authorizationUrl: Schema.optional<typeof Schema.String>;
+                        tokenUrl: Schema.optional<typeof Schema.String>;
+                        refreshUrl: Schema.optional<typeof Schema.String>;
+                        scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+                    }>>;
+                    authorizationCode: Schema.optional<Schema.Struct<{
+                        authorizationUrl: Schema.optional<typeof Schema.String>;
+                        tokenUrl: Schema.optional<typeof Schema.String>;
+                        refreshUrl: Schema.optional<typeof Schema.String>;
+                        scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+                    }>>;
+                }>;
+                description: Schema.optional<typeof Schema.String>;
+            }>, Schema.Struct<{
+                name: typeof Schema.String;
+                type: Schema.Literal<["openIdConnect"]>;
+                openIdConnectUrl: typeof Schema.String;
+                description: Schema.optional<typeof Schema.String>;
+            }>]>>>;
+            global: Schema.optional<Schema.Array$<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>>;
+        }>>;
+    }>;
+    options: Schema.optional<Schema.Struct<{
+        basePath: Schema.optional<typeof Schema.String>;
+        extractValidation: Schema.optional<typeof Schema.Boolean>;
+        excludeDecorators: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        query: Schema.optional<Schema.Struct<{
+            style: Schema.optional<Schema.Literal<["inline", "ref"]>>;
+        }>>;
+        schemas: Schema.optional<Schema.Struct<{
+            aliasRefs: Schema.optional<Schema.Literal<["collapse", "preserve"]>>;
+        }>>;
+        pathFilter: Schema.optional<Schema.Union<[Schema.instanceOf<RegExp>, Schema.declare<(path: string) => boolean, (path: string) => boolean, readonly [], never>]>>;
+    }>>;
+}>;
+type OpenApiGeneratorConfig = typeof OpenApiGeneratorConfig.Type;
+declare const ResolvedConfig: Schema.Struct<{
+    tsconfig: typeof Schema.String;
+    entry: Schema.Array$<typeof Schema.String>;
+    include: Schema.Array$<typeof Schema.String>;
+    exclude: Schema.Array$<typeof Schema.String>;
+    excludeDecorators: Schema.Array$<typeof Schema.String>;
+    dtoGlob: Schema.Array$<typeof Schema.String>;
+    extractValidation: typeof Schema.Boolean;
+    aliasRefs: Schema.Literal<["collapse", "preserve"]>;
+    basePath: Schema.optional<typeof Schema.String>;
+    pathFilter: Schema.optional<Schema.Union<[Schema.instanceOf<RegExp>, Schema.declare<(path: string) => boolean, (path: string) => boolean, readonly [], never>]>>;
+    version: Schema.optional<typeof Schema.String>;
+    info: Schema.Struct<{
+        title: typeof Schema.String;
+        version: typeof Schema.String;
+        description: Schema.optional<typeof Schema.String>;
+        contact: Schema.optional<Schema.Struct<{
+            name: Schema.optional<typeof Schema.String>;
+            email: Schema.optional<typeof Schema.String>;
+            url: Schema.optional<typeof Schema.String>;
+        }>>;
+        license: Schema.optional<Schema.Struct<{
+            name: typeof Schema.String;
+            url: Schema.optional<typeof Schema.String>;
+        }>>;
+    }>;
+    servers: Schema.Array$<Schema.Struct<{
+        url: typeof Schema.String;
+        description: Schema.optional<typeof Schema.String>;
+    }>>;
+    securitySchemes: Schema.Array$<Schema.Union<[Schema.Struct<{
+        name: typeof Schema.String;
+        type: Schema.Literal<["http"]>;
+        scheme: typeof Schema.String;
+        bearerFormat: Schema.optional<typeof Schema.String>;
+        description: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        name: typeof Schema.String;
+        type: Schema.Literal<["apiKey"]>;
+        in: Schema.Literal<["query", "header", "cookie"]>;
+        parameterName: typeof Schema.String;
+        description: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        name: typeof Schema.String;
+        type: Schema.Literal<["oauth2"]>;
+        flows: Schema.Struct<{
+            implicit: Schema.optional<Schema.Struct<{
+                authorizationUrl: Schema.optional<typeof Schema.String>;
+                tokenUrl: Schema.optional<typeof Schema.String>;
+                refreshUrl: Schema.optional<typeof Schema.String>;
+                scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+            }>>;
+            password: Schema.optional<Schema.Struct<{
+                authorizationUrl: Schema.optional<typeof Schema.String>;
+                tokenUrl: Schema.optional<typeof Schema.String>;
+                refreshUrl: Schema.optional<typeof Schema.String>;
+                scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+            }>>;
+            clientCredentials: Schema.optional<Schema.Struct<{
+                authorizationUrl: Schema.optional<typeof Schema.String>;
+                tokenUrl: Schema.optional<typeof Schema.String>;
+                refreshUrl: Schema.optional<typeof Schema.String>;
+                scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+            }>>;
+            authorizationCode: Schema.optional<Schema.Struct<{
+                authorizationUrl: Schema.optional<typeof Schema.String>;
+                tokenUrl: Schema.optional<typeof Schema.String>;
+                refreshUrl: Schema.optional<typeof Schema.String>;
+                scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+            }>>;
+        }>;
+        description: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        name: typeof Schema.String;
+        type: Schema.Literal<["openIdConnect"]>;
+        openIdConnectUrl: typeof Schema.String;
+        description: Schema.optional<typeof Schema.String>;
+    }>]>>;
+    securityRequirements: Schema.Array$<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>;
+    tags: Schema.Array$<Schema.Struct<{
+        name: typeof Schema.String;
+        description: Schema.optional<typeof Schema.String>;
+    }>>;
+    output: typeof Schema.String;
+    format: Schema.Literal<["json", "yaml"]>;
+}>;
+type ResolvedConfig = typeof ResolvedConfig.Type;
+
+/** Configuration options for parameter extraction */
+interface ExtractParametersOptions {
+    /** Query parameter handling options */
+    readonly query?: {
+        /** How to represent query DTOs: "inline" (default) or "ref" */
+        readonly style?: 'inline' | 'ref';
+    };
+}
+declare const getMethodInfo: (controller: ClassDeclaration, method: MethodDeclaration, options?: ExtractParametersOptions) => Option.Option<MethodInfo>;
+declare const getMethodInfoEffect: (controller: ClassDeclaration, method: MethodDeclaration, options?: ExtractParametersOptions | undefined) => Effect.Effect<Option.Option<{
+    readonly httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD" | "ALL";
+    readonly path: string;
+    readonly methodName: string;
+    readonly controllerName: string;
+    readonly controllerTags: readonly string[];
+    readonly returnType: {
+        readonly filePath: Option.Option<string>;
+        readonly type: Option.Option<string>;
+        readonly inline: Option.Option<string>;
+        readonly container: Option.Option<"array">;
+    };
+    readonly parameters: readonly {
+        readonly name: string;
+        readonly location: "path" | "query" | "header" | "cookie" | "body";
+        readonly tsType: string;
+        readonly required: boolean;
+        readonly description: Option.Option<string>;
+    }[];
+    readonly decorators: readonly string[];
+    readonly operation: {
+        readonly description: Option.Option<string>;
+        readonly summary: Option.Option<string>;
+        readonly operationId: Option.Option<string>;
+        readonly deprecated: Option.Option<boolean>;
+    };
+    readonly responses: readonly {
+        readonly type: Option.Option<string>;
+        readonly description: Option.Option<string>;
+        readonly statusCode: number;
+        readonly isArray: boolean;
+    }[];
+    readonly httpCode: Option.Option<number>;
+    readonly consumes: readonly string[];
+    readonly produces: readonly string[];
+    readonly security: readonly {
+        readonly schemeName: string;
+        readonly scopes: readonly string[];
+    }[];
+}>, never, never>;
+declare const getControllerMethodInfos: (controller: ClassDeclaration, options?: ExtractParametersOptions) => readonly MethodInfo[];
+declare const getControllerMethodInfosEffect: (controller: ClassDeclaration, options?: ExtractParametersOptions | undefined) => Effect.Effect<{
+    readonly httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD" | "ALL";
+    readonly path: string;
+    readonly methodName: string;
+    readonly controllerName: string;
+    readonly controllerTags: readonly string[];
+    readonly returnType: {
+        readonly filePath: Option.Option<string>;
+        readonly type: Option.Option<string>;
+        readonly inline: Option.Option<string>;
+        readonly container: Option.Option<"array">;
+    };
+    readonly parameters: readonly {
+        readonly name: string;
+        readonly location: "path" | "query" | "header" | "cookie" | "body";
+        readonly tsType: string;
+        readonly required: boolean;
+        readonly description: Option.Option<string>;
+    }[];
+    readonly decorators: readonly string[];
+    readonly operation: {
+        readonly description: Option.Option<string>;
+        readonly summary: Option.Option<string>;
+        readonly operationId: Option.Option<string>;
+        readonly deprecated: Option.Option<boolean>;
+    };
+    readonly responses: readonly {
+        readonly type: Option.Option<string>;
+        readonly description: Option.Option<string>;
+        readonly statusCode: number;
+        readonly isArray: boolean;
+    }[];
+    readonly httpCode: Option.Option<number>;
+    readonly consumes: readonly string[];
+    readonly produces: readonly string[];
+    readonly security: readonly {
+        readonly schemeName: string;
+        readonly scopes: readonly string[];
+    }[];
+}[], never, never>;
+declare const MethodExtractionService_base: Effect.Service.Class<MethodExtractionService, "MethodExtractionService", {
+    readonly accessors: true;
+    readonly effect: Effect.Effect<{
+        getMethodInfo: (controller: ClassDeclaration, method: MethodDeclaration, options?: ExtractParametersOptions | undefined) => Effect.Effect<Option.Option<{
+            readonly httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD" | "ALL";
+            readonly path: string;
+            readonly methodName: string;
+            readonly controllerName: string;
+            readonly controllerTags: readonly string[];
+            readonly returnType: {
+                readonly filePath: Option.Option<string>;
+                readonly type: Option.Option<string>;
+                readonly inline: Option.Option<string>;
+                readonly container: Option.Option<"array">;
+            };
+            readonly parameters: readonly {
+                readonly name: string;
+                readonly location: "path" | "query" | "header" | "cookie" | "body";
+                readonly tsType: string;
+                readonly required: boolean;
+                readonly description: Option.Option<string>;
+            }[];
+            readonly decorators: readonly string[];
+            readonly operation: {
+                readonly description: Option.Option<string>;
+                readonly summary: Option.Option<string>;
+                readonly operationId: Option.Option<string>;
+                readonly deprecated: Option.Option<boolean>;
+            };
+            readonly responses: readonly {
+                readonly type: Option.Option<string>;
+                readonly description: Option.Option<string>;
+                readonly statusCode: number;
+                readonly isArray: boolean;
+            }[];
+            readonly httpCode: Option.Option<number>;
+            readonly consumes: readonly string[];
+            readonly produces: readonly string[];
+            readonly security: readonly {
+                readonly schemeName: string;
+                readonly scopes: readonly string[];
+            }[];
+        }>, never, never>;
+        getControllerMethodInfos: (controller: ClassDeclaration, options?: ExtractParametersOptions | undefined) => Effect.Effect<{
+            readonly httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD" | "ALL";
+            readonly path: string;
+            readonly methodName: string;
+            readonly controllerName: string;
+            readonly controllerTags: readonly string[];
+            readonly returnType: {
+                readonly filePath: Option.Option<string>;
+                readonly type: Option.Option<string>;
+                readonly inline: Option.Option<string>;
+                readonly container: Option.Option<"array">;
+            };
+            readonly parameters: readonly {
+                readonly name: string;
+                readonly location: "path" | "query" | "header" | "cookie" | "body";
+                readonly tsType: string;
+                readonly required: boolean;
+                readonly description: Option.Option<string>;
+            }[];
+            readonly decorators: readonly string[];
+            readonly operation: {
+                readonly description: Option.Option<string>;
+                readonly summary: Option.Option<string>;
+                readonly operationId: Option.Option<string>;
+                readonly deprecated: Option.Option<boolean>;
+            };
+            readonly responses: readonly {
+                readonly type: Option.Option<string>;
+                readonly description: Option.Option<string>;
+                readonly statusCode: number;
+                readonly isArray: boolean;
+            }[];
+            readonly httpCode: Option.Option<number>;
+            readonly consumes: readonly string[];
+            readonly produces: readonly string[];
+            readonly security: readonly {
+                readonly schemeName: string;
+                readonly scopes: readonly string[];
+            }[];
+        }[], never, never>;
+    }, never, never>;
+}>;
+declare class MethodExtractionService extends MethodExtractionService_base {
+}
+
+/**
+ * Define configuration for OpenAPI generation.
+ *
+ * @example
+ * ```typescript
+ * export default defineConfig({
+ *   output: 'openapi.json',
+ *   files: { entry: 'src/app.module.ts' },
+ *   openapi: { info: { title: 'My API', version: '1.0.0' } },
+ * });
+ * ```
+ */
+declare function defineConfig(config: Config): Config;
+declare const findConfigFile: (startDir?: string) => Effect.Effect<string, ConfigNotFoundError>;
+declare const loadConfigFromFile: (configPath: string) => Effect.Effect<typeof OpenApiGeneratorConfig.Type, ConfigError>;
+declare const loadConfig: (configPath?: string, cwd?: string) => Effect.Effect<typeof OpenApiGeneratorConfig.Type, ConfigError>;
+declare const resolveConfig: (config: typeof OpenApiGeneratorConfig.Type, configPath?: string) => Effect.Effect<typeof ResolvedConfig.Type, ConfigValidationError>;
+declare const loadAndResolveConfig: (configPath?: string, cwd?: string) => Effect.Effect<typeof ResolvedConfig.Type, ConfigError>;
+declare const ConfigService_base: Effect.Service.Class<ConfigService, "ConfigService", {
+    readonly accessors: true;
+    readonly effect: Effect.Effect<{
+        findConfigFile: (startDir?: string | undefined) => Effect.Effect<string, ConfigNotFoundError, never>;
+        loadConfigFromFile: (configPath: string) => Effect.Effect<{
+            readonly extends?: string | undefined;
+            readonly files?: {
+                readonly entry?: string | readonly string[] | undefined;
+                readonly tsconfig?: string | undefined;
+                readonly dtoGlob?: string | readonly string[] | undefined;
+                readonly include?: readonly string[] | undefined;
+                readonly exclude?: readonly string[] | undefined;
+            } | undefined;
+            readonly output: string;
+            readonly format?: "json" | "yaml" | undefined;
+            readonly openapi: {
+                readonly security?: {
+                    readonly schemes?: readonly ({
+                        readonly name: string;
+                        readonly type: "http";
+                        readonly description?: string | undefined;
+                        readonly scheme: string;
+                        readonly bearerFormat?: string | undefined;
+                    } | {
+                        readonly name: string;
+                        readonly type: "apiKey";
+                        readonly description?: string | undefined;
+                        readonly in: "query" | "header" | "cookie";
+                        readonly parameterName: string;
+                    } | {
+                        readonly name: string;
+                        readonly type: "oauth2";
+                        readonly description?: string | undefined;
+                        readonly flows: {
+                            readonly implicit?: {
+                                readonly scopes?: {
+                                    readonly [x: string]: string;
+                                } | undefined;
+                                readonly authorizationUrl?: string | undefined;
+                                readonly tokenUrl?: string | undefined;
+                                readonly refreshUrl?: string | undefined;
+                            } | undefined;
+                            readonly password?: {
+                                readonly scopes?: {
+                                    readonly [x: string]: string;
+                                } | undefined;
+                                readonly authorizationUrl?: string | undefined;
+                                readonly tokenUrl?: string | undefined;
+                                readonly refreshUrl?: string | undefined;
+                            } | undefined;
+                            readonly clientCredentials?: {
+                                readonly scopes?: {
+                                    readonly [x: string]: string;
+                                } | undefined;
+                                readonly authorizationUrl?: string | undefined;
+                                readonly tokenUrl?: string | undefined;
+                                readonly refreshUrl?: string | undefined;
+                            } | undefined;
+                            readonly authorizationCode?: {
+                                readonly scopes?: {
+                                    readonly [x: string]: string;
+                                } | undefined;
+                                readonly authorizationUrl?: string | undefined;
+                                readonly tokenUrl?: string | undefined;
+                                readonly refreshUrl?: string | undefined;
+                            } | undefined;
+                        };
+                    } | {
+                        readonly name: string;
+                        readonly type: "openIdConnect";
+                        readonly description?: string | undefined;
+                        readonly openIdConnectUrl: string;
+                    })[] | undefined;
+                    readonly global?: readonly {
+                        readonly [x: string]: readonly string[];
+                    }[] | undefined;
+                } | undefined;
+                readonly tags?: readonly {
+                    readonly name: string;
+                    readonly description?: string | undefined;
+                }[] | undefined;
+                readonly version?: "3.0.3" | "3.1.0" | "3.2.0" | undefined;
+                readonly info: {
+                    readonly description?: string | undefined;
+                    readonly version: string;
+                    readonly title: string;
+                    readonly contact?: {
+                        readonly name?: string | undefined;
+                        readonly email?: string | undefined;
+                        readonly url?: string | undefined;
+                    } | undefined;
+                    readonly license?: {
+                        readonly name: string;
+                        readonly url?: string | undefined;
+                    } | undefined;
+                };
+                readonly servers?: readonly {
+                    readonly description?: string | undefined;
+                    readonly url: string;
+                }[] | undefined;
+            };
+            readonly options?: {
+                readonly query?: {
+                    readonly style?: "inline" | "ref" | undefined;
+                } | undefined;
+                readonly basePath?: string | undefined;
+                readonly extractValidation?: boolean | undefined;
+                readonly excludeDecorators?: readonly string[] | undefined;
+                readonly schemas?: {
+                    readonly aliasRefs?: "collapse" | "preserve" | undefined;
+                } | undefined;
+                readonly pathFilter?: RegExp | ((path: string) => boolean) | undefined;
+            } | undefined;
+        }, ConfigError, never>;
+        loadConfig: (configPath?: string | undefined, cwd?: string | undefined) => Effect.Effect<{
+            readonly extends?: string | undefined;
+            readonly files?: {
+                readonly entry?: string | readonly string[] | undefined;
+                readonly tsconfig?: string | undefined;
+                readonly dtoGlob?: string | readonly string[] | undefined;
+                readonly include?: readonly string[] | undefined;
+                readonly exclude?: readonly string[] | undefined;
+            } | undefined;
+            readonly output: string;
+            readonly format?: "json" | "yaml" | undefined;
+            readonly openapi: {
+                readonly security?: {
+                    readonly schemes?: readonly ({
+                        readonly name: string;
+                        readonly type: "http";
+                        readonly description?: string | undefined;
+                        readonly scheme: string;
+                        readonly bearerFormat?: string | undefined;
+                    } | {
+                        readonly name: string;
+                        readonly type: "apiKey";
+                        readonly description?: string | undefined;
+                        readonly in: "query" | "header" | "cookie";
+                        readonly parameterName: string;
+                    } | {
+                        readonly name: string;
+                        readonly type: "oauth2";
+                        readonly description?: string | undefined;
+                        readonly flows: {
+                            readonly implicit?: {
+                                readonly scopes?: {
+                                    readonly [x: string]: string;
+                                } | undefined;
+                                readonly authorizationUrl?: string | undefined;
+                                readonly tokenUrl?: string | undefined;
+                                readonly refreshUrl?: string | undefined;
+                            } | undefined;
+                            readonly password?: {
+                                readonly scopes?: {
+                                    readonly [x: string]: string;
+                                } | undefined;
+                                readonly authorizationUrl?: string | undefined;
+                                readonly tokenUrl?: string | undefined;
+                                readonly refreshUrl?: string | undefined;
+                            } | undefined;
+                            readonly clientCredentials?: {
+                                readonly scopes?: {
+                                    readonly [x: string]: string;
+                                } | undefined;
+                                readonly authorizationUrl?: string | undefined;
+                                readonly tokenUrl?: string | undefined;
+                                readonly refreshUrl?: string | undefined;
+                            } | undefined;
+                            readonly authorizationCode?: {
+                                readonly scopes?: {
+                                    readonly [x: string]: string;
+                                } | undefined;
+                                readonly authorizationUrl?: string | undefined;
+                                readonly tokenUrl?: string | undefined;
+                                readonly refreshUrl?: string | undefined;
+                            } | undefined;
+                        };
+                    } | {
+                        readonly name: string;
+                        readonly type: "openIdConnect";
+                        readonly description?: string | undefined;
+                        readonly openIdConnectUrl: string;
+                    })[] | undefined;
+                    readonly global?: readonly {
+                        readonly [x: string]: readonly string[];
+                    }[] | undefined;
+                } | undefined;
+                readonly tags?: readonly {
+                    readonly name: string;
+                    readonly description?: string | undefined;
+                }[] | undefined;
+                readonly version?: "3.0.3" | "3.1.0" | "3.2.0" | undefined;
+                readonly info: {
+                    readonly description?: string | undefined;
+                    readonly version: string;
+                    readonly title: string;
+                    readonly contact?: {
+                        readonly name?: string | undefined;
+                        readonly email?: string | undefined;
+                        readonly url?: string | undefined;
+                    } | undefined;
+                    readonly license?: {
+                        readonly name: string;
+                        readonly url?: string | undefined;
+                    } | undefined;
+                };
+                readonly servers?: readonly {
+                    readonly description?: string | undefined;
+                    readonly url: string;
+                }[] | undefined;
+            };
+            readonly options?: {
+                readonly query?: {
+                    readonly style?: "inline" | "ref" | undefined;
+                } | undefined;
+                readonly basePath?: string | undefined;
+                readonly extractValidation?: boolean | undefined;
+                readonly excludeDecorators?: readonly string[] | undefined;
+                readonly schemas?: {
+                    readonly aliasRefs?: "collapse" | "preserve" | undefined;
+                } | undefined;
+                readonly pathFilter?: RegExp | ((path: string) => boolean) | undefined;
+            } | undefined;
+        }, ConfigError, never>;
+        resolveConfig: (config: {
+            readonly extends?: string | undefined;
+            readonly files?: {
+                readonly entry?: string | readonly string[] | undefined;
+                readonly tsconfig?: string | undefined;
+                readonly dtoGlob?: string | readonly string[] | undefined;
+                readonly include?: readonly string[] | undefined;
+                readonly exclude?: readonly string[] | undefined;
+            } | undefined;
+            readonly output: string;
+            readonly format?: "json" | "yaml" | undefined;
+            readonly openapi: {
+                readonly security?: {
+                    readonly schemes?: readonly ({
+                        readonly name: string;
+                        readonly type: "http";
+                        readonly description?: string | undefined;
+                        readonly scheme: string;
+                        readonly bearerFormat?: string | undefined;
+                    } | {
+                        readonly name: string;
+                        readonly type: "apiKey";
+                        readonly description?: string | undefined;
+                        readonly in: "query" | "header" | "cookie";
+                        readonly parameterName: string;
+                    } | {
+                        readonly name: string;
+                        readonly type: "oauth2";
+                        readonly description?: string | undefined;
+                        readonly flows: {
+                            readonly implicit?: {
+                                readonly scopes?: {
+                                    readonly [x: string]: string;
+                                } | undefined;
+                                readonly authorizationUrl?: string | undefined;
+                                readonly tokenUrl?: string | undefined;
+                                readonly refreshUrl?: string | undefined;
+                            } | undefined;
+                            readonly password?: {
+                                readonly scopes?: {
+                                    readonly [x: string]: string;
+                                } | undefined;
+                                readonly authorizationUrl?: string | undefined;
+                                readonly tokenUrl?: string | undefined;
+                                readonly refreshUrl?: string | undefined;
+                            } | undefined;
+                            readonly clientCredentials?: {
+                                readonly scopes?: {
+                                    readonly [x: string]: string;
+                                } | undefined;
+                                readonly authorizationUrl?: string | undefined;
+                                readonly tokenUrl?: string | undefined;
+                                readonly refreshUrl?: string | undefined;
+                            } | undefined;
+                            readonly authorizationCode?: {
+                                readonly scopes?: {
+                                    readonly [x: string]: string;
+                                } | undefined;
+                                readonly authorizationUrl?: string | undefined;
+                                readonly tokenUrl?: string | undefined;
+                                readonly refreshUrl?: string | undefined;
+                            } | undefined;
+                        };
+                    } | {
+                        readonly name: string;
+                        readonly type: "openIdConnect";
+                        readonly description?: string | undefined;
+                        readonly openIdConnectUrl: string;
+                    })[] | undefined;
+                    readonly global?: readonly {
+                        readonly [x: string]: readonly string[];
+                    }[] | undefined;
+                } | undefined;
+                readonly tags?: readonly {
+                    readonly name: string;
+                    readonly description?: string | undefined;
+                }[] | undefined;
+                readonly version?: "3.0.3" | "3.1.0" | "3.2.0" | undefined;
+                readonly info: {
+                    readonly description?: string | undefined;
+                    readonly version: string;
+                    readonly title: string;
+                    readonly contact?: {
+                        readonly name?: string | undefined;
+                        readonly email?: string | undefined;
+                        readonly url?: string | undefined;
+                    } | undefined;
+                    readonly license?: {
+                        readonly name: string;
+                        readonly url?: string | undefined;
+                    } | undefined;
+                };
+                readonly servers?: readonly {
+                    readonly description?: string | undefined;
+                    readonly url: string;
+                }[] | undefined;
+            };
+            readonly options?: {
+                readonly query?: {
+                    readonly style?: "inline" | "ref" | undefined;
+                } | undefined;
+                readonly basePath?: string | undefined;
+                readonly extractValidation?: boolean | undefined;
+                readonly excludeDecorators?: readonly string[] | undefined;
+                readonly schemas?: {
+                    readonly aliasRefs?: "collapse" | "preserve" | undefined;
+                } | undefined;
+                readonly pathFilter?: RegExp | ((path: string) => boolean) | undefined;
+            } | undefined;
+        }, configPath?: string | undefined) => Effect.Effect<{
+            readonly tags: readonly {
+                readonly name: string;
+                readonly description?: string | undefined;
+            }[];
+            readonly entry: readonly string[];
+            readonly tsconfig: string;
+            readonly dtoGlob: readonly string[];
+            readonly include: readonly string[];
+            readonly exclude: readonly string[];
+            readonly output: string;
+            readonly format: "json" | "yaml";
+            readonly version?: string | undefined;
+            readonly info: {
+                readonly description?: string | undefined;
+                readonly version: string;
+                readonly title: string;
+                readonly contact?: {
+                    readonly name?: string | undefined;
+                    readonly email?: string | undefined;
+                    readonly url?: string | undefined;
+                } | undefined;
+                readonly license?: {
+                    readonly name: string;
+                    readonly url?: string | undefined;
+                } | undefined;
+            };
+            readonly servers: readonly {
+                readonly description?: string | undefined;
+                readonly url: string;
+            }[];
+            readonly basePath?: string | undefined;
+            readonly extractValidation: boolean;
+            readonly excludeDecorators: readonly string[];
+            readonly aliasRefs: "collapse" | "preserve";
+            readonly pathFilter?: RegExp | ((path: string) => boolean) | undefined;
+            readonly securitySchemes: readonly ({
+                readonly name: string;
+                readonly type: "http";
+                readonly description?: string | undefined;
+                readonly scheme: string;
+                readonly bearerFormat?: string | undefined;
+            } | {
+                readonly name: string;
+                readonly type: "apiKey";
+                readonly description?: string | undefined;
+                readonly in: "query" | "header" | "cookie";
+                readonly parameterName: string;
+            } | {
+                readonly name: string;
+                readonly type: "oauth2";
+                readonly description?: string | undefined;
+                readonly flows: {
+                    readonly implicit?: {
+                        readonly scopes?: {
+                            readonly [x: string]: string;
+                        } | undefined;
+                        readonly authorizationUrl?: string | undefined;
+                        readonly tokenUrl?: string | undefined;
+                        readonly refreshUrl?: string | undefined;
+                    } | undefined;
+                    readonly password?: {
+                        readonly scopes?: {
+                            readonly [x: string]: string;
+                        } | undefined;
+                        readonly authorizationUrl?: string | undefined;
+                        readonly tokenUrl?: string | undefined;
+                        readonly refreshUrl?: string | undefined;
+                    } | undefined;
+                    readonly clientCredentials?: {
+                        readonly scopes?: {
+                            readonly [x: string]: string;
+                        } | undefined;
+                        readonly authorizationUrl?: string | undefined;
+                        readonly tokenUrl?: string | undefined;
+                        readonly refreshUrl?: string | undefined;
+                    } | undefined;
+                    readonly authorizationCode?: {
+                        readonly scopes?: {
+                            readonly [x: string]: string;
+                        } | undefined;
+                        readonly authorizationUrl?: string | undefined;
+                        readonly tokenUrl?: string | undefined;
+                        readonly refreshUrl?: string | undefined;
+                    } | undefined;
+                };
+            } | {
+                readonly name: string;
+                readonly type: "openIdConnect";
+                readonly description?: string | undefined;
+                readonly openIdConnectUrl: string;
+            })[];
+            readonly securityRequirements: readonly {
+                readonly [x: string]: readonly string[];
+            }[];
+        }, ConfigValidationError, never>;
+        loadAndResolveConfig: (configPath?: string | undefined, cwd?: string | undefined) => Effect.Effect<{
+            readonly tags: readonly {
+                readonly name: string;
+                readonly description?: string | undefined;
+            }[];
+            readonly entry: readonly string[];
+            readonly tsconfig: string;
+            readonly dtoGlob: readonly string[];
+            readonly include: readonly string[];
+            readonly exclude: readonly string[];
+            readonly output: string;
+            readonly format: "json" | "yaml";
+            readonly version?: string | undefined;
+            readonly info: {
+                readonly description?: string | undefined;
+                readonly version: string;
+                readonly title: string;
+                readonly contact?: {
+                    readonly name?: string | undefined;
+                    readonly email?: string | undefined;
+                    readonly url?: string | undefined;
+                } | undefined;
+                readonly license?: {
+                    readonly name: string;
+                    readonly url?: string | undefined;
+                } | undefined;
+            };
+            readonly servers: readonly {
+                readonly description?: string | undefined;
+                readonly url: string;
+            }[];
+            readonly basePath?: string | undefined;
+            readonly extractValidation: boolean;
+            readonly excludeDecorators: readonly string[];
+            readonly aliasRefs: "collapse" | "preserve";
+            readonly pathFilter?: RegExp | ((path: string) => boolean) | undefined;
+            readonly securitySchemes: readonly ({
+                readonly name: string;
+                readonly type: "http";
+                readonly description?: string | undefined;
+                readonly scheme: string;
+                readonly bearerFormat?: string | undefined;
+            } | {
+                readonly name: string;
+                readonly type: "apiKey";
+                readonly description?: string | undefined;
+                readonly in: "query" | "header" | "cookie";
+                readonly parameterName: string;
+            } | {
+                readonly name: string;
+                readonly type: "oauth2";
+                readonly description?: string | undefined;
+                readonly flows: {
+                    readonly implicit?: {
+                        readonly scopes?: {
+                            readonly [x: string]: string;
+                        } | undefined;
+                        readonly authorizationUrl?: string | undefined;
+                        readonly tokenUrl?: string | undefined;
+                        readonly refreshUrl?: string | undefined;
+                    } | undefined;
+                    readonly password?: {
+                        readonly scopes?: {
+                            readonly [x: string]: string;
+                        } | undefined;
+                        readonly authorizationUrl?: string | undefined;
+                        readonly tokenUrl?: string | undefined;
+                        readonly refreshUrl?: string | undefined;
+                    } | undefined;
+                    readonly clientCredentials?: {
+                        readonly scopes?: {
+                            readonly [x: string]: string;
+                        } | undefined;
+                        readonly authorizationUrl?: string | undefined;
+                        readonly tokenUrl?: string | undefined;
+                        readonly refreshUrl?: string | undefined;
+                    } | undefined;
+                    readonly authorizationCode?: {
+                        readonly scopes?: {
+                            readonly [x: string]: string;
+                        } | undefined;
+                        readonly authorizationUrl?: string | undefined;
+                        readonly tokenUrl?: string | undefined;
+                        readonly refreshUrl?: string | undefined;
+                    } | undefined;
+                };
+            } | {
+                readonly name: string;
+                readonly type: "openIdConnect";
+                readonly description?: string | undefined;
+                readonly openIdConnectUrl: string;
+            })[];
+            readonly securityRequirements: readonly {
+                readonly [x: string]: readonly string[];
+            }[];
+        }, ConfigError, never>;
+    }, never, never>;
+}>;
+/**
+ * Business service facade for config orchestration.
+ */
+declare class ConfigService extends ConfigService_base {
+}
+
+/**
+ * OpenAPI spec validation utilities.
+ *
+ * Validates that generated specs don't have broken $ref references
+ * or other common issues.
+ */
+
+/**
+ * A broken reference found during validation
+ */
+interface BrokenRef {
+    /** The $ref value that couldn't be resolved */
+    readonly ref: string;
+    /** The JSON path where this reference was found */
+    readonly path: string;
+    /** The schema name that's missing (extracted from $ref) */
+    readonly missingSchema: string;
+}
+/**
+ * Result of spec validation
+ */
+interface ValidationResult {
+    /** Whether the spec is valid (no broken refs) */
+    readonly valid: boolean;
+    /** Total number of schema refs found */
+    readonly totalRefs: number;
+    /** Number of broken refs */
+    readonly brokenRefCount: number;
+    /** Details of each broken ref */
+    readonly brokenRefs: readonly BrokenRef[];
+    /** Missing schema names grouped with their usage count */
+    readonly missingSchemas: ReadonlyMap<string, number>;
+}
+/**
+ * Validates an OpenAPI spec for broken $ref references.
+ *
+ * @param spec - The OpenAPI specification to validate
+ * @returns Validation result with details about any broken refs
+ *
+ * @example
+ * ```typescript
+ * const result = validateSpec(spec);
+ * if (!result.valid) {
+ *   console.error(`Found ${result.brokenRefCount} broken refs:`);
+ *   for (const [schema, count] of result.missingSchemas) {
+ *     console.error(`  - ${schema} (${count} usages)`);
+ *   }
+ * }
+ * ```
+ */
+declare function validateSpec(spec: OpenApiSpec): ValidationResult;
+/**
+ * Categorizes broken refs by likely cause
+ */
+interface BrokenRefCategories {
+    /** Primitive types that shouldn't be refs (string, number, boolean) */
+    readonly primitives: readonly string[];
+    /** Union types (Type | null, void | Type) */
+    readonly unionTypes: readonly string[];
+    /** Query/Path parameter DTOs */
+    readonly queryParams: readonly string[];
+    /** Other missing schemas (likely from different glob patterns) */
+    readonly other: readonly string[];
+}
+/**
+ * Categorize broken refs to help diagnose the root cause.
+ *
+ * @param missingSchemas - Map of missing schema names to usage count
+ * @returns Categorized broken refs
+ */
+declare function categorizeBrokenRefs(missingSchemas: ReadonlyMap<string, number>): BrokenRefCategories;
+/**
+ * Formats validation result as a human-readable string for CLI output.
+ *
+ * @param result - Validation result from validateSpec
+ * @returns Formatted string describing the validation issues
+ */
+declare function formatValidationResult(result: ValidationResult): string;
+
+/**
+ * Schema Generator - Wraps ts-json-schema-generator with Effect
+ *
+ * This module generates JSON Schema definitions from TypeScript DTO files.
+ */
+
+type SchemaError = SchemaGenerationError;
+
+interface GeneratedSchemas {
+    readonly definitions: Record<string, JsonSchema>;
+}
+interface JsonSchema {
+    readonly type?: string | readonly string[];
+    readonly format?: string;
+    readonly $ref?: string;
+    readonly properties?: Record<string, JsonSchema>;
+    readonly required?: readonly string[];
+    readonly items?: JsonSchema;
+    readonly enum?: readonly unknown[];
+    readonly oneOf?: readonly JsonSchema[];
+    readonly anyOf?: readonly JsonSchema[];
+    readonly allOf?: readonly JsonSchema[];
+    readonly description?: string;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: string;
+    readonly default?: unknown;
+    readonly additionalProperties?: boolean | JsonSchema;
+    readonly [key: string]: unknown;
+}
+interface SchemaGeneratorOptions {
+    /** Glob patterns for DTO files */
+    readonly dtoGlob: readonly string[];
+    /** Path to tsconfig.json */
+    readonly tsconfig: string;
+    /** Base directory for resolving globs */
+    readonly basePath: string;
+    /** Optional shared TypeScript program to reuse compiler context */
+    readonly reuseProgram?: unknown;
+}
+/**
+ * Generate JSON Schema definitions from TypeScript DTO files
+ */
+declare const generateSchemas: (options: SchemaGeneratorOptions) => Effect.Effect<GeneratedSchemas, SchemaGenerationError, never>;
+/**
+ * Generate schemas from a specific list of file paths.
+ * This is used for the hybrid approach to generate schemas for
+ * types that weren't covered by the initial dtoGlob patterns.
+ *
+ * Uses a temporary tsconfig with only the specified files for better performance.
+ * Falls back to individual file processing if the batched approach fails.
+ */
+declare const generateSchemasFromFiles: (filePaths: readonly string[], tsconfig: string) => Effect.Effect<GeneratedSchemas, never, never>;
+
+declare const SchemaService_base: Effect.Service.Class<SchemaService, "SchemaService", {
+    readonly accessors: true;
+    readonly effect: Effect.Effect<{
+        generateSchemas: (options: SchemaGeneratorOptions) => Effect.Effect<GeneratedSchemas, SchemaGenerationError, never>;
+        generateSchemasFromFiles: (filePaths: readonly string[], tsconfig: string) => Effect.Effect<GeneratedSchemas, never, never>;
+    }, never, never>;
+}>;
+declare class SchemaService extends SchemaService_base {
+}
+
+/**
+ * Validation Mapper - Maps class-validator decorators to OpenAPI constraints
+ *
+ * This module extracts validation information from class-validator decorators
+ * in TypeScript source files and applies them to JSON Schema definitions.
+ */
+
+interface ValidationConstraints {
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: string;
+    readonly format?: string;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly exclusiveMinimum?: number | boolean;
+    readonly exclusiveMaximum?: number | boolean;
+    readonly multipleOf?: number;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly uniqueItems?: boolean;
+    readonly enum?: readonly unknown[];
+    readonly type?: string;
+    readonly description?: string;
+    readonly title?: string;
+    readonly example?: unknown;
+    readonly default?: unknown;
+    readonly deprecated?: boolean;
+    readonly readOnly?: boolean;
+    readonly writeOnly?: boolean;
+    readonly nullable?: boolean;
+    readonly isArray?: boolean;
+    readonly hidden?: boolean;
+}
+/**
+ * Result of extracting property validation info in a single pass
+ */
+interface PropertyValidationInfo {
+    readonly isOptional: boolean;
+    readonly constraints: ValidationConstraints;
+}
+/**
+ * Result of extracting validation metadata from an entire class.
+ * Collected in a single pass over properties.
+ */
+interface ClassValidationInfo {
+    readonly constraints: Record<string, ValidationConstraints>;
+    readonly required: readonly string[];
+}
+/**
+ * Extract validation constraints from a property's decorators
+ */
+declare const extractPropertyConstraints: (property: PropertyDeclaration) => ValidationConstraints;
+/**
+ * Check if a property has @IsOptional() decorator
+ */
+declare const isPropertyOptional: (property: PropertyDeclaration) => boolean;
+/**
+ * Extract both optionality and constraints from a property in a single pass.
+ * This is more efficient than calling isPropertyOptional and extractPropertyConstraints separately.
+ */
+declare const extractPropertyValidationInfo: (property: PropertyDeclaration) => PropertyValidationInfo;
+/**
+ * Extract class-level validation metadata in one pass.
+ */
+declare const extractClassValidationInfo: (classDecl: ClassDeclaration) => ClassValidationInfo;
+/**
+ * Extract all property constraints from a class
+ */
+declare const extractClassConstraints: (classDecl: ClassDeclaration) => Record<string, ValidationConstraints>;
+/**
+ * Get required property names from a class (those without @IsOptional)
+ */
+declare const getRequiredProperties: (classDecl: ClassDeclaration) => readonly string[];
+/**
+ * Apply validation constraints to a JSON Schema
+ */
+declare const applyConstraintsToSchema: (schema: JsonSchema, propertyConstraints: Record<string, ValidationConstraints>, requiredProperties?: readonly string[]) => JsonSchema;
+/**
+ * Merge validation constraints into generated schemas
+ */
+declare const mergeValidationConstraints: (schemas: GeneratedSchemas, classConstraints: Map<string, Record<string, ValidationConstraints>>, classRequired: Map<string, readonly string[]>) => GeneratedSchemas;
+/**
+ * Effect-native wrapper with trace annotations for class validation extraction.
+ */
+declare const extractClassValidationInfoEffect: (classDecl: ClassDeclaration) => Effect.Effect<ClassValidationInfo, ValidationMappingError, never>;
+/**
+ * Effect-native wrapper with trace annotations for schema merge.
+ */
+declare const mergeValidationConstraintsEffect: (schemas: GeneratedSchemas, classConstraints: Map<string, Record<string, ValidationConstraints>>, classRequired: Map<string, readonly string[]>) => Effect.Effect<GeneratedSchemas, never, never>;
+
+declare const ValidationService_base: Effect.Service.Class<ValidationService, "ValidationService", {
+    readonly accessors: true;
+    readonly effect: Effect.Effect<{
+        extractClassValidationInfo: (classDecl: ClassDeclaration) => Effect.Effect<ClassValidationInfo, ValidationMappingError, never>;
+        mergeValidationConstraints: (schemas: GeneratedSchemas, classConstraints: Map<string, Record<string, ValidationConstraints>>, classRequired: Map<string, readonly string[]>) => Effect.Effect<GeneratedSchemas, never, never>;
+    }, never, never>;
+}>;
+declare class ValidationService extends ValidationService_base {
+}
+
+declare const OutputService_base: Effect.Service.Class<OutputService, "OutputService", {
+    readonly accessors: true;
+    readonly effect: Effect.Effect<{
+        ensureOutputDirectory: (outputPath: string) => Effect.Effect<void, OutputDirectoryCreationError, never>;
+        serializeSpec: (spec: OpenApiSpec, outputPath: string, format: "json" | "yaml") => Effect.Effect<string, OutputSerializationError, never>;
+        writeOutput: (outputPath: string, content: string, format: "json" | "yaml") => Effect.Effect<void, OutputWriteError, never>;
+    }, never, never>;
+}>;
+declare class OutputService extends OutputService_base {
+}
+
+interface GenerateResult {
+    /** Path where the OpenAPI spec was written */
+    readonly outputPath: string;
+    /** Number of paths in the generated spec */
+    readonly pathCount: number;
+    /** Number of operations in the generated spec */
+    readonly operationCount: number;
+    /** Number of schemas in the generated spec */
+    readonly schemaCount: number;
+    /** Validation result checking for broken refs */
+    readonly validation: ValidationResult;
+}
+/**
+ * Promise-based public compatibility wrapper.
+ */
+declare const generate$1: (configPath: string, overrides?: GenerateOverrides) => Promise<GenerateResult>;
+
+interface ProjectContext {
+    readonly project: Project;
+    readonly entrySourceFile: SourceFile;
+    readonly entryClass: ClassDeclaration;
+}
+interface ProjectOptions {
+    readonly tsconfig: string;
+    readonly entry: string;
+}
+declare const makeProjectContext: (options: ProjectOptions) => Effect.Effect<{
+    project: Project;
+    entrySourceFile: SourceFile;
+    entryClass: ClassDeclaration;
+}, EntryNotFoundError | ProjectInitError, never>;
+declare const ProjectService_base: Effect.Service.Class<ProjectService, "ProjectService", {
+    readonly accessors: true;
+    readonly effect: Effect.Effect<{
+        makeProjectContext: (options: ProjectOptions) => Effect.Effect<{
+            project: Project;
+            entrySourceFile: SourceFile;
+            entryClass: ClassDeclaration;
+        }, EntryNotFoundError | ProjectInitError, never>;
+    }, never, never>;
+}>;
+declare class ProjectService extends ProjectService_base {
+}
+declare const ProjectServiceLive: (_options: ProjectOptions) => Layer.Layer<ProjectService, never>;
+
+interface GenerateOptions {
+    readonly tsconfig: string;
+    readonly entry: string;
+}
+/**
+ * Low-level path-only Effect API from entry + tsconfig.
+ */
+declare const generatePathsEffect: (options: GenerateOptions) => Effect.Effect<{
+    [path: string]: {
+        [method: string]: {
+            readonly parameters?: readonly {
+                readonly name: string;
+                readonly required: boolean;
+                readonly description?: string | undefined;
+                readonly in: "path" | "query" | "header" | "cookie";
+                readonly schema: OpenApiSchema;
+            }[] | undefined;
+            readonly description?: string | undefined;
+            readonly summary?: string | undefined;
+            readonly operationId: string;
+            readonly deprecated?: boolean | undefined;
+            readonly responses: {
+                readonly [x: string]: {
+                    readonly description: string;
+                    readonly content?: {
+                        readonly [x: string]: {
+                            readonly schema: unknown;
+                        };
+                    } | undefined;
+                };
+            };
+            readonly security?: readonly {
+                readonly [x: string]: readonly string[];
+            }[] | undefined;
+            readonly requestBody?: {
+                readonly required?: boolean | undefined;
+                readonly description?: string | undefined;
+                readonly content: {
+                    readonly [x: string]: {
+                        readonly schema: unknown;
+                    };
+                };
+            } | undefined;
+            readonly tags?: readonly string[] | undefined;
+        };
+    };
+}, ProjectInitError | EntryNotFoundError, ModuleTraversalService | ProjectService | MethodExtractionService>;
+/**
+ * Canonical config-file based Effect API.
+ */
+declare const generateFromConfigEffect: (configPath: string, overrides?: GenerateOverrides | undefined) => Effect.Effect<{
+    outputPath: string;
+    pathCount: number;
+    operationCount: number;
+    schemaCount: number;
+    validation: ValidationResult;
+}, EntryNotFoundError | ConfigError | SchemaGenerationError | ValidationMappingError | DtoGlobResolutionError | MissingGenericSchemaTempFileWriteError | OutputDirectoryCreationError | OutputSerializationError | OutputWriteError, ModuleTraversalService | MethodExtractionService | ConfigService | SchemaService | ValidationService | OutputService>;
+/**
+ * Promise wrapper for path-only API.
+ */
+declare const generatePathsAsync: (options: GenerateOptions) => Promise<OpenApiPaths>;
+/**
+ * Promise wrapper for canonical config-file API.
+ */
+declare const generateFromConfigAsync: (configPath: string, overrides?: GenerateOverrides) => Promise<GenerateResult>;
+/**
+ * Backward-compatible aliases.
+ */
+declare const generate: (options: GenerateOptions) => Effect.Effect<{
+    [path: string]: {
+        [method: string]: {
+            readonly parameters?: readonly {
+                readonly name: string;
+                readonly required: boolean;
+                readonly description?: string | undefined;
+                readonly in: "path" | "query" | "header" | "cookie";
+                readonly schema: OpenApiSchema;
+            }[] | undefined;
+            readonly description?: string | undefined;
+            readonly summary?: string | undefined;
+            readonly operationId: string;
+            readonly deprecated?: boolean | undefined;
+            readonly responses: {
+                readonly [x: string]: {
+                    readonly description: string;
+                    readonly content?: {
+                        readonly [x: string]: {
+                            readonly schema: unknown;
+                        };
+                    } | undefined;
+                };
+            };
+            readonly security?: readonly {
+                readonly [x: string]: readonly string[];
+            }[] | undefined;
+            readonly requestBody?: {
+                readonly required?: boolean | undefined;
+                readonly description?: string | undefined;
+                readonly content: {
+                    readonly [x: string]: {
+                        readonly schema: unknown;
+                    };
+                };
+            } | undefined;
+            readonly tags?: readonly string[] | undefined;
+        };
+    };
+}, ProjectInitError | EntryNotFoundError, ModuleTraversalService | ProjectService | MethodExtractionService>;
+declare const generateAsync: (options: GenerateOptions) => Promise<OpenApiPaths>;
+
+export { MissingGenericSchemaTempFileCleanupError as $, generatePathsAsync as A, generateFromConfigEffect as B, ConfigService as C, generateFromConfigAsync as D, ParameterLocation as F, ReturnTypeInfo as H, HttpMethod as J, OpenApiGeneratorConfig as K, MethodInfo as M, ResolvedConfig as N, ProjectService as P, ProjectInitError as Q, ResolvedParameter as R, SpecFileNotFoundError as S, EntryNotFoundError as U, ValidationService as V, ConfigNotFoundError as W, ConfigLoadError as X, ConfigValidationError as Y, DtoGlobResolutionError as Z, InvalidMethodError as _, SpecFileReadError as a, MissingGenericSchemaTempFileWriteError as a0, PublicApiError as a1, ProjectServiceLive as a6, makeProjectContext as a7, findConfigFile as aA, loadConfigFromFile as aB, loadConfig as aC, resolveConfig as aD, loadAndResolveConfig as aE, validateSpec as aF, categorizeBrokenRefs as aG, formatValidationResult as aH, getModules as aa, getAllControllers as ab, getMethodInfo as ad, getMethodInfoEffect as ae, getControllerMethodInfos as af, getControllerMethodInfosEffect as ag, generateSchemas as ah, generateSchemasFromFiles as ai, SchemaGenerationError as aj, extractPropertyConstraints as an, isPropertyOptional as ao, extractPropertyValidationInfo as ap, extractClassValidationInfo as aq, extractClassValidationInfoEffect as ar, extractClassConstraints as as, getRequiredProperties as at, applyConstraintsToSchema as au, mergeValidationConstraints as av, mergeValidationConstraintsEffect as aw, SpecFileParseError as b, OpenApiOperation as d, ModuleTraversalService as g, MethodExtractionService as h, SchemaService as i, OutputService as j, generate$1 as k, defineConfig as m, generate as x, generateAsync as y, generatePathsEffect as z };
+export type { GenerateOptions as E, GeneratedSchemas as G, InfoConfig as I, LicenseConfig as L, OpenApiSpec as O, TagConfig as T, ProjectError as a2, ConfigError as a3, AnalysisError as a4, GeneratorError as a5, ProjectContext as a8, ProjectOptions as a9, ValidationResult as aI, BrokenRef as aJ, BrokenRefCategories as aK, ModuleWithControllers as ac, SchemaError as ak, SchemaGeneratorOptions as al, JsonSchema as am, ValidationConstraints as ax, PropertyValidationInfo as ay, ClassValidationInfo as az, OpenApiPaths as c, OpenApiPaths$1 as e, OpenApiSchema$1 as f, GenerateResult as l, Config as n, ContactConfig as o, ServerConfig as p, OutputFormat as q, TelemetryConfig as r, GenerateOverrides as s, OpenApiOperation$1 as t, OpenApiParameter as u, OpenApiRequestBody as v, OpenApiResponse as w };