nestjs-openapi 0.1.0

package/dist/shared/nestjs-openapi.BYUrTaMo.d.ts

@@ -0,0 +1,355 @@
+import { Schema, Effect } from 'effect';
+
+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;
+}
+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;
+type GeneratorError = ProjectError | ConfigError | AnalysisError;
+
+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;
+    readonly exclusiveMaximum?: number;
+    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 items?: OpenApiSchema;
+    readonly properties?: Record<string, OpenApiSchema>;
+    readonly required?: readonly string[];
+}
+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.Struct<{
+                name: typeof Schema.String;
+                type: Schema.Literal<["apiKey", "http", "oauth2", "openIdConnect"]>;
+                scheme: Schema.optional<typeof Schema.String>;
+                bearerFormat: Schema.optional<typeof Schema.String>;
+                in: Schema.optional<Schema.Literal<["query", "header", "cookie"]>>;
+                parameterName: Schema.optional<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"]>>;
+        }>>;
+        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;
+    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.Struct<{
+        name: typeof Schema.String;
+        type: Schema.Literal<["apiKey", "http", "oauth2", "openIdConnect"]>;
+        scheme: Schema.optional<typeof Schema.String>;
+        bearerFormat: Schema.optional<typeof Schema.String>;
+        in: Schema.optional<Schema.Literal<["query", "header", "cookie"]>>;
+        parameterName: Schema.optional<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;
+
+/**
+ * Internal Effect-based API
+ *
+ * This module exposes the Effect-based implementation for users who want
+ * to integrate with Effect-TS. For most users, the Promise-based API
+ * in the main module is recommended.
+ */
+
+interface GenerateOptions {
+    readonly tsconfig: string;
+    readonly entry: string;
+}
+/**
+ * Generate OpenAPI paths using Effect
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect';
+ * import { generate } from 'nestjs-openapi/internal';
+ *
+ * const program = generate({
+ *   tsconfig: './tsconfig.json',
+ *   entry: './src/app.module.ts'
+ * });
+ *
+ * const paths = await Effect.runPromise(program);
+ * ```
+ */
+declare const generate: (options: GenerateOptions) => Effect.Effect<OpenApiPaths, ProjectError>;
+declare const generateAsync: (options: GenerateOptions) => Promise<OpenApiPaths>;
+
+export { ConfigNotFoundError as C, EntryNotFoundError as E, HttpMethod as H, InvalidMethodError as I, MethodInfo as M, OpenApiGeneratorConfig as O, ResolvedConfig as R, ProjectInitError as b, generateAsync as d, ParameterLocation as e, ResolvedParameter as f, generate as g, ReturnTypeInfo as h, ConfigLoadError as i, ConfigValidationError as j };
+export type { AnalysisError as A, GenerateOptions as G, ProjectError as P, ConfigError as a, OpenApiPaths as c, GeneratorError as k };