@navios/openapi-bun 0.7.0

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.7.0] - 2025-12-18
+
+### Added
+
+- **Bun OpenAPI Provider**: Initial release of the Bun provider for OpenAPI documentation
+- **Scalar UI Integration**: Interactive Scalar UI for exploring API documentation
+- **OpenAPI Plugin**: `defineOpenApiPlugin()` function for easy integration with Navios applications
+- **Automatic Spec Generation**: Automatic OpenAPI specification generation from Navios controllers
+- **JSON Endpoint**: `/openapi.json` endpoint serving OpenAPI specification in JSON format
+- **YAML Endpoint**: `/openapi.yaml` endpoint serving OpenAPI specification in YAML format (configurable)
+- **Documentation UI**: `/docs` endpoint serving interactive Scalar UI documentation
+- **Customizable Configuration**: Extensive configuration options:
+  - OpenAPI info (title, version, description, contact, license, termsOfService)
+  - Server definitions
+  - Security schemes and global security requirements
+  - Custom tags with descriptions
+  - Customizable paths for JSON, YAML, and docs endpoints
+  - Scalar UI theme configuration (default, alternate, moon, purple, solarized)
+  - Option to disable YAML endpoint
+- **Bun Integration**: Seamless integration with Bun's HTTP server
+- **Type Safety**: Full TypeScript support with comprehensive type definitions
+- **All Core Decorators**: Full support for all decorators from `@navios/openapi`:
+  - `@ApiTag`, `@ApiOperation`, `@ApiSummary`, `@ApiDeprecated`, `@ApiSecurity`, `@ApiExclude`, `@ApiStream`
+- **Endpoint Type Support**: Support for all endpoint types (standard, multipart, stream)
+- **Zod Schema Support**: Automatic conversion of Zod schemas to OpenAPI schemas
+

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,286 @@
+# @navios/openapi-bun
+
+Bun provider for OpenAPI documentation with Scalar UI integration.
+
+This package provides OpenAPI documentation generation for Navios applications running on Bun, including automatic endpoint discovery, schema conversion, and Scalar UI integration for interactive API documentation.
+
+## Overview
+
+`@navios/openapi-bun` extends `@navios/openapi` with Bun-specific integration, providing:
+
+- Scalar UI for interactive API documentation
+- Automatic OpenAPI spec generation
+- JSON and YAML endpoints for the OpenAPI specification
+- Seamless integration with Bun's HTTP server
+
+## Features
+
+- Automatic endpoint discovery from Navios controllers
+- Zod schema to OpenAPI schema conversion
+- Interactive Scalar UI documentation
+- OpenAPI JSON and YAML endpoints
+- Customizable themes and configuration
+- Support for all endpoint types (standard, multipart, stream)
+- Type-safe configuration
+
+## Installation
+
+```bash
+bun add @navios/openapi @navios/openapi-bun
+```
+
+Or with npm:
+
+```bash
+npm install @navios/openapi @navios/openapi-bun
+```
+
+## Usage
+
+### Basic Setup
+
+```ts
+import { defineBunEnvironment } from '@navios/adapter-bun'
+import { Module, NaviosFactory } from '@navios/core'
+import { defineOpenApiPlugin } from '@navios/openapi-bun'
+import { ApiTag, ApiOperation } from '@navios/openapi'
+
+import { AppModule } from './app.module.js'
+
+async function bootstrap() {
+  const app = await NaviosFactory.create(AppModule, {
+    adapter: defineBunEnvironment(),
+  })
+
+  app.usePlugin(
+    defineOpenApiPlugin({
+      info: {
+        title: 'My API',
+        version: '1.0.0',
+        description: 'API documentation',
+      },
+    }),
+  )
+
+  await app.init()
+  await app.listen({ port: 3000 })
+  
+  console.log('API docs available at http://localhost:3000/docs')
+}
+
+bootstrap()
+```
+
+### Complete Example
+
+```ts
+import { defineBunEnvironment } from '@navios/adapter-bun'
+import { builder } from '@navios/builder'
+import {
+  Controller,
+  Endpoint,
+  EndpointParams,
+  Module,
+  NaviosFactory,
+} from '@navios/core'
+import { defineOpenApiPlugin } from '@navios/openapi-bun'
+import { ApiOperation, ApiTag } from '@navios/openapi'
+import { z } from 'zod'
+
+const API = builder()
+
+const userSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string().email(),
+})
+
+export const getUser = API.declareEndpoint({
+  method: 'GET',
+  url: '/users/$userId',
+  responseSchema: userSchema,
+})
+
+@Controller()
+@ApiTag('Users', 'User management operations')
+class UserController {
+  @Endpoint(getUser)
+  @ApiOperation({
+    summary: 'Get user by ID',
+    description: 'Retrieves a user by their unique identifier.',
+  })
+  async getUser(params: EndpointParams<typeof getUser>) {
+    return {
+      id: params.urlParams.userId,
+      name: 'John',
+      email: 'john@example.com',
+    }
+  }
+}
+
+@Module({ controllers: [UserController] })
+class AppModule {}
+
+async function bootstrap() {
+  const app = await NaviosFactory.create(AppModule, {
+    adapter: defineBunEnvironment(),
+  })
+
+  app.usePlugin(
+    defineOpenApiPlugin({
+      info: {
+        title: 'User API',
+        version: '1.0.0',
+      },
+      securitySchemes: {
+        bearerAuth: {
+          type: 'http',
+          scheme: 'bearer',
+        },
+      },
+    }),
+  )
+
+  await app.init()
+  await app.listen({ port: 3000 })
+  console.log('API docs: http://localhost:3000/docs')
+}
+
+bootstrap()
+```
+
+### Advanced Configuration
+
+```ts
+app.usePlugin(
+  defineOpenApiPlugin({
+    info: {
+      title: 'My API',
+      version: '1.0.0',
+      description: 'Complete API documentation',
+      termsOfService: 'https://example.com/terms',
+      contact: {
+        name: 'API Support',
+        url: 'https://example.com/support',
+        email: 'support@example.com',
+      },
+      license: {
+        name: 'MIT',
+        url: 'https://opensource.org/licenses/MIT',
+      },
+    },
+    servers: [
+      { url: 'http://localhost:3000', description: 'Development' },
+      { url: 'https://api.example.com', description: 'Production' },
+    ],
+    securitySchemes: {
+      bearerAuth: {
+        type: 'http',
+        scheme: 'bearer',
+        bearerFormat: 'JWT',
+      },
+      apiKey: {
+        type: 'apiKey',
+        in: 'header',
+        name: 'X-API-Key',
+      },
+    },
+    security: [{ bearerAuth: [] }], // Global security requirement
+    tags: [
+      { name: 'Users', description: 'User management' },
+      { name: 'Orders', description: 'Order processing' },
+    ],
+    jsonPath: '/openapi.json',
+    yamlPath: '/openapi.yaml',
+    docsPath: '/docs',
+    scalar: {
+      theme: 'purple',
+    },
+  }),
+)
+```
+
+## Configuration Options
+
+### Path Configuration
+
+| Option     | Default         | Description                |
+| ---------- | --------------- | -------------------------- |
+| `jsonPath` | `/openapi.json` | Path to serve OpenAPI JSON |
+| `yamlPath` | `/openapi.yaml` | Path to serve OpenAPI YAML |
+| `docsPath` | `/docs`         | Path to serve Scalar UI    |
+| `disableYaml` | `false`      | Disable YAML endpoint      |
+
+### Scalar Themes
+
+The `scalar.theme` option accepts: `'default'`, `'alternate'`, `'moon'`, `'purple'`, `'solarized'`.
+
+## Decorators
+
+All decorators from `@navios/openapi` are available:
+
+- `@ApiTag` - Group endpoints under tags
+- `@ApiOperation` - Full operation metadata
+- `@ApiSummary` - Quick summary
+- `@ApiDeprecated` - Mark as deprecated
+- `@ApiSecurity` - Security requirements
+- `@ApiExclude` - Exclude from docs
+- `@ApiStream` - Stream endpoint metadata
+
+See [@navios/openapi](../openapi/README.md) for detailed decorator documentation.
+
+## Endpoints
+
+After setup, the following endpoints are automatically available:
+
+- `GET /docs` - Interactive Scalar UI documentation
+- `GET /openapi.json` - OpenAPI specification in JSON format
+- `GET /openapi.yaml` - OpenAPI specification in YAML format (if enabled)
+
+## Requirements
+
+- **Runtime**: Bun 1.0+
+- **Dependencies**:
+  - `@navios/adapter-bun` - Bun adapter for Navios
+  - `@navios/core` - Core Navios framework
+  - `@navios/openapi` - Core OpenAPI package
+  - `zod` ^3.25.0 || ^4.0.0 - Schema validation
+- **Peer Dependencies**:
+  - `@navios/builder` - Endpoint builder
+
+## Features
+
+- **Automatic Discovery**: Discovers all endpoints from your controllers
+- **Schema Conversion**: Converts Zod schemas to OpenAPI schemas automatically
+- **Interactive UI**: Beautiful Scalar UI for exploring your API
+- **Type Safety**: Full TypeScript support with comprehensive types
+- **Customizable**: Extensive configuration options
+- **Production Ready**: Battle-tested in production environments
+
+## Examples
+
+For complete working examples, see:
+
+- [OpenAPI Examples](../../examples/openapi/src/bun.mts) - Full Bun example
+- [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)
+- [@navios/openapi Core Package](../openapi/README.md)
+- [Controllers & Endpoints](../core/docs/controllers.md)
+
+## Comparison with Fastify Provider
+
+| Feature     | Bun Provider    | Fastify Provider |
+| ----------- | --------------- | ---------------- |
+| Runtime     | Bun             | Node.js          |
+| Performance | Very High       | High             |
+| UI          | Scalar          | Scalar           |
+| Setup       | Simple          | Simple           |
+| Themes      | 5 themes        | 5 themes         |
+
+Both providers offer the same features and API - choose based on your runtime environment.
+

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

@@ -0,0 +1,4 @@
+export { createOpenApiJsonController } from './openapi-json.controller.mjs';
+export { createOpenApiYamlController } from './openapi-yaml.controller.mjs';
+export { createOpenApiUiController } from './openapi-ui.controller.mjs';
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/controllers/index.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAA;AAC3E,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAA;AAC3E,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA"}

package/dist/src/controllers/openapi-json.controller.d.mts

@@ -0,0 +1,10 @@
+import type { ClassType } from '@navios/di';
+/**
+ * Creates a customized JSON controller with the correct path.
+ * Called by the plugin to create a controller with the configured jsonPath.
+ *
+ * @param jsonPath - The path to serve the OpenAPI JSON (e.g., '/openapi.json')
+ * @returns A controller class that serves the OpenAPI document as JSON
+ */
+export declare function createOpenApiJsonController(jsonPath: string): ClassType;
+//# sourceMappingURL=openapi-json.controller.d.mts.map

package/dist/src/controllers/openapi-json.controller.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-json.controller.d.mts","sourceRoot":"","sources":["../../../src/controllers/openapi-json.controller.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAgB3C;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CA0BvE"}

package/dist/src/controllers/openapi-ui.controller.d.mts

@@ -0,0 +1,10 @@
+import type { ClassType } from '@navios/di';
+/**
+ * Creates a customized Scalar UI controller with the correct path.
+ *
+ * @param docsPath - The path to serve the Scalar UI (e.g., '/docs')
+ * @param jsonPath - The path to the OpenAPI JSON spec (used by Scalar to load the spec)
+ * @returns A controller class that serves the Scalar API Reference UI
+ */
+export declare function createOpenApiUiController(docsPath: string, jsonPath: string): ClassType;
+//# sourceMappingURL=openapi-ui.controller.d.mts.map

package/dist/src/controllers/openapi-ui.controller.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-ui.controller.d.mts","sourceRoot":"","sources":["../../../src/controllers/openapi-ui.controller.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAY3C;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,SAAS,CAgDX"}

package/dist/src/controllers/openapi-yaml.controller.d.mts

@@ -0,0 +1,10 @@
+import type { ClassType } from '@navios/di';
+/**
+ * Creates a customized YAML controller with the correct path.
+ * Uses Stream endpoint to set content-type header properly.
+ *
+ * @param yamlPath - The path to serve the OpenAPI YAML (e.g., '/openapi.yaml')
+ * @returns A controller class that serves the OpenAPI document as YAML
+ */
+export declare function createOpenApiYamlController(yamlPath: string): ClassType;
+//# sourceMappingURL=openapi-yaml.controller.d.mts.map

package/dist/src/controllers/openapi-yaml.controller.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-yaml.controller.d.mts","sourceRoot":"","sources":["../../../src/controllers/openapi-yaml.controller.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAQ3C;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CA6BvE"}

package/dist/src/index.d.mts

@@ -0,0 +1,8 @@
+export { OpenApiBunPlugin, defineOpenApiPlugin, type BunOpenApiPluginOptions, type ScalarOptions, type ScalarTheme, } from './openapi-bun.plugin.mjs';
+export { bunOpenApiPluginOptionsSchema, scalarOptionsSchema, scalarThemeSchema, type BunOpenApiPluginOptionsBase, } from './schemas/index.mjs';
+export { OpenApiOptionsToken } from './tokens/index.mjs';
+export { OpenApiDocumentService, OpenApiDocumentServiceToken, } from './services/index.mjs';
+export { createOpenApiJsonController } from './controllers/openapi-json.controller.mjs';
+export { createOpenApiYamlController } from './controllers/openapi-yaml.controller.mjs';
+export { createOpenApiUiController } from './controllers/openapi-ui.controller.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,gBAAgB,EAChB,mBAAmB,EACnB,KAAK,uBAAuB,EAC5B,KAAK,aAAa,EAClB,KAAK,WAAW,GACjB,MAAM,0BAA0B,CAAA;AAGjC,OAAO,EACL,6BAA6B,EAC7B,mBAAmB,EACnB,iBAAiB,EACjB,KAAK,2BAA2B,GACjC,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAGxD,OAAO,EACL,sBAAsB,EACtB,2BAA2B,GAC5B,MAAM,sBAAsB,CAAA;AAG7B,OAAO,EAAE,2BAA2B,EAAE,MAAM,2CAA2C,CAAA;AACvF,OAAO,EAAE,2BAA2B,EAAE,MAAM,2CAA2C,CAAA;AACvF,OAAO,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAA"}

package/dist/src/openapi-bun.plugin.d.mts

@@ -0,0 +1,68 @@
+import type { NaviosPlugin, PluginContext, PluginDefinition } from '@navios/core';
+import type { ScalarOptions, ScalarTheme } from './schemas/index.mjs';
+import type { BunOpenApiPluginOptions } from './tokens/openapi-options.token.mjs';
+/**
+ * OpenAPI plugin for Bun adapter.
+ *
+ * This plugin:
+ * - Scans all registered modules for endpoints
+ * - Generates an OpenAPI 3.1 document
+ * - Injects controllers for JSON, YAML, and Scalar UI endpoints
+ *
+ * Unlike the Fastify plugin which registers routes directly,
+ * this plugin uses the standard Navios controller pattern via
+ * ModuleLoaderService.extendModules().
+ */
+export declare class OpenApiBunPlugin implements NaviosPlugin<BunOpenApiPluginOptions> {
+    readonly name = "openapi-bun";
+    register(context: PluginContext, options: BunOpenApiPluginOptions): Promise<void>;
+    /**
+     * Registers the plugin options in the DI container.
+     */
+    private registerOptions;
+    /**
+     * Registers and initializes the document service.
+     */
+    private initializeDocumentService;
+    /**
+     * Creates controller classes based on options.
+     */
+    private createControllers;
+}
+/**
+ * Creates a plugin definition for the OpenAPI Bun plugin.
+ *
+ * @param options - Plugin configuration options
+ * @returns Plugin definition to pass to `app.usePlugin()`
+ *
+ * @example
+ * ```typescript
+ * import { NaviosFactory } from '@navios/core'
+ * import { defineBunEnvironment } from '@navios/adapter-bun'
+ * import { defineOpenApiPlugin } from '@navios/openapi-bun'
+ *
+ * const app = await NaviosFactory.create(AppModule, {
+ *   adapter: defineBunEnvironment(),
+ * })
+ *
+ * app.usePlugin(defineOpenApiPlugin({
+ *   info: {
+ *     title: 'My API',
+ *     version: '1.0.0',
+ *     description: 'API documentation',
+ *   },
+ *   servers: [
+ *     { url: 'http://localhost:3000', description: 'Development' },
+ *   ],
+ *   scalar: {
+ *     theme: 'purple',
+ *   },
+ * }))
+ *
+ * await app.listen({ port: 3000 })
+ * // API docs available at http://localhost:3000/docs
+ * ```
+ */
+export declare function defineOpenApiPlugin(options: BunOpenApiPluginOptions): PluginDefinition<BunOpenApiPluginOptions>;
+export type { ScalarOptions, ScalarTheme, BunOpenApiPluginOptions };
+//# sourceMappingURL=openapi-bun.plugin.d.mts.map

package/dist/src/openapi-bun.plugin.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-bun.plugin.d.mts","sourceRoot":"","sources":["../../src/openapi-bun.plugin.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,gBAAgB,EACjB,MAAM,cAAc,CAAA;AAKrB,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACrE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAA;AASjF;;;;;;;;;;;GAWG;AACH,qBAAa,gBAAiB,YAAW,YAAY,CAAC,uBAAuB,CAAC;IAC5E,QAAQ,CAAC,IAAI,iBAAgB;IAEvB,QAAQ,CACZ,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,IAAI,CAAC;IAyBhB;;OAEG;IACH,OAAO,CAAC,eAAe;IAiBvB;;OAEG;YACW,yBAAyB;IAWvC;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAqB1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,uBAAuB,GAC/B,gBAAgB,CAAC,uBAAuB,CAAC,CAK3C;AAGD,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,uBAAuB,EAAE,CAAA"}

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

@@ -0,0 +1,2 @@
+export { bunOpenApiPluginOptionsSchema, scalarMetaDataSchema, scalarOptionsSchema, scalarThemeSchema, type BunOpenApiPluginOptionsBase, type ScalarMetaData, type ScalarOptions, type ScalarTheme, } from './openapi-bun-options.schema.mjs';
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/schemas/index.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,6BAA6B,EAC7B,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,KAAK,2BAA2B,EAChC,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,WAAW,GACjB,MAAM,kCAAkC,CAAA"}

package/dist/src/schemas/openapi-bun-options.schema.d.mts

@@ -0,0 +1,114 @@
+import { z } from 'zod';
+/**
+ * Zod schema for Scalar UI theme options
+ */
+export declare const scalarThemeSchema: z.ZodEnum<{
+    default: "default";
+    alternate: "alternate";
+    moon: "moon";
+    purple: "purple";
+    solarized: "solarized";
+    bluePlanet: "bluePlanet";
+    saturn: "saturn";
+    kepler: "kepler";
+    mars: "mars";
+    deepSpace: "deepSpace";
+    laserwave: "laserwave";
+    elysiajs: "elysiajs";
+    fastify: "fastify";
+    none: "none";
+}>;
+/**
+ * Zod schema for Scalar UI metadata
+ */
+export declare const scalarMetaDataSchema: z.ZodOptional<z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    ogDescription: z.ZodOptional<z.ZodString>;
+    ogTitle: z.ZodOptional<z.ZodString>;
+    ogImage: z.ZodOptional<z.ZodString>;
+    twitterCard: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+/**
+ * Zod schema for Scalar UI configuration options
+ */
+export declare const scalarOptionsSchema: z.ZodObject<{
+    theme: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        alternate: "alternate";
+        moon: "moon";
+        purple: "purple";
+        solarized: "solarized";
+        bluePlanet: "bluePlanet";
+        saturn: "saturn";
+        kepler: "kepler";
+        mars: "mars";
+        deepSpace: "deepSpace";
+        laserwave: "laserwave";
+        elysiajs: "elysiajs";
+        fastify: "fastify";
+        none: "none";
+    }>>;
+    favicon: z.ZodOptional<z.ZodString>;
+    logo: z.ZodOptional<z.ZodString>;
+    hideDownloadButton: z.ZodOptional<z.ZodBoolean>;
+    hideSearch: z.ZodOptional<z.ZodBoolean>;
+    customCss: z.ZodOptional<z.ZodString>;
+    metaData: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ogDescription: z.ZodOptional<z.ZodString>;
+        ogTitle: z.ZodOptional<z.ZodString>;
+        ogImage: z.ZodOptional<z.ZodString>;
+        twitterCard: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    cdn: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Zod schema for Bun OpenAPI plugin options
+ */
+export declare const bunOpenApiPluginOptionsSchema: z.ZodObject<{
+    jsonPath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    yamlPath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    docsPath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    scalar: z.ZodOptional<z.ZodObject<{
+        theme: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            alternate: "alternate";
+            moon: "moon";
+            purple: "purple";
+            solarized: "solarized";
+            bluePlanet: "bluePlanet";
+            saturn: "saturn";
+            kepler: "kepler";
+            mars: "mars";
+            deepSpace: "deepSpace";
+            laserwave: "laserwave";
+            elysiajs: "elysiajs";
+            fastify: "fastify";
+            none: "none";
+        }>>;
+        favicon: z.ZodOptional<z.ZodString>;
+        logo: z.ZodOptional<z.ZodString>;
+        hideDownloadButton: z.ZodOptional<z.ZodBoolean>;
+        hideSearch: z.ZodOptional<z.ZodBoolean>;
+        customCss: z.ZodOptional<z.ZodString>;
+        metaData: z.ZodOptional<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            ogDescription: z.ZodOptional<z.ZodString>;
+            ogTitle: z.ZodOptional<z.ZodString>;
+            ogImage: z.ZodOptional<z.ZodString>;
+            twitterCard: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        cdn: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    disableJson: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    disableScalar: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    disableYaml: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export type ScalarTheme = z.infer<typeof scalarThemeSchema>;
+export type ScalarMetaData = z.infer<typeof scalarMetaDataSchema>;
+export type ScalarOptions = z.infer<typeof scalarOptionsSchema>;
+export type BunOpenApiPluginOptionsBase = z.infer<typeof bunOpenApiPluginOptionsSchema>;
+//# sourceMappingURL=openapi-bun-options.schema.d.mts.map

package/dist/src/schemas/openapi-bun-options.schema.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-bun-options.schema.d.mts","sourceRoot":"","sources":["../../../src/schemas/openapi-bun-options.schema.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;EAe5B,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;kBASpB,CAAA;AAEb;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4C9B,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCxC,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACjE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA"}

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

@@ -0,0 +1,2 @@
+export { OpenApiDocumentService, OpenApiDocumentServiceToken, } from './openapi-document.service.mjs';
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/services/index.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,2BAA2B,GAC5B,MAAM,gCAAgC,CAAA"}

package/dist/src/services/openapi-document.service.d.mts

@@ -0,0 +1,38 @@
+import type { ModuleMetadata } from '@navios/core';
+import type { oas31 } from 'zod-openapi';
+import { InjectionToken } from '@navios/core';
+type OpenAPIObject = oas31.OpenAPIObject;
+/**
+ * Injection token for the document service
+ */
+export declare const OpenApiDocumentServiceToken: InjectionToken<OpenApiDocumentService, undefined, false>;
+/**
+ * Service that generates and caches the OpenAPI document.
+ *
+ * The document is generated once during plugin initialization
+ * and served by controllers.
+ */
+export declare class OpenApiDocumentService {
+    private options;
+    private generator;
+    private document;
+    private yamlDocument;
+    /**
+     * Initializes the document service by generating the OpenAPI document.
+     * Called by the plugin during registration.
+     *
+     * @param modules - All loaded modules with their metadata
+     * @param globalPrefix - Global route prefix (e.g., '/api/v1')
+     */
+    initialize(modules: Map<string, ModuleMetadata>, globalPrefix: string): void;
+    /**
+     * Returns the OpenAPI document as JSON-serializable object.
+     */
+    getDocument(): OpenAPIObject;
+    /**
+     * Returns the OpenAPI document as YAML string.
+     */
+    getYamlDocument(): string;
+}
+export {};
+//# sourceMappingURL=openapi-document.service.d.mts.map

package/dist/src/services/openapi-document.service.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-document.service.d.mts","sourceRoot":"","sources":["../../../src/services/openapi-document.service.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC,OAAO,EAAsB,cAAc,EAAE,MAAM,cAAc,CAAA;AAOjE,KAAK,aAAa,GAAG,KAAK,CAAC,aAAa,CAAA;AAExC;;GAEG;AACH,eAAO,MAAM,2BAA2B,0DAGrC,CAAA;AAEH;;;;;GAKG;AACH,qBAGa,sBAAsB;IACjC,OAAO,CAAC,OAAO,CAA8B;IAC7C,OAAO,CAAC,SAAS,CAAkC;IAEnD,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,YAAY,CAAsB;IAE1C;;;;;;OAMG;IACH,UAAU,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAgB5E;;OAEG;IACH,WAAW,IAAI,aAAa;IAS5B;;OAEG;IACH,eAAe,IAAI,MAAM;CAQ1B"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/tokens/index.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,KAAK,uBAAuB,EAAE,MAAM,6BAA6B,CAAA"}