@navios/openapi 0.7.0

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2025 Oleksandr Hanzha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

package/README.md

@@ -0,0 +1,260 @@
+# @navios/openapi
+
+Core OpenAPI package for Navios - Automatic OpenAPI 3.1 documentation generation.
+
+This package provides the core functionality for generating OpenAPI documentation from your Navios controllers and endpoints. It automatically discovers endpoints, extracts type information from Zod schemas, and generates comprehensive OpenAPI specifications.
+
+## Overview
+
+`@navios/openapi` is the foundation package that provides decorators and services for OpenAPI documentation. It works with provider packages to add runtime-specific UI integration:
+
+- `@navios/openapi-fastify` - For Fastify applications with Scalar UI
+- `@navios/openapi-bun` - For Bun applications with Scalar UI
+
+## Features
+
+- Automatic endpoint discovery from controllers
+- Zod schema to OpenAPI schema conversion
+- Comprehensive decorator system for API documentation
+- Type-safe metadata extraction
+- Support for all endpoint types (standard, multipart, stream)
+- OpenAPI 3.1 specification generation
+- Rich schema metadata support via Zod `.meta()`
+
+## Installation
+
+```bash
+npm install @navios/openapi zod
+```
+
+Or with yarn:
+
+```bash
+yarn add @navios/openapi zod
+```
+
+## Usage
+
+### Basic Setup
+
+This package is typically used through provider packages (`@navios/openapi-fastify` or `@navios/openapi-bun`), but you can also use the core services directly:
+
+```ts
+import { NaviosFactory } from '@navios/core'
+import {
+  EndpointScannerService,
+  MetadataExtractorService,
+  OpenApiGeneratorService,
+} from '@navios/openapi'
+
+// Use the services to generate OpenAPI spec programmatically
+const generator = await container.get(OpenApiGeneratorService)
+
+const spec = await generator.generate({
+  info: {
+    title: 'My API',
+    version: '1.0.0',
+  },
+})
+```
+
+### Decorators
+
+The package provides decorators to enhance your API documentation:
+
+#### @ApiTag
+
+Groups endpoints under tags in the documentation:
+
+```ts
+import { Controller, Endpoint } from '@navios/core'
+import { ApiTag } from '@navios/openapi'
+
+@Controller()
+@ApiTag('Users', 'User management operations')
+class UserController {
+  @Endpoint(getUser)
+  async getUser() {}
+}
+```
+
+#### @ApiOperation
+
+Provides detailed operation metadata:
+
+```ts
+import { ApiOperation } from '@navios/openapi'
+
+@Endpoint(getUser)
+@ApiOperation({
+  summary: 'Get user by ID',
+  description: 'Retrieves a user by their unique identifier.',
+  operationId: 'getUserById',
+  deprecated: false,
+})
+async getUser() {}
+```
+
+#### @ApiSummary
+
+Shorthand for adding just a summary:
+
+```ts
+import { ApiSummary } from '@navios/openapi'
+
+@Endpoint(getUser)
+@ApiSummary('Get user by ID')
+async getUser() {}
+```
+
+#### @ApiDeprecated
+
+Marks an endpoint as deprecated:
+
+```ts
+import { ApiDeprecated } from '@navios/openapi'
+
+@Endpoint(legacyGetUser)
+@ApiDeprecated('Use /v2/users/:id instead')
+async getLegacyUser() {}
+```
+
+#### @ApiSecurity
+
+Specifies security requirements:
+
+```ts
+import { ApiSecurity } from '@navios/openapi'
+
+@Endpoint(getUser)
+@ApiSecurity({ bearerAuth: [] })
+async getUser() {}
+```
+
+#### @ApiExclude
+
+Excludes an endpoint from documentation:
+
+```ts
+import { ApiExclude } from '@navios/openapi'
+
+@Endpoint(healthCheck)
+@ApiExclude()
+async healthCheck() {
+  return { status: 'ok' }
+}
+```
+
+#### @ApiStream
+
+Specifies content type for stream endpoints:
+
+```ts
+import { ApiStream } from '@navios/openapi'
+import { Stream } from '@navios/core'
+
+@Stream(downloadFile)
+@ApiStream({
+  contentType: 'application/octet-stream',
+  description: 'Download file as binary stream',
+})
+async download() {}
+```
+
+### Schema Metadata
+
+Add OpenAPI metadata to your Zod schemas:
+
+```ts
+import { z } from 'zod'
+
+const userSchema = z
+  .object({
+    id: z.string().meta({
+      openapi: {
+        description: 'Unique user identifier',
+        example: 'usr_123abc',
+      },
+    }),
+    name: z.string().meta({
+      openapi: {
+        description: 'User display name',
+        example: 'John Doe',
+      },
+    }),
+    email: z
+      .string()
+      .email()
+      .meta({
+        openapi: {
+          description: 'User email address',
+          example: 'john@example.com',
+          format: 'email',
+        },
+      }),
+  })
+  .meta({
+    openapi: {
+      title: 'User',
+      description: 'Represents a user in the system',
+    },
+  })
+```
+
+## API Reference
+
+### Decorators
+
+- `@ApiTag(name: string, description?: string)` - Tag endpoints
+- `@ApiOperation(options: ApiOperationOptions)` - Full operation metadata
+- `@ApiSummary(summary: string)` - Quick summary
+- `@ApiDeprecated(reason?: string)` - Mark as deprecated
+- `@ApiSecurity(requirements: ApiSecurityRequirement)` - Security requirements
+- `@ApiExclude()` - Exclude from docs
+- `@ApiStream(options: ApiStreamOptions)` - Stream endpoint metadata
+
+### Services
+
+- `OpenApiGeneratorService` - Main service for generating OpenAPI specs
+- `EndpointScannerService` - Discovers endpoints from controllers
+- `MetadataExtractorService` - Extracts decorator metadata
+- `SchemaConverterService` - Converts Zod schemas to OpenAPI
+- `PathBuilderService` - Builds OpenAPI path items
+
+### Types
+
+- `OpenApiGeneratorOptions` - Options for generating OpenAPI spec
+- `OpenApiEndpointMetadata` - Endpoint metadata type
+- `ApiOperationOptions` - Options for @ApiOperation decorator
+- `ApiSecurityRequirement` - Security requirement type
+
+## Requirements
+
+- **Dependencies**:
+  - `@navios/core` - Core Navios framework
+  - `zod` ^3.25.0 || ^4.0.0 - Schema validation
+- **Peer Dependencies**:
+  - `@navios/di` - Dependency injection (for service usage)
+
+## Provider Packages
+
+This core package is used by provider packages that add runtime-specific UI:
+
+- **[@navios/openapi-fastify](../openapi-fastify/README.md)** - Fastify integration with Scalar UI
+- **[@navios/openapi-bun](../openapi-bun/README.md)** - Bun integration with Scalar UI
+
+## Examples
+
+For complete working examples, see:
+
+- [OpenAPI Examples](../../examples/openapi) - Full examples for both Fastify and Bun
+- [OpenAPI Guide](../../apps/docs/docs/server/guides/openapi.md) - Comprehensive documentation
+
+## Documentation
+
+For complete documentation on using OpenAPI with Navios, see:
+
+- [OpenAPI Guide](../../apps/docs/docs/server/guides/openapi.md)
+- [Controllers & Endpoints](../core/docs/controllers.md)
+- [Streaming](../core/docs/streaming.md)
+- [Multipart](../core/docs/multipart.md)

package/dist/src/__tests__/decorators.spec.d.mts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=decorators.spec.d.mts.map

package/dist/src/__tests__/decorators.spec.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.spec.d.mts","sourceRoot":"","sources":["../../../src/__tests__/decorators.spec.mts"],"names":[],"mappings":""}

package/dist/src/__tests__/metadata.spec.d.mts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=metadata.spec.d.mts.map

package/dist/src/__tests__/metadata.spec.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.spec.d.mts","sourceRoot":"","sources":["../../../src/__tests__/metadata.spec.mts"],"names":[],"mappings":""}

package/dist/src/__tests__/services.spec.d.mts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=services.spec.d.mts.map

package/dist/src/__tests__/services.spec.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.spec.d.mts","sourceRoot":"","sources":["../../../src/__tests__/services.spec.mts"],"names":[],"mappings":""}

package/dist/src/decorators/api-deprecated.decorator.d.mts

@@ -0,0 +1,33 @@
+import { z } from 'zod/v4';
+declare const ApiDeprecatedSchema: z.ZodObject<{
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Options for the @ApiDeprecated decorator, inferred from the schema */
+export type ApiDeprecatedOptions = z.infer<typeof ApiDeprecatedSchema>;
+/**
+ * Marks an endpoint as deprecated.
+ *
+ * Deprecated endpoints are shown with a visual indicator in documentation
+ * and may include a migration message.
+ *
+ * @param message - Optional deprecation message
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class UserController {
+ *   // Simple deprecation
+ *   @Endpoint(legacyGetUser)
+ *   @ApiDeprecated()
+ *   async getLegacyUser() {}
+ *
+ *   // With migration message
+ *   @Endpoint(oldCreateUser)
+ *   @ApiDeprecated('Use POST /v2/users instead')
+ *   async oldCreateUser() {}
+ * }
+ * ```
+ */
+export declare function ApiDeprecated(message?: string): <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T;
+export {};
+//# sourceMappingURL=api-deprecated.decorator.d.mts.map

package/dist/src/decorators/api-deprecated.decorator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-deprecated.decorator.d.mts","sourceRoot":"","sources":["../../../src/decorators/api-deprecated.decorator.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,QAAA,MAAM,mBAAmB;;iBAEvB,CAAA;AAEF,yEAAyE;AACzE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAOtE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,MAAM,qFAE7C"}

package/dist/src/decorators/api-exclude.decorator.d.mts

@@ -0,0 +1,26 @@
+/**
+ * Excludes an endpoint from OpenAPI documentation.
+ *
+ * Use this decorator for internal endpoints that should not be visible
+ * in the public API documentation.
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class HealthController {
+ *   @Endpoint(healthCheck)
+ *   @ApiExclude()
+ *   async healthCheck() {
+ *     return { status: 'ok' }
+ *   }
+ *
+ *   @Endpoint(internalMetrics)
+ *   @ApiExclude()
+ *   async internalMetrics() {
+ *     return { ... }
+ *   }
+ * }
+ * ```
+ */
+export declare const ApiExclude: import("@navios/core").ClassAttribute;
+//# sourceMappingURL=api-exclude.decorator.d.mts.map

package/dist/src/decorators/api-exclude.decorator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-exclude.decorator.d.mts","sourceRoot":"","sources":["../../../src/decorators/api-exclude.decorator.mts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,UAAU,uCAAoD,CAAA"}

package/dist/src/decorators/api-operation.decorator.d.mts

@@ -0,0 +1,58 @@
+import { z } from 'zod/v4';
+declare const ApiOperationSchema: z.ZodObject<{
+    summary: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    operationId: z.ZodOptional<z.ZodString>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    externalDocs: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Options for the @ApiOperation decorator, inferred from the schema */
+export type ApiOperationOptions = z.infer<typeof ApiOperationSchema>;
+/**
+ * Provides detailed operation metadata for an endpoint.
+ *
+ * Use this decorator when you need to specify multiple operation properties.
+ * For simple cases, consider using @ApiSummary instead.
+ *
+ * @param options - Operation configuration options
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class UserController {
+ *   @Endpoint(getUser)
+ *   @ApiOperation({
+ *     summary: 'Get user by ID',
+ *     description: 'Retrieves a user by their unique identifier. Returns 404 if not found.',
+ *     operationId: 'getUserById',
+ *   })
+ *   async getUser(params: EndpointParams<typeof getUser>) {}
+ *
+ *   @Endpoint(legacyGetUser)
+ *   @ApiOperation({
+ *     summary: 'Get user (legacy)',
+ *     deprecated: true,
+ *     externalDocs: {
+ *       url: 'https://docs.example.com/migration',
+ *       description: 'Migration guide'
+ *     }
+ *   })
+ *   async getLegacyUser() {}
+ * }
+ * ```
+ */
+export declare const ApiOperation: import("@navios/core").ClassSchemaAttribute<z.ZodObject<{
+    summary: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    operationId: z.ZodOptional<z.ZodString>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    externalDocs: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export {};
+//# sourceMappingURL=api-operation.decorator.d.mts.map

package/dist/src/decorators/api-operation.decorator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-operation.decorator.d.mts","sourceRoot":"","sources":["../../../src/decorators/api-operation.decorator.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,QAAA,MAAM,kBAAkB;;;;;;;;;iBAWtB,CAAA;AAEF,wEAAwE;AACxE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,YAAY;;;;;;;;;kBAGxB,CAAA"}

package/dist/src/decorators/api-security.decorator.d.mts

@@ -0,0 +1,36 @@
+import { z } from 'zod/v4';
+declare const ApiSecuritySchema: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+/** Security requirement for an endpoint, inferred from the schema */
+export type ApiSecurityRequirement = z.infer<typeof ApiSecuritySchema>;
+/**
+ * Specifies security requirements for an endpoint.
+ *
+ * The security requirement object maps security scheme names to their scopes.
+ * For schemes that don't use scopes (like API keys), use an empty array.
+ *
+ * @param requirements - Security requirements object
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class UserController {
+ *   // Require bearer token authentication
+ *   @Endpoint(getUser)
+ *   @ApiSecurity({ bearerAuth: [] })
+ *   async getUser() {}
+ *
+ *   // Require multiple authentication methods
+ *   @Endpoint(adminEndpoint)
+ *   @ApiSecurity({ bearerAuth: [], apiKey: [] })
+ *   async adminAction() {}
+ *
+ *   // OAuth2 with specific scopes
+ *   @Endpoint(writeUser)
+ *   @ApiSecurity({ oauth2: ['users:write', 'users:read'] })
+ *   async writeUser() {}
+ * }
+ * ```
+ */
+export declare const ApiSecurity: import("@navios/core").ClassSchemaAttribute<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+export {};
+//# sourceMappingURL=api-security.decorator.d.mts.map

package/dist/src/decorators/api-security.decorator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-security.decorator.d.mts","sourceRoot":"","sources":["../../../src/decorators/api-security.decorator.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,QAAA,MAAM,iBAAiB,mDAA4C,CAAA;AAEnE,qEAAqE;AACrE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,WAAW,gGAGvB,CAAA"}

package/dist/src/decorators/api-stream.decorator.d.mts

@@ -0,0 +1,50 @@
+import { z } from 'zod/v4';
+declare const ApiStreamSchema: z.ZodObject<{
+    contentType: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Options for the @ApiStream decorator, inferred from the schema */
+export type ApiStreamOptions = z.infer<typeof ApiStreamSchema>;
+/**
+ * Specifies content type and description for stream endpoints.
+ *
+ * Stream endpoints don't have a responseSchema, so this decorator provides
+ * the necessary metadata for OpenAPI documentation.
+ *
+ * @param options - Stream response options
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class FileController {
+ *   // Binary file download
+ *   @Stream(downloadFile)
+ *   @ApiStream({
+ *     contentType: 'application/octet-stream',
+ *     description: 'Download file as binary stream'
+ *   })
+ *   async download(params: StreamParams<typeof downloadFile>, reply: Reply) {
+ *     // Stream implementation
+ *   }
+ * }
+ *
+ * @Controller()
+ * export class EventController {
+ *   // Server-Sent Events
+ *   @Stream(streamEvents)
+ *   @ApiStream({
+ *     contentType: 'text/event-stream',
+ *     description: 'Real-time event stream'
+ *   })
+ *   async stream(params: StreamParams<typeof streamEvents>, reply: Reply) {
+ *     // SSE implementation
+ *   }
+ * }
+ * ```
+ */
+export declare const ApiStream: import("@navios/core").ClassSchemaAttribute<z.ZodObject<{
+    contentType: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export {};
+//# sourceMappingURL=api-stream.decorator.d.mts.map

package/dist/src/decorators/api-stream.decorator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-stream.decorator.d.mts","sourceRoot":"","sources":["../../../src/decorators/api-stream.decorator.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,QAAA,MAAM,eAAe;;;iBAGnB,CAAA;AAEF,qEAAqE;AACrE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,SAAS;;;kBAGrB,CAAA"}

package/dist/src/decorators/api-summary.decorator.d.mts

@@ -0,0 +1,24 @@
+import { z } from 'zod/v4';
+/**
+ * Shorthand decorator for adding just a summary to an endpoint.
+ *
+ * This is equivalent to `@ApiOperation({ summary: '...' })` but more concise.
+ *
+ * @param summary - Short summary text for the endpoint
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class UserController {
+ *   @Endpoint(getUser)
+ *   @ApiSummary('Get user by ID')
+ *   async getUser() {}
+ *
+ *   @Endpoint(createUser)
+ *   @ApiSummary('Create a new user')
+ *   async createUser() {}
+ * }
+ * ```
+ */
+export declare const ApiSummary: import("@navios/core").ClassSchemaAttribute<z.ZodString>;
+//# sourceMappingURL=api-summary.decorator.d.mts.map

package/dist/src/decorators/api-summary.decorator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-summary.decorator.d.mts","sourceRoot":"","sources":["../../../src/decorators/api-summary.decorator.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAM1B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,UAAU,0DAGtB,CAAA"}

package/dist/src/decorators/api-tag.decorator.d.mts

@@ -0,0 +1,42 @@
+import { z } from 'zod/v4';
+declare const ApiTagSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Options for the @ApiTag decorator, inferred from the schema */
+export type ApiTagOptions = z.infer<typeof ApiTagSchema>;
+/**
+ * Groups endpoints under a specific tag/folder in the documentation.
+ *
+ * Can be applied to controllers (affects all endpoints) or individual methods.
+ * When applied to both, the method-level tag takes precedence.
+ *
+ * @param name - The tag name
+ * @param description - Optional tag description
+ *
+ * @example
+ * ```typescript
+ * // Apply to entire controller
+ * @Controller()
+ * @ApiTag('Users', 'User management operations')
+ * export class UserController {
+ *   @Endpoint(getUser)
+ *   async getUser() {}
+ * }
+ *
+ * // Apply to individual endpoint
+ * @Controller()
+ * export class MixedController {
+ *   @Endpoint(getUser)
+ *   @ApiTag('Users')
+ *   async getUser() {}
+ *
+ *   @Endpoint(getOrder)
+ *   @ApiTag('Orders')
+ *   async getOrder() {}
+ * }
+ * ```
+ */
+export declare function ApiTag(name: string, description?: string): <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T;
+export {};
+//# sourceMappingURL=api-tag.decorator.d.mts.map

package/dist/src/decorators/api-tag.decorator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-tag.decorator.d.mts","sourceRoot":"","sources":["../../../src/decorators/api-tag.decorator.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,QAAA,MAAM,YAAY;;;iBAGhB,CAAA;AAEF,kEAAkE;AAClE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAIxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,qFAExD"}

package/dist/src/decorators/index.d.mts

@@ -0,0 +1,8 @@
+export { ApiTag, type ApiTagOptions } from './api-tag.decorator.mjs';
+export { ApiOperation, type ApiOperationOptions } from './api-operation.decorator.mjs';
+export { ApiSummary } from './api-summary.decorator.mjs';
+export { ApiDeprecated, type ApiDeprecatedOptions } from './api-deprecated.decorator.mjs';
+export { ApiSecurity, type ApiSecurityRequirement } from './api-security.decorator.mjs';
+export { ApiExclude } from './api-exclude.decorator.mjs';
+export { ApiStream, type ApiStreamOptions } from './api-stream.decorator.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/src/decorators/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/decorators/index.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACpE,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,+BAA+B,CAAA;AACtF,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AACxD,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,gCAAgC,CAAA;AACzF,OAAO,EAAE,WAAW,EAAE,KAAK,sBAAsB,EAAE,MAAM,8BAA8B,CAAA;AACvF,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AACxD,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAA"}

package/dist/src/index.d.mts

@@ -0,0 +1,5 @@
+export { ApiTag, ApiOperation, ApiSummary, ApiDeprecated, ApiSecurity, ApiExclude, ApiStream, type ApiOperationOptions, type ApiTagOptions, type ApiStreamOptions, type ApiDeprecatedOptions, type ApiSecurityRequirement, } from './decorators/index.mjs';
+export type { OpenApiEndpointMetadata } from './metadata/index.mjs';
+export { OpenApiGeneratorService, type OpenApiGeneratorOptions, EndpointScannerService, type DiscoveredEndpoint, MetadataExtractorService, SchemaConverterService, type SchemaConversionResult, PathBuilderService, type PathItemResult, } from './services/index.mjs';
+export { ApiTagToken, ApiOperationToken, ApiSummaryToken, ApiDeprecatedToken, ApiSecurityToken, ApiExcludeToken, ApiStreamToken, } from './tokens/index.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/src/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/index.mts"],"names":[],"mappings":"AACA,OAAO,EACL,MAAM,EACN,YAAY,EACZ,UAAU,EACV,aAAa,EACb,WAAW,EACX,UAAU,EACV,SAAS,EACT,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,GAC5B,MAAM,wBAAwB,CAAA;AAG/B,YAAY,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAGnE,OAAO,EACL,uBAAuB,EACvB,KAAK,uBAAuB,EAC5B,sBAAsB,EACtB,KAAK,kBAAkB,EACvB,wBAAwB,EACxB,sBAAsB,EACtB,KAAK,sBAAsB,EAC3B,kBAAkB,EAClB,KAAK,cAAc,GACpB,MAAM,sBAAsB,CAAA;AAG7B,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,cAAc,GACf,MAAM,oBAAoB,CAAA"}

package/dist/src/metadata/index.d.mts

@@ -0,0 +1,2 @@
+export type { OpenApiEndpointMetadata } from './openapi.metadata.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/src/metadata/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/metadata/index.mts"],"names":[],"mappings":"AACA,YAAY,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/src/metadata/openapi.metadata.d.mts

@@ -0,0 +1,30 @@
+import type { ApiSecurityRequirement, ApiStreamOptions } from '../decorators/index.mjs';
+/**
+ * Extracted OpenAPI metadata for an endpoint
+ */
+export interface OpenApiEndpointMetadata {
+    /** Tags for grouping endpoints */
+    tags: string[];
+    /** Short summary */
+    summary?: string;
+    /** Detailed description */
+    description?: string;
+    /** Unique operation identifier */
+    operationId?: string;
+    /** Whether the endpoint is deprecated */
+    deprecated: boolean;
+    /** Deprecation message */
+    deprecationMessage?: string;
+    /** Security requirements */
+    security?: ApiSecurityRequirement[];
+    /** External documentation link */
+    externalDocs?: {
+        url: string;
+        description?: string;
+    };
+    /** Stream content type (for stream endpoints) */
+    stream?: ApiStreamOptions;
+    /** Whether to exclude from documentation */
+    excluded: boolean;
+}
+//# sourceMappingURL=openapi.metadata.d.mts.map

package/dist/src/metadata/openapi.metadata.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.metadata.d.mts","sourceRoot":"","sources":["../../../src/metadata/openapi.metadata.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAEvF;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,kCAAkC;IAClC,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,oBAAoB;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,2BAA2B;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,kCAAkC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,yCAAyC;IACzC,UAAU,EAAE,OAAO,CAAA;IACnB,0BAA0B;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,4BAA4B;IAC5B,QAAQ,CAAC,EAAE,sBAAsB,EAAE,CAAA;IACnC,kCAAkC;IAClC,YAAY,CAAC,EAAE;QACb,GAAG,EAAE,MAAM,CAAA;QACX,WAAW,CAAC,EAAE,MAAM,CAAA;KACrB,CAAA;IACD,iDAAiD;IACjD,MAAM,CAAC,EAAE,gBAAgB,CAAA;IACzB,4CAA4C;IAC5C,QAAQ,EAAE,OAAO,CAAA;CAClB"}