@navios/core 0.1.0

package/LICENSE

@@ -0,0 +1,7 @@
+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,145 @@
+# Navios
+
+Navios is a Type-Safe HTTP Server with Zod Validation.
+
+It is a powerful tool for building robust and type-safe APIs using TypeScript. It leverages the power of Zod for validation and provides a simple and intuitive API for defining endpoints, request and response schemas, and handling errors.
+
+It uses Fastify under the hood, which is a fast and low-overhead web framework for Node.js. This allows Navios to provide high performance and low latency for your APIs.
+
+## Features
+
+- **Type Safety**: Navios provides a type-safe API for defining endpoints, request and response schemas. This ensures that your API is always type-safe and reduces the risk of runtime errors.
+- **Validation**: Zod provides powerful validation capabilities, allowing you to define complex validation rules for your data. This ensures that the data you work with is always valid and meets your requirements.
+- **Build with Navios Builder**: Navios Builder is a powerful HTTP client that simplifies API requests. By combining it with Navios, you can use the same API definition for both the client and server, ensuring consistency and reducing duplication.
+- **Declarative API**: The API is designed to be declarative, allowing you to define your API endpoints and their schemas in a clear and concise manner. This makes it easy to understand and maintain your API client.
+- **Customizable**: The package allows you to customize the behavior of the API client, such as using a custom client.
+- **Error Handling**: The package provides built-in error handling capabilities, allowing you to handle API errors gracefully and provide meaningful feedback to users.
+
+## Main Concepts
+
+- **Module**: A module is a collection of controllers, and other modules. It is used to group related functionality together and provide a clear structure for your API. It also can define some shared guards and attributes.
+- **Controller**: A controller is a class that defines a set of endpoints for a specific resource. It is used to handle incoming requests and return responses. Controllers can also define guards and attributes that apply to all endpoints in the controller.
+- **Endpoint**: An endpoint is a specific route in your API that handles a specific request. It used original endpoint definition from Navios Builder, and a set of request and response schemas. Endpoints can also define guards and attributes that apply to the endpoint.
+- **Service**: A service is a class that defines the business logic for a specific resource. It is used to separate the business logic from the controller and provide a clear structure for your API.
+- **Guard**: A guard is a class that is used to validate incoming requests and ensure that they meet certain criteria. Guards can be used to validate request parameters, headers, and body. They can also be used to check authentication and authorization.
+- **Attribute**: An attribute is a decorator that is used to add metadata to a class or method. Attributes can be used in guards, controllers, modules, and endpoints to provide additional information about the class or method.
+ 
+
+## Getting Started
+
+### Define your API
+
+Define your API in a shared location accessible to both the client and server. This allows you to use the same API definition for both the client and server, ensuring consistency and reducing duplication.
+
+```ts
+import { builder } from '@navios/core'
+import { z } from 'zod'
+
+const api = builder({
+  useDiscriminatorResponse: true,
+})
+
+const login = api.declareEndpoint({
+  method: 'post',
+  url: '/login',
+  requestSchema: z.object({
+    email: z.string().email(),
+    password: z.string().min(6),
+  }),
+  responseSchema: z.discriminatedUnion('success', [
+    z.object({
+      success: z.literal(true),
+      user: z.object({
+        id: z.string(),
+        name: z.string(),
+        email: z.string().email(),
+      }),
+    }),
+    z.object({
+      success: z.literal(false),
+      error: z.string(),
+    }),
+  ]),
+})
+```
+
+### Create your server
+
+```bash
+yarn install --save @navios/core @navios/common zod
+```
+
+Create AuthService:
+
+```ts
+import { Injectable } from '@navios/core'
+
+@Injectable()
+export class LoginService {
+  async login(email: string, password: string) {
+    // Perform your login logic here
+    // For example, check the email and password against a database
+  }
+}
+```
+
+Create your first Controller:
+
+```ts
+import { Controller, Endpoint, type EndpointParams, syncInject } from '@navios/core'
+
+import { AuthService } from './auth.service.mjs'
+
+@Controller()
+export class AuthController {
+  // Inject the LoginService
+  loginService = syncInject(LoginService)
+
+  @Endpoint(login)
+  async login(request: EndpointParams<typeof login>) {
+    // Handle the login request
+    const { email, password } = request
+
+    // Perform your login logic here
+    const user = await this.loginService.login(email, password)
+
+    if (user) {
+      return { success: true, user }
+    } else {
+      return { success: false, error: 'Invalid credentials' }
+    }
+  }
+}
+```
+Create your AppModule:
+
+```ts
+import { Module } from '@navios/core'
+
+import { AuthController } from './auth.controller.mjs'
+
+@Module({
+  controllers: [AuthController],
+})
+export class AppModule {}
+```
+
+Create your server:
+
+```ts
+import { NaviosFactory } from '@navios/core'
+import { AppModule } from './src/app.module.mjs'
+
+export async function boot() {
+  const app = await NaviosFactory.create(AppModule)
+  app.setGlobalPrefix('/api')
+  app.enableCors({
+    methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
+  })
+  await app.init()
+  await app.listen({ port: 3000, host: '0.0.0.0' })
+}
+await boot()
+```
+
+That's it! You have created your first Navios server. You can now run your server and test the `/api/login` endpoint.

package/dist/index.d.mts

@@ -0,0 +1,425 @@
+import { AnyZodObject, z, ZodType } from 'zod';
+import { BaseEndpointConfig, EndpointFunctionArgs, HttpMethod } from '@navios/common';
+import * as fastify from 'fastify';
+import { FastifyRequest, FastifyReply, FastifyInstance, FastifyServerOptions, FastifyListenOptions } from 'fastify';
+import * as http from 'http';
+import * as fastify_types_type_provider_js from 'fastify/types/type-provider.js';
+import { FastifyCorsOptions } from '@fastify/cors';
+
+type ClassType = new (...args: any[]) => any;
+type ClassTypeWithInstance<T> = new (...args: any[]) => T;
+declare class InjectionToken<T, S extends AnyZodObject | unknown = unknown> {
+    readonly name: string | symbol | ClassType;
+    readonly schema: AnyZodObject | undefined;
+    id: `${string}-${string}-${string}-${string}-${string}`;
+    constructor(name: string | symbol | ClassType, schema: AnyZodObject | undefined);
+    static create<T extends ClassType>(name: T): InjectionToken<InstanceType<T>, undefined>;
+    static create<T extends ClassType, Schema extends AnyZodObject>(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>;
+    static create<T>(name: string): InjectionToken<T, undefined>;
+    static create<T, Schema extends AnyZodObject>(name: string, schema: Schema): InjectionToken<T, Schema>;
+    toString(): string | symbol | ClassType;
+}
+
+declare function getInjectableToken<R, T extends ClassTypeWithInstance<R>>(target: ClassType): R extends {
+    create(...args: any[]): infer V;
+} ? InjectionToken<V> : InjectionToken<R>;
+
+declare enum InjectableScope {
+    /**
+     * Singleton scope: The instance is created once and shared across the application.
+     */
+    Singleton = "Singleton",
+    /**
+     * Instance scope: A new instance is created for each injection.
+     */
+    Instance = "Instance"
+}
+
+declare enum InjectableType {
+    Class = "Class",
+    Factory = "Factory"
+}
+interface InjectableOptions {
+    scope?: InjectableScope;
+    type?: InjectableType;
+    token?: InjectionToken<any, any>;
+}
+declare const InjectableTokenMeta: unique symbol;
+declare function Injectable({ scope, type, token, }?: InjectableOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
+
+declare enum ErrorsEnum {
+    InstanceExpired = "InstanceExpired",
+    InstanceNotFound = "InstanceNotFound",
+    InstanceDestroying = "InstanceDestroying",
+    UnknownError = "UnknownError",
+    FactoryNotFound = "FactoryNotFound"
+}
+
+declare class FactoryNotFound extends Error {
+    name: string;
+    code: ErrorsEnum;
+    constructor(name: string);
+}
+
+declare class InstanceDestroying extends Error {
+    name: string;
+    code: ErrorsEnum;
+    constructor(name: string);
+}
+
+declare class InstanceExpired extends Error {
+    name: string;
+    code: ErrorsEnum;
+    constructor(name: string);
+}
+
+declare class InstanceNotFound extends Error {
+    name: string;
+    code: ErrorsEnum;
+    constructor(name: string);
+}
+
+declare class UnknownError extends Error {
+    code: ErrorsEnum;
+    parent?: Error;
+    constructor(message: string | Error);
+}
+
+type EventsConfig = {
+    [event: string]: any[];
+};
+type EventsNames<Events extends EventsConfig> = Exclude<keyof Events, symbol | number>;
+type EventsArgs<Events extends EventsConfig, Name extends EventsNames<Events>> = Events[Name] extends any[] ? Events[Name] : [];
+type ChannelEmitter<Events extends EventsConfig, Ns extends string, E extends EventsNames<Events>> = {
+    emit<Args extends EventsArgs<Events, E>>(ns: Ns, event: E, ...args: Args): Promise<any>;
+};
+interface EventEmitterInterface<Events extends EventsConfig> {
+    on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void): () => void;
+    emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, ...args: Args): void;
+    addChannel<E extends EventsNames<Events>, Ns extends string, Emmiter extends ChannelEmitter<Events, Ns, E>>(ns: Ns, event: E, target: Emmiter): () => void;
+}
+declare class EventEmitter<Events extends EventsConfig = {}> implements EventEmitterInterface<Events> {
+    private listeners;
+    on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void): () => void;
+    off<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void): void;
+    once<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void): () => void;
+    emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, ...args: Args): Promise<any>;
+    addChannel<E extends EventsNames<Events>, Ns extends string, Emitter extends ChannelEmitter<Events, Ns, E>>(ns: Ns, event: E, target: Emitter): () => void;
+}
+
+declare function inject<T extends ClassType>(token: T): Promise<InstanceType<T>>;
+declare function inject<T, S extends AnyZodObject>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
+declare function inject<T>(token: InjectionToken<T, undefined>): Promise<T>;
+
+declare class ServiceLocatorEventBus {
+    private readonly logger;
+    private listeners;
+    constructor(logger?: Console | null);
+    on<Event extends string | `pre:${string}` | `post:${string}`>(ns: string, event: Event, listener: (event: Event) => void): () => void;
+    emit(key: string, event: string): Promise<PromiseSettledResult<any>[] | undefined>;
+}
+
+interface ServiceLocatorAbstractFactoryContext {
+    inject: typeof inject;
+    addDependency: ((token: InjectionToken<any, undefined>) => void) | (<S extends AnyZodObject>(token: InjectionToken<any, S>, args: z.input<S>) => void);
+    on: ServiceLocatorEventBus['on'];
+    getDependencies: () => string[];
+    invalidate: () => void;
+    addEffect: (listener: () => void) => void;
+    getDestroyListeners: () => (() => void)[];
+    setTtl: (ttl: number) => void;
+    getTtl: () => number;
+}
+
+declare class ServiceLocator {
+    private readonly logger;
+    private abstractFactories;
+    private instanceFactories;
+    private readonly eventBus;
+    private readonly manager;
+    constructor(logger?: Console | null);
+    getEventBus(): ServiceLocatorEventBus;
+    registerInstance<Instance>(token: InjectionToken<Instance, undefined>, instance: Instance): void;
+    removeInstance<Instance>(token: InjectionToken<Instance, undefined>): Promise<any>;
+    registerAbstractFactory<Instance, Schema extends AnyZodObject | undefined>(token: InjectionToken<Instance, Schema>, factory: (ctx: ServiceLocatorAbstractFactoryContext, values: Schema extends AnyZodObject ? z.output<Schema> : undefined) => Promise<Instance>, type?: InjectableScope): void;
+    getInstanceIdentifier<Instance, Schema extends AnyZodObject | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : undefined): string;
+    getInstance<Instance, Schema extends AnyZodObject | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : undefined): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getOrThrowInstance<Instance, Schema extends AnyZodObject | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : undefined): Promise<Instance>;
+    private notifyListeners;
+    private createInstance;
+    private createInstanceFromAbstractFactory;
+    private createContextForAbstractFactory;
+    getSyncInstance<Instance, Schema extends AnyZodObject | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : undefined): Instance | null;
+    invalidate(service: string, round?: number): Promise<any>;
+    ready(): Promise<null>;
+    makeInstanceName(token: InjectionToken<any, any>, args: any): string;
+}
+
+declare function provideServiceLocator(locator: ServiceLocator): ServiceLocator;
+declare function getServiceLocator(): ServiceLocator;
+
+/**
+ * Useful for tests or when you want to override a service
+ * with a different implementation.
+ */
+declare function override<T>(token: InjectionToken<T>, target: ClassType): () => void;
+
+declare enum ServiceLocatorInstanceHolderKind {
+    Instance = "instance",
+    Factory = "factory",
+    AbstractFactory = "abstractFactory"
+}
+declare enum ServiceLocatorInstanceHolderStatus {
+    Created = "created",
+    Creating = "creating",
+    Destroying = "destroying"
+}
+type ServiceLocatorInstanceEffect = () => void;
+type ServiceLocatorInstanceDestroyListener = () => void | Promise<void>;
+interface ServiceLocatorInstanceHolderCreating<Instance> {
+    status: ServiceLocatorInstanceHolderStatus.Creating;
+    name: string;
+    instance: null;
+    creationPromise: Promise<[undefined, Instance]> | null;
+    destroyPromise: null;
+    kind: ServiceLocatorInstanceHolderKind;
+    effects: ServiceLocatorInstanceEffect[];
+    deps: string[];
+    destroyListeners: ServiceLocatorInstanceDestroyListener[];
+    createdAt: number;
+    ttl: number;
+}
+interface ServiceLocatorInstanceHolderCreated<Instance> {
+    status: ServiceLocatorInstanceHolderStatus.Created;
+    name: string;
+    instance: Instance;
+    creationPromise: null;
+    destroyPromise: null;
+    kind: ServiceLocatorInstanceHolderKind;
+    effects: ServiceLocatorInstanceEffect[];
+    deps: string[];
+    destroyListeners: ServiceLocatorInstanceDestroyListener[];
+    createdAt: number;
+    ttl: number;
+}
+interface ServiceLocatorInstanceHolderDestroying<Instance> {
+    status: ServiceLocatorInstanceHolderStatus.Destroying;
+    name: string;
+    instance: Instance | null;
+    creationPromise: null;
+    destroyPromise: Promise<void>;
+    kind: ServiceLocatorInstanceHolderKind;
+    effects: ServiceLocatorInstanceEffect[];
+    deps: string[];
+    destroyListeners: ServiceLocatorInstanceDestroyListener[];
+    createdAt: number;
+    ttl: number;
+}
+type ServiceLocatorInstanceHolder<Instance = unknown> = ServiceLocatorInstanceHolderCreating<Instance> | ServiceLocatorInstanceHolderCreated<Instance> | ServiceLocatorInstanceHolderDestroying<Instance>;
+
+declare class ServiceLocatorManager {
+    private readonly logger;
+    private readonly instancesHolders;
+    constructor(logger?: Console | null);
+    get(name: string): [InstanceExpired | InstanceDestroying, ServiceLocatorInstanceHolder] | [InstanceNotFound] | [undefined, ServiceLocatorInstanceHolder];
+    set(name: string, holder: ServiceLocatorInstanceHolder): void;
+    has(name: string): [InstanceExpired | InstanceDestroying] | [undefined, boolean];
+    delete(name: string): boolean;
+    filter(predicate: (value: ServiceLocatorInstanceHolder<any>, key: string) => boolean): Map<string, ServiceLocatorInstanceHolder>;
+}
+
+declare let promiseCollector: null | ((promise: Promise<any>) => void);
+declare function syncInject<T extends ClassType>(token: T): InstanceType<T>;
+declare function syncInject<T, S extends AnyZodObject>(token: InjectionToken<T, S>, args: z.input<S>): T;
+declare function syncInject<T>(token: InjectionToken<T, undefined>): T;
+declare function setPromiseCollector(collector: null | ((promise: Promise<any>) => void)): typeof promiseCollector;
+
+interface ControllerOptions {
+    guards?: ClassType[] | Set<ClassType>;
+}
+declare function Controller({ guards }?: ControllerOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
+
+type EndpointParams<EndpointDeclaration extends {
+    config: BaseEndpointConfig<any, any, any, any, any>;
+}, Url extends string = EndpointDeclaration['config']['url'], QuerySchema = EndpointDeclaration['config']['querySchema']> = QuerySchema extends AnyZodObject ? EndpointDeclaration['config']['requestSchema'] extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, EndpointDeclaration['config']['requestSchema']> : EndpointFunctionArgs<Url, QuerySchema, undefined> : EndpointDeclaration['config']['requestSchema'] extends ZodType ? EndpointFunctionArgs<Url, undefined, EndpointDeclaration['config']['requestSchema']> : EndpointFunctionArgs<Url, undefined, undefined>;
+declare function Endpoint<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, ResponseSchema extends ZodType = ZodType, RequestSchema = ZodType>(endpoint: {
+    config: BaseEndpointConfig<Method, Url, QuerySchema, ResponseSchema, RequestSchema>;
+}): (target: (params: QuerySchema extends AnyZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema> : EndpointFunctionArgs<Url, QuerySchema, undefined> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema> : EndpointFunctionArgs<Url, undefined, undefined>) => z.input<ResponseSchema>, context: ClassMethodDecoratorContext) => (params: QuerySchema extends AnyZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema> : EndpointFunctionArgs<Url, QuerySchema, undefined> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema> : EndpointFunctionArgs<Url, undefined, undefined>) => z.input<ResponseSchema>;
+
+interface ModuleOptions {
+    controllers?: ClassType[] | Set<ClassType>;
+    imports?: ClassType[] | Set<ClassType>;
+    guards?: ClassType[] | Set<ClassType>;
+}
+declare function Module(metadata: ModuleOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
+
+declare const EndpointMetadataKey: unique symbol;
+interface EndpointMetadata {
+    classMethod: string;
+    url: string;
+    httpMethod: HttpMethod;
+    config: BaseEndpointConfig | null;
+    guards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+    customAttributes: Map<string | symbol, any>;
+}
+declare function getAllEndpointMetadata(context: ClassMethodDecoratorContext | ClassDecoratorContext): Set<EndpointMetadata>;
+declare function getEndpointMetadata(target: Function, context: ClassMethodDecoratorContext): EndpointMetadata;
+
+declare const ControllerMetadataKey: unique symbol;
+interface ControllerMetadata {
+    endpoints: Set<EndpointMetadata>;
+    guards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+    customAttributes: Map<string | symbol, any>;
+}
+declare function getControllerMetadata(target: ClassType, context: ClassDecoratorContext): ControllerMetadata;
+declare function extractControllerMetadata(target: ClassType): ControllerMetadata;
+declare function hasControllerMetadata(target: ClassType): boolean;
+
+interface InjectableMetadata<Instance = any, Schema = any> {
+    type: InjectableType;
+    scope: InjectableScope;
+    token: InjectionToken<Instance, Schema>;
+}
+
+declare const ModuleMetadataKey: unique symbol;
+interface ModuleMetadata {
+    controllers: Set<ClassType>;
+    imports: Set<ClassType>;
+    guards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+    customAttributes: Map<string | symbol, any>;
+}
+declare function getModuleMetadata(target: ClassType, context: ClassDecoratorContext): ModuleMetadata;
+declare function extractModuleMetadata(target: ClassType): ModuleMetadata;
+declare function hasModuleMetadata(target: ClassType): boolean;
+
+declare class ExecutionContext {
+    private readonly module;
+    private readonly controller;
+    private readonly handler;
+    private request;
+    private reply;
+    constructor(module: ModuleMetadata, controller: ControllerMetadata, handler: EndpointMetadata);
+    getModule(): ModuleMetadata;
+    getController(): ControllerMetadata;
+    getHandler(): EndpointMetadata;
+    getRequest(): FastifyRequest;
+    getReply(): FastifyReply;
+    provideRequest(request: FastifyRequest): void;
+    provideReply(reply: FastifyReply): void;
+}
+
+declare class GuardRunnerService {
+    runGuards(allGuards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>, executionContext: ExecutionContext): Promise<boolean>;
+    makeContext(executionContext: ExecutionContext): Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+}
+
+declare class ControllerAdapterService {
+    guardRunner: GuardRunnerService;
+    setupController(controller: ClassType, instance: FastifyInstance, moduleMetadata: ModuleMetadata): void;
+}
+
+declare class ModuleLoaderService {
+    private modulesMetadata;
+    private loadedModules;
+    private initialized;
+    loadModules(appModule: ClassTypeWithInstance<NaviosModule>): Promise<void>;
+    private traverseModules;
+    private mergeMetadata;
+    getAllModules(): Map<string, ModuleMetadata>;
+}
+
+interface CanActivate {
+    canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean;
+}
+
+interface NaviosModule {
+    onModuleInit?: () => Promise<void> | void;
+}
+
+declare function UseGuards(...guards: (ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>)[]): <T extends Function>(target: T, context: ClassMethodDecoratorContext | ClassDecoratorContext) => T;
+
+declare class HttpException {
+    readonly statusCode: number;
+    readonly response: string | object;
+    readonly error?: Error | undefined;
+    constructor(statusCode: number, response: string | object, error?: Error | undefined);
+}
+
+declare class BadRequestException extends HttpException {
+    constructor(message: string | object);
+}
+
+declare class ForbiddenException extends HttpException {
+    constructor(message: string);
+}
+
+declare class InternalServerErrorException extends HttpException {
+    constructor(message: string | object, error?: Error);
+}
+
+declare class NotFoundException extends HttpException {
+    readonly response: string | object;
+    readonly error?: Error | undefined;
+    constructor(response: string | object, error?: Error | undefined);
+}
+
+declare class UnauthorizedException extends HttpException {
+    constructor(message: string | object, error?: Error);
+}
+
+declare class ConflictException extends HttpException {
+    constructor(message: string | object, error?: Error);
+}
+
+declare const Application: InjectionToken<FastifyInstance<fastify.RawServerDefault, http.IncomingMessage, http.ServerResponse<http.IncomingMessage>, fastify.FastifyBaseLogger, fastify.FastifyTypeProviderDefault>, undefined>;
+
+declare const ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
+declare const ExecutionContextToken: InjectionToken<ExecutionContext, undefined>;
+
+declare const Reply: InjectionToken<FastifyReply<fastify.RouteGenericInterface, fastify.RawServerDefault, http.IncomingMessage, http.ServerResponse<http.IncomingMessage>, unknown, fastify.FastifySchema, fastify.FastifyTypeProviderDefault, unknown>, undefined>;
+
+declare const Request: InjectionToken<FastifyRequest<fastify.RouteGenericInterface, fastify.RawServerDefault, http.IncomingMessage, fastify.FastifySchema, fastify.FastifyTypeProviderDefault, unknown, fastify.FastifyBaseLogger, fastify_types_type_provider_js.ResolveFastifyRequestType<fastify.FastifyTypeProviderDefault, fastify.FastifySchema, fastify.RouteGenericInterface>>, undefined>;
+
+type ClassAttribute = (() => <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T) & {
+    token: symbol;
+};
+type ClassSchemaAttribute<T extends ZodType> = ((value: z.input<T>) => <T extends ClassType>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T) & {
+    token: symbol;
+    schema: ZodType;
+};
+declare class AttributeFactory {
+    static createAttribute(token: symbol): ClassAttribute;
+    static createAttribute<T extends ZodType>(token: symbol, value: z.input<T>): ClassSchemaAttribute<T>;
+    static get(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): true | null;
+    static get<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): z.output<T> | null;
+    static getAll(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): Array<true> | null;
+    static getAll<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): Array<z.output<T>> | null;
+    static getLast(attribute: ClassAttribute, target: (ModuleMetadata | ControllerMetadata | EndpointMetadata)[]): true | null;
+    static getLast<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: (ModuleMetadata | ControllerMetadata | EndpointMetadata)[]): z.output<T> | null;
+    static has(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): boolean;
+    static has<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): boolean;
+}
+
+interface NaviosApplicationOptions extends FastifyServerOptions {
+}
+declare class NaviosApplication {
+    private moduleLoader;
+    private controllerAdapter;
+    private server;
+    private corsOptions;
+    private globalPrefix;
+    private appModule;
+    private options;
+    setup(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): void;
+    init(): Promise<void>;
+    enableCors(options: FastifyCorsOptions): void;
+    setGlobalPrefix(prefix: string): void;
+    getServer(): FastifyInstance;
+    listen(options: FastifyListenOptions): Promise<void>;
+}
+
+declare class NaviosFactory {
+    static create(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): Promise<NaviosApplication>;
+}
+
+export { Application, AttributeFactory, BadRequestException, type CanActivate, type ChannelEmitter, type ClassAttribute, type ClassSchemaAttribute, type ClassType, type ClassTypeWithInstance, ConflictException, Controller, ControllerAdapterService, type ControllerMetadata, ControllerMetadataKey, type ControllerOptions, Endpoint, type EndpointMetadata, EndpointMetadataKey, type EndpointParams, ErrorsEnum, EventEmitter, type EventEmitterInterface, type EventsArgs, type EventsConfig, type EventsNames, ExecutionContext, ExecutionContextInjectionToken, ExecutionContextToken, FactoryNotFound, ForbiddenException, GuardRunnerService, HttpException, Injectable, type InjectableMetadata, type InjectableOptions, InjectableScope, InjectableTokenMeta, InjectableType, InjectionToken, InstanceDestroying, InstanceExpired, InstanceNotFound, InternalServerErrorException, Module, ModuleLoaderService, type ModuleMetadata, ModuleMetadataKey, type ModuleOptions, NaviosApplication, type NaviosApplicationOptions, NaviosFactory, type NaviosModule, NotFoundException, Reply, Request, ServiceLocator, type ServiceLocatorAbstractFactoryContext, ServiceLocatorEventBus, type ServiceLocatorInstanceDestroyListener, type ServiceLocatorInstanceEffect, type ServiceLocatorInstanceHolder, type ServiceLocatorInstanceHolderCreated, type ServiceLocatorInstanceHolderCreating, type ServiceLocatorInstanceHolderDestroying, ServiceLocatorInstanceHolderKind, ServiceLocatorInstanceHolderStatus, ServiceLocatorManager, UnauthorizedException, UnknownError, UseGuards, extractControllerMetadata, extractModuleMetadata, getAllEndpointMetadata, getControllerMetadata, getEndpointMetadata, getInjectableToken, getModuleMetadata, getServiceLocator, hasControllerMetadata, hasModuleMetadata, inject, override, provideServiceLocator, setPromiseCollector, syncInject };