@navios/core 0.1.0

package/dist/index.d.ts

@@ -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 };