@noxfly/noxus 2.5.0 → 3.0.0-dev.1

package/dist/app-injector-Bz3Upc0y.d.mts

@@ -0,0 +1,125 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+/**
+ * Represents a generic type that can be either a value or a promise resolving to that value.
+ */
+type MaybeAsync<T> = T | Promise<T>;
+
+
+/**
+ * A function that returns a type.
+ * Used for forward references to types that are not yet defined.
+ */
+interface ForwardRefFn<T = any> {
+    (): Type<T>;
+}
+/**
+ * A wrapper class for forward referenced types.
+ */
+declare class ForwardReference<T = any> {
+    readonly forwardRefFn: ForwardRefFn<T>;
+    constructor(forwardRefFn: ForwardRefFn<T>);
+}
+/**
+ * Creates a forward reference to a type.
+ * @param fn A function that returns the type.
+ * @returns A ForwardReference instance.
+ */
+declare function forwardRef<T = any>(fn: ForwardRefFn<T>): ForwardReference<T>;
+
+
+/**
+ * A DI token uniquely identifies a dependency.
+ * It can wrap a class (Type<T>) or be a named symbol token.
+ *
+ * Using tokens instead of reflect-metadata means dependencies are
+ * declared explicitly — no magic type inference, no emitDecoratorMetadata.
+ *
+ * @example
+ * // Class token (most common)
+ * const MY_SERVICE = token(MyService);
+ *
+ * // Named symbol token (for interfaces or non-class values)
+ * const DB_URL = token<string>('DB_URL');
+ */
+declare class Token<T> {
+    readonly target: Type<T> | string;
+    readonly description: string;
+    constructor(target: Type<T> | string);
+    toString(): string;
+}
+/**
+ * Creates a DI token for a class type or a named value.
+ *
+ * @example
+ * export const MY_SERVICE = token(MyService);
+ * export const DB_URL = token<string>('DB_URL');
+ */
+declare function token<T>(target: Type<T> | string): Token<T>;
+/**
+ * The key used to look up a class token in the registry.
+ * For class tokens, the key is the class constructor itself.
+ * For named tokens, the key is the Token instance.
+ */
+type TokenKey<T = unknown> = Type<T> | Token<T>;
+
+
+/**
+ * Lifetime of a binding in the DI container.
+ * - singleton: created once, shared for the lifetime of the app.
+ * - scope:     created once per request scope.
+ * - transient: new instance every time it is resolved.
+ */
+type Lifetime = 'singleton' | 'scope' | 'transient';
+/**
+ * Internal representation of a registered binding.
+ */
+interface IBinding<T = unknown> {
+    lifetime: Lifetime;
+    implementation: Type<T>;
+    /** Explicit constructor dependencies, declared by the class itself. */
+    deps: ReadonlyArray<TokenKey>;
+    instance?: T;
+}
+/**
+ * AppInjector is the core DI container.
+ * It no longer uses reflect-metadata — all dependency information
+ * comes from explicitly declared `deps` arrays on each binding.
+ */
+declare class AppInjector {
+    readonly name: string | null;
+    readonly bindings: Map<Type<unknown> | Token<unknown>, IBinding<unknown>>;
+    readonly singletons: Map<Type<unknown> | Token<unknown>, unknown>;
+    readonly scoped: Map<Type<unknown> | Token<unknown>, unknown>;
+    constructor(name?: string | null);
+    /**
+     * Creates a child scope for per-request lifetime resolution.
+     */
+    createScope(): AppInjector;
+    /**
+     * Registers a binding explicitly.
+     */
+    register<T>(key: TokenKey<T>, implementation: Type<T>, lifetime: Lifetime, deps?: ReadonlyArray<TokenKey>): void;
+    /**
+     * Resolves a dependency by token or class reference.
+     */
+    resolve<T>(target: TokenKey<T> | ForwardReference<T>): T;
+    private _resolveForwardRef;
+    private _instantiate;
+}
+/**
+ * The global root injector. All singletons live here.
+ */
+declare const RootInjector: AppInjector;
+/**
+ * Convenience function: resolve a token from the root injector.
+ */
+declare function inject<T>(t: TokenKey<T> | ForwardReference<T>): T;
+
+export { AppInjector as A, type ForwardRefFn as F, type IBinding as I, type Lifetime as L, type MaybeAsync as M, RootInjector as R, type Type as T, type TokenKey as a, ForwardReference as b, Token as c, forwardRef as f, inject as i, token as t };

package/dist/app-injector-Bz3Upc0y.d.ts

@@ -0,0 +1,125 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+/**
+ * Represents a generic type that can be either a value or a promise resolving to that value.
+ */
+type MaybeAsync<T> = T | Promise<T>;
+
+
+/**
+ * A function that returns a type.
+ * Used for forward references to types that are not yet defined.
+ */
+interface ForwardRefFn<T = any> {
+    (): Type<T>;
+}
+/**
+ * A wrapper class for forward referenced types.
+ */
+declare class ForwardReference<T = any> {
+    readonly forwardRefFn: ForwardRefFn<T>;
+    constructor(forwardRefFn: ForwardRefFn<T>);
+}
+/**
+ * Creates a forward reference to a type.
+ * @param fn A function that returns the type.
+ * @returns A ForwardReference instance.
+ */
+declare function forwardRef<T = any>(fn: ForwardRefFn<T>): ForwardReference<T>;
+
+
+/**
+ * A DI token uniquely identifies a dependency.
+ * It can wrap a class (Type<T>) or be a named symbol token.
+ *
+ * Using tokens instead of reflect-metadata means dependencies are
+ * declared explicitly — no magic type inference, no emitDecoratorMetadata.
+ *
+ * @example
+ * // Class token (most common)
+ * const MY_SERVICE = token(MyService);
+ *
+ * // Named symbol token (for interfaces or non-class values)
+ * const DB_URL = token<string>('DB_URL');
+ */
+declare class Token<T> {
+    readonly target: Type<T> | string;
+    readonly description: string;
+    constructor(target: Type<T> | string);
+    toString(): string;
+}
+/**
+ * Creates a DI token for a class type or a named value.
+ *
+ * @example
+ * export const MY_SERVICE = token(MyService);
+ * export const DB_URL = token<string>('DB_URL');
+ */
+declare function token<T>(target: Type<T> | string): Token<T>;
+/**
+ * The key used to look up a class token in the registry.
+ * For class tokens, the key is the class constructor itself.
+ * For named tokens, the key is the Token instance.
+ */
+type TokenKey<T = unknown> = Type<T> | Token<T>;
+
+
+/**
+ * Lifetime of a binding in the DI container.
+ * - singleton: created once, shared for the lifetime of the app.
+ * - scope:     created once per request scope.
+ * - transient: new instance every time it is resolved.
+ */
+type Lifetime = 'singleton' | 'scope' | 'transient';
+/**
+ * Internal representation of a registered binding.
+ */
+interface IBinding<T = unknown> {
+    lifetime: Lifetime;
+    implementation: Type<T>;
+    /** Explicit constructor dependencies, declared by the class itself. */
+    deps: ReadonlyArray<TokenKey>;
+    instance?: T;
+}
+/**
+ * AppInjector is the core DI container.
+ * It no longer uses reflect-metadata — all dependency information
+ * comes from explicitly declared `deps` arrays on each binding.
+ */
+declare class AppInjector {
+    readonly name: string | null;
+    readonly bindings: Map<Type<unknown> | Token<unknown>, IBinding<unknown>>;
+    readonly singletons: Map<Type<unknown> | Token<unknown>, unknown>;
+    readonly scoped: Map<Type<unknown> | Token<unknown>, unknown>;
+    constructor(name?: string | null);
+    /**
+     * Creates a child scope for per-request lifetime resolution.
+     */
+    createScope(): AppInjector;
+    /**
+     * Registers a binding explicitly.
+     */
+    register<T>(key: TokenKey<T>, implementation: Type<T>, lifetime: Lifetime, deps?: ReadonlyArray<TokenKey>): void;
+    /**
+     * Resolves a dependency by token or class reference.
+     */
+    resolve<T>(target: TokenKey<T> | ForwardReference<T>): T;
+    private _resolveForwardRef;
+    private _instantiate;
+}
+/**
+ * The global root injector. All singletons live here.
+ */
+declare const RootInjector: AppInjector;
+/**
+ * Convenience function: resolve a token from the root injector.
+ */
+declare function inject<T>(t: TokenKey<T> | ForwardReference<T>): T;
+
+export { AppInjector as A, type ForwardRefFn as F, type IBinding as I, type Lifetime as L, type MaybeAsync as M, RootInjector as R, type Type as T, type TokenKey as a, ForwardReference as b, Token as c, forwardRef as f, inject as i, token as t };

package/dist/child.d.mts

@@ -1,11 +1,119 @@
-import { L as Lifetime } from './app-injector-B3MvgV3k.mjs';
-export { A as AppInjector, F as ForwardRefFn, a as ForwardReference, I as IBinding, M as MaybeAsync, R as RootInjector, T as Type, f as forwardRef, i as inject } from './app-injector-B3MvgV3k.mjs';
-
 /**
  * @copyright 2025 NoxFly
  * @license MIT
  * @author NoxFly
  */
+interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+/**
+ * Represents a generic type that can be either a value or a promise resolving to that value.
+ */
+type MaybeAsync<T> = T | Promise<T>;
+
+
+/**
+ * A function that returns a type.
+ * Used for forward references to types that are not yet defined.
+ */
+interface ForwardRefFn<T = any> {
+    (): Type<T>;
+}
+/**
+ * A wrapper class for forward referenced types.
+ */
+declare class ForwardReference<T = any> {
+    readonly forwardRefFn: ForwardRefFn<T>;
+    constructor(forwardRefFn: ForwardRefFn<T>);
+}
+/**
+ * Creates a forward reference to a type.
+ * @param fn A function that returns the type.
+ * @returns A ForwardReference instance.
+ */
+declare function forwardRef<T = any>(fn: ForwardRefFn<T>): ForwardReference<T>;
+
+
+/**
+ * A DI token uniquely identifies a dependency.
+ * It can wrap a class (Type<T>) or be a named symbol token.
+ *
+ * Using tokens instead of reflect-metadata means dependencies are
+ * declared explicitly — no magic type inference, no emitDecoratorMetadata.
+ *
+ * @example
+ * // Class token (most common)
+ * const MY_SERVICE = token(MyService);
+ *
+ * // Named symbol token (for interfaces or non-class values)
+ * const DB_URL = token<string>('DB_URL');
+ */
+declare class Token<T> {
+    readonly target: Type<T> | string;
+    readonly description: string;
+    constructor(target: Type<T> | string);
+    toString(): string;
+}
+/**
+ * The key used to look up a class token in the registry.
+ * For class tokens, the key is the class constructor itself.
+ * For named tokens, the key is the Token instance.
+ */
+type TokenKey<T = unknown> = Type<T> | Token<T>;
+
+
+/**
+ * Lifetime of a binding in the DI container.
+ * - singleton: created once, shared for the lifetime of the app.
+ * - scope:     created once per request scope.
+ * - transient: new instance every time it is resolved.
+ */
+type Lifetime = 'singleton' | 'scope' | 'transient';
+/**
+ * Internal representation of a registered binding.
+ */
+interface IBinding<T = unknown> {
+    lifetime: Lifetime;
+    implementation: Type<T>;
+    /** Explicit constructor dependencies, declared by the class itself. */
+    deps: ReadonlyArray<TokenKey>;
+    instance?: T;
+}
+/**
+ * AppInjector is the core DI container.
+ * It no longer uses reflect-metadata — all dependency information
+ * comes from explicitly declared `deps` arrays on each binding.
+ */
+declare class AppInjector {
+    readonly name: string | null;
+    readonly bindings: Map<Type<unknown> | Token<unknown>, IBinding<unknown>>;
+    readonly singletons: Map<Type<unknown> | Token<unknown>, unknown>;
+    readonly scoped: Map<Type<unknown> | Token<unknown>, unknown>;
+    constructor(name?: string | null);
+    /**
+     * Creates a child scope for per-request lifetime resolution.
+     */
+    createScope(): AppInjector;
+    /**
+     * Registers a binding explicitly.
+     */
+    register<T>(key: TokenKey<T>, implementation: Type<T>, lifetime: Lifetime, deps?: ReadonlyArray<TokenKey>): void;
+    /**
+     * Resolves a dependency by token or class reference.
+     */
+    resolve<T>(target: TokenKey<T> | ForwardReference<T>): T;
+    private _resolveForwardRef;
+    private _instantiate;
+}
+/**
+ * The global root injector. All singletons live here.
+ */
+declare const RootInjector: AppInjector;
+/**
+ * Convenience function: resolve a token from the root injector.
+ */
+declare function inject<T>(t: TokenKey<T> | ForwardReference<T>): T;
+
 declare class ResponseException extends Error {
     readonly status: number;
     constructor(message?: string);
@@ -81,29 +189,55 @@ declare class NetworkConnectTimeoutException extends ResponseException {
     readonly status = 599;
 }
 
-declare const INJECTABLE_METADATA_KEY: unique symbol;
-declare function getInjectableMetadata(target: Function): Lifetime | undefined;
-declare function hasInjectableMetadata(target: Function): boolean;
-
 
+interface InjectableOptions {
+    /**
+     * Lifetime of this injectable.
+     * @default 'scope'
+     */
+    lifetime?: Lifetime;
+    /**
+     * Explicit list of constructor dependencies, in the same order as the constructor parameters.
+     * Each entry is either a class constructor or a Token created with token().
+     *
+     * This replaces reflect-metadata / emitDecoratorMetadata entirely.
+     *
+     * @example
+     * @Injectable({ lifetime: 'singleton', deps: [MyRepo, DB_URL] })
+     * class MyService {
+     *   constructor(private repo: MyRepo, private dbUrl: string) {}
+     * }
+     */
+    deps?: ReadonlyArray<TokenKey>;
+}
 /**
- * The Injectable decorator marks a class as injectable.
- * It allows the class to be registered in the dependency injection system.
- * A class decorated with @Injectable can be injected into other classes
- * either from the constructor of the class that needs it of from the `inject` function.
- * @param lifetime - The lifetime of the injectable. Can be 'singleton', 'scope', or 'transient'.
- */
-declare function Injectable(lifetime?: Lifetime): ClassDecorator;
-
-
-declare const INJECT_METADATA_KEY = "custom:inject";
-/**
- * Decorator to manually inject a dependency.
- * Useful for handling circular dependencies with `forwardRef` or injecting specific tokens.
+ * Marks a class as injectable into the Noxus DI container.
+ *
+ * Unlike the v2 @Injectable, this decorator:
+ * - Does NOT require reflect-metadata or emitDecoratorMetadata.
+ * - Requires you to declare deps explicitly when the class has constructor parameters.
+ * - Supports standalone usage — no module declaration needed.
+ *
+ * @example
+ * // No dependencies
+ * @Injectable()
+ * class Logger {}
+ *
+ * // With dependencies
+ * @Injectable({ lifetime: 'singleton', deps: [Logger, MyRepo] })
+ * class MyService {
+ *   constructor(private logger: Logger, private repo: MyRepo) {}
+ * }
+ *
+ * // With a named token
+ * const DB_URL = token<string>('DB_URL');
  *
- * @param token The token or forward reference to inject.
+ * @Injectable({ deps: [DB_URL] })
+ * class DbService {
+ *   constructor(private url: string) {}
+ * }
  */
-declare function Inject(token: any): ParameterDecorator;
+declare function Injectable(options?: InjectableOptions): ClassDecorator;
 
 /**
  * Logger is a utility class for logging messages to the console.
@@ -206,4 +340,4 @@ declare namespace Logger {
     };
 }
 
-export { BadGatewayException, BadRequestException, ConflictException, ForbiddenException, GatewayTimeoutException, HttpVersionNotSupportedException, INJECTABLE_METADATA_KEY, INJECT_METADATA_KEY, Inject, Injectable, InsufficientStorageException, InternalServerException, Lifetime, type LogLevel, Logger, LoopDetectedException, MethodNotAllowedException, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, PaymentRequiredException, RequestTimeoutException, ResponseException, ServiceUnavailableException, TooManyRequestsException, UnauthorizedException, UpgradeRequiredException, VariantAlsoNegotiatesException, getInjectableMetadata, hasInjectableMetadata };
+export { AppInjector, BadGatewayException, BadRequestException, ConflictException, ForbiddenException, type ForwardRefFn, ForwardReference, GatewayTimeoutException, HttpVersionNotSupportedException, type IBinding, Injectable, type InjectableOptions, InsufficientStorageException, InternalServerException, type Lifetime, type LogLevel, Logger, LoopDetectedException, type MaybeAsync, MethodNotAllowedException, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, PaymentRequiredException, RequestTimeoutException, ResponseException, RootInjector, ServiceUnavailableException, Token, type TokenKey, TooManyRequestsException, type Type, UnauthorizedException, UpgradeRequiredException, VariantAlsoNegotiatesException, forwardRef, inject };

package/dist/child.d.ts

@@ -1,11 +1,119 @@
-import { L as Lifetime } from './app-injector-B3MvgV3k.js';
-export { A as AppInjector, F as ForwardRefFn, a as ForwardReference, I as IBinding, M as MaybeAsync, R as RootInjector, T as Type, f as forwardRef, i as inject } from './app-injector-B3MvgV3k.js';
-
 /**
  * @copyright 2025 NoxFly
  * @license MIT
  * @author NoxFly
  */
+interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+/**
+ * Represents a generic type that can be either a value or a promise resolving to that value.
+ */
+type MaybeAsync<T> = T | Promise<T>;
+
+
+/**
+ * A function that returns a type.
+ * Used for forward references to types that are not yet defined.
+ */
+interface ForwardRefFn<T = any> {
+    (): Type<T>;
+}
+/**
+ * A wrapper class for forward referenced types.
+ */
+declare class ForwardReference<T = any> {
+    readonly forwardRefFn: ForwardRefFn<T>;
+    constructor(forwardRefFn: ForwardRefFn<T>);
+}
+/**
+ * Creates a forward reference to a type.
+ * @param fn A function that returns the type.
+ * @returns A ForwardReference instance.
+ */
+declare function forwardRef<T = any>(fn: ForwardRefFn<T>): ForwardReference<T>;
+
+
+/**
+ * A DI token uniquely identifies a dependency.
+ * It can wrap a class (Type<T>) or be a named symbol token.
+ *
+ * Using tokens instead of reflect-metadata means dependencies are
+ * declared explicitly — no magic type inference, no emitDecoratorMetadata.
+ *
+ * @example
+ * // Class token (most common)
+ * const MY_SERVICE = token(MyService);
+ *
+ * // Named symbol token (for interfaces or non-class values)
+ * const DB_URL = token<string>('DB_URL');
+ */
+declare class Token<T> {
+    readonly target: Type<T> | string;
+    readonly description: string;
+    constructor(target: Type<T> | string);
+    toString(): string;
+}
+/**
+ * The key used to look up a class token in the registry.
+ * For class tokens, the key is the class constructor itself.
+ * For named tokens, the key is the Token instance.
+ */
+type TokenKey<T = unknown> = Type<T> | Token<T>;
+
+
+/**
+ * Lifetime of a binding in the DI container.
+ * - singleton: created once, shared for the lifetime of the app.
+ * - scope:     created once per request scope.
+ * - transient: new instance every time it is resolved.
+ */
+type Lifetime = 'singleton' | 'scope' | 'transient';
+/**
+ * Internal representation of a registered binding.
+ */
+interface IBinding<T = unknown> {
+    lifetime: Lifetime;
+    implementation: Type<T>;
+    /** Explicit constructor dependencies, declared by the class itself. */
+    deps: ReadonlyArray<TokenKey>;
+    instance?: T;
+}
+/**
+ * AppInjector is the core DI container.
+ * It no longer uses reflect-metadata — all dependency information
+ * comes from explicitly declared `deps` arrays on each binding.
+ */
+declare class AppInjector {
+    readonly name: string | null;
+    readonly bindings: Map<Type<unknown> | Token<unknown>, IBinding<unknown>>;
+    readonly singletons: Map<Type<unknown> | Token<unknown>, unknown>;
+    readonly scoped: Map<Type<unknown> | Token<unknown>, unknown>;
+    constructor(name?: string | null);
+    /**
+     * Creates a child scope for per-request lifetime resolution.
+     */
+    createScope(): AppInjector;
+    /**
+     * Registers a binding explicitly.
+     */
+    register<T>(key: TokenKey<T>, implementation: Type<T>, lifetime: Lifetime, deps?: ReadonlyArray<TokenKey>): void;
+    /**
+     * Resolves a dependency by token or class reference.
+     */
+    resolve<T>(target: TokenKey<T> | ForwardReference<T>): T;
+    private _resolveForwardRef;
+    private _instantiate;
+}
+/**
+ * The global root injector. All singletons live here.
+ */
+declare const RootInjector: AppInjector;
+/**
+ * Convenience function: resolve a token from the root injector.
+ */
+declare function inject<T>(t: TokenKey<T> | ForwardReference<T>): T;
+
 declare class ResponseException extends Error {
     readonly status: number;
     constructor(message?: string);
@@ -81,29 +189,55 @@ declare class NetworkConnectTimeoutException extends ResponseException {
     readonly status = 599;
 }
 
-declare const INJECTABLE_METADATA_KEY: unique symbol;
-declare function getInjectableMetadata(target: Function): Lifetime | undefined;
-declare function hasInjectableMetadata(target: Function): boolean;
-
 
+interface InjectableOptions {
+    /**
+     * Lifetime of this injectable.
+     * @default 'scope'
+     */
+    lifetime?: Lifetime;
+    /**
+     * Explicit list of constructor dependencies, in the same order as the constructor parameters.
+     * Each entry is either a class constructor or a Token created with token().
+     *
+     * This replaces reflect-metadata / emitDecoratorMetadata entirely.
+     *
+     * @example
+     * @Injectable({ lifetime: 'singleton', deps: [MyRepo, DB_URL] })
+     * class MyService {
+     *   constructor(private repo: MyRepo, private dbUrl: string) {}
+     * }
+     */
+    deps?: ReadonlyArray<TokenKey>;
+}
 /**
- * The Injectable decorator marks a class as injectable.
- * It allows the class to be registered in the dependency injection system.
- * A class decorated with @Injectable can be injected into other classes
- * either from the constructor of the class that needs it of from the `inject` function.
- * @param lifetime - The lifetime of the injectable. Can be 'singleton', 'scope', or 'transient'.
- */
-declare function Injectable(lifetime?: Lifetime): ClassDecorator;
-
-
-declare const INJECT_METADATA_KEY = "custom:inject";
-/**
- * Decorator to manually inject a dependency.
- * Useful for handling circular dependencies with `forwardRef` or injecting specific tokens.
+ * Marks a class as injectable into the Noxus DI container.
+ *
+ * Unlike the v2 @Injectable, this decorator:
+ * - Does NOT require reflect-metadata or emitDecoratorMetadata.
+ * - Requires you to declare deps explicitly when the class has constructor parameters.
+ * - Supports standalone usage — no module declaration needed.
+ *
+ * @example
+ * // No dependencies
+ * @Injectable()
+ * class Logger {}
+ *
+ * // With dependencies
+ * @Injectable({ lifetime: 'singleton', deps: [Logger, MyRepo] })
+ * class MyService {
+ *   constructor(private logger: Logger, private repo: MyRepo) {}
+ * }
+ *
+ * // With a named token
+ * const DB_URL = token<string>('DB_URL');
  *
- * @param token The token or forward reference to inject.
+ * @Injectable({ deps: [DB_URL] })
+ * class DbService {
+ *   constructor(private url: string) {}
+ * }
  */
-declare function Inject(token: any): ParameterDecorator;
+declare function Injectable(options?: InjectableOptions): ClassDecorator;
 
 /**
  * Logger is a utility class for logging messages to the console.
@@ -206,4 +340,4 @@ declare namespace Logger {
     };
 }
 
-export { BadGatewayException, BadRequestException, ConflictException, ForbiddenException, GatewayTimeoutException, HttpVersionNotSupportedException, INJECTABLE_METADATA_KEY, INJECT_METADATA_KEY, Inject, Injectable, InsufficientStorageException, InternalServerException, Lifetime, type LogLevel, Logger, LoopDetectedException, MethodNotAllowedException, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, PaymentRequiredException, RequestTimeoutException, ResponseException, ServiceUnavailableException, TooManyRequestsException, UnauthorizedException, UpgradeRequiredException, VariantAlsoNegotiatesException, getInjectableMetadata, hasInjectableMetadata };
+export { AppInjector, BadGatewayException, BadRequestException, ConflictException, ForbiddenException, type ForwardRefFn, ForwardReference, GatewayTimeoutException, HttpVersionNotSupportedException, type IBinding, Injectable, type InjectableOptions, InsufficientStorageException, InternalServerException, type Lifetime, type LogLevel, Logger, LoopDetectedException, type MaybeAsync, MethodNotAllowedException, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, PaymentRequiredException, RequestTimeoutException, ResponseException, RootInjector, ServiceUnavailableException, Token, type TokenKey, TooManyRequestsException, type Type, UnauthorizedException, UpgradeRequiredException, VariantAlsoNegotiatesException, forwardRef, inject };