@expressots/core 2.16.2 → 3.0.0-beta.3

package/lib/cjs/provider/environment/env-validator.provider.js

@@ -13,22 +13,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnvValidatorProvider = void 0;
-const dotenv_1 = __importDefault(require("dotenv"));
-const inversify_1 = require("inversify");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const inversify_1 = require("../../di/inversify");
 const logger_provider_1 = require("../logger/logger.provider");
+const shared_1 = require("@expressots/shared");
 /**
  * The EnvValidatorProvider class provides utility methods for working with environment variables.
  * It validates, loads, and retrieves environment variables from the .env file.
  * @provide EnvValidatorProvider
+ * @public API
  */
 let EnvValidatorProvider = class EnvValidatorProvider {
     constructor() {
-        this.name = "EnvValidatorProvider";
-        this.version = "0.0.1";
+        this.name = "Env Validator Provider";
+        this.version = "3.0.0";
         this.author = "Richard Zampieri";
-        this.repo = "internal";
+        this.repo = "https://github.com/expressots/expressots";
         this.logger = new logger_provider_1.Logger();
     }
     /**
@@ -36,6 +37,7 @@ let EnvValidatorProvider = class EnvValidatorProvider {
      * @param key - The key of the environment variable.
      * @param defaultValue - The default value to return if the environment variable is not set.
      * @returns The value of the environment variable, or the default value if not set.
+     * @public API
      */
     get(key, defaultValue = undefined) {
         return process.env[key] ?? defaultValue;
@@ -43,25 +45,25 @@ let EnvValidatorProvider = class EnvValidatorProvider {
     /**
      * Validates and loads all environment variables from the .env file.
      * If the .env file does not exist or any environment variables are not set, the process will exit with an error.
+     * @param envFile -
+     * @public API
      */
-    checkAll() {
+    checkFile(envFile) {
         // Get the full path of the .env file
-        const envFilePath = path_1.default.join(process.cwd(), ".", ".env");
+        const envFilePath = path_1.default.join(process.cwd(), ".", envFile);
         // Check if the .env file exists
         if (!fs_1.default.existsSync(envFilePath)) {
-            this.logger.error("Environment file .env is not defined.", "env-validator-provider");
+            this.logger.error(`Environment file [${envFile}] is not defined.`, "environment-provider");
             process.exit(1);
         }
-        // Load the environment variables from the .env file
-        const dotenvConfigOutput = dotenv_1.default.config({ path: envFilePath });
-        const dotEnvParsed = dotenvConfigOutput.parsed;
+        const dotEnvParsed = (0, shared_1.parse)(fs_1.default.readFileSync(envFilePath, "utf8"));
         /* Verify if all environment variables are defined */
         let hasError = false;
         if (dotEnvParsed) {
             for (const key of Object.keys(dotEnvParsed)) {
                 // Check if the environment variable is not defined or is an empty string
                 if (!process.env[key] || process.env[key] === "") {
-                    this.logger.error(`Environment variable ${key} is not defined.`, "env-validator-provider");
+                    this.logger.error(`Environment variable [ ${key} ] is not defined.`, "environment-provider");
                     hasError = true;
                 }
             }

package/lib/cjs/provider/index.js

@@ -1,6 +1,20 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseRepository = exports.InMemoryDB = exports.ValidateDTO = exports.Env = exports.Logger = exports.ProviderManager = void 0;
+exports.ValidateDTO = exports.Env = exports.Logger = exports.ProviderManager = void 0;
 var provider_manager_1 = require("./provider-manager");
 Object.defineProperty(exports, "ProviderManager", { enumerable: true, get: function () { return provider_manager_1.ProviderManager; } });
 var logger_provider_1 = require("./logger/logger.provider");
@@ -9,7 +23,4 @@ var env_validator_provider_1 = require("./environment/env-validator.provider");
 Object.defineProperty(exports, "Env", { enumerable: true, get: function () { return env_validator_provider_1.EnvValidatorProvider; } });
 var dto_validator_provider_1 = require("./dto-validator/dto-validator.provider");
 Object.defineProperty(exports, "ValidateDTO", { enumerable: true, get: function () { return dto_validator_provider_1.ValidateDTO; } });
-var db_in_memory_provider_1 = require("./db-in-memory/db-in-memory.provider");
-Object.defineProperty(exports, "InMemoryDB", { enumerable: true, get: function () { return db_in_memory_provider_1.InMemoryDB; } });
-var base_repo_repository_1 = require("./db-in-memory/base-repo.repository");
-Object.defineProperty(exports, "BaseRepository", { enumerable: true, get: function () { return base_repo_repository_1.BaseRepository; } });
+__exportStar(require("./db-in-memory"), exports);

package/lib/cjs/provider/logger/logger.provider.js

@@ -10,8 +10,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
-const inversify_1 = require("inversify");
-const color_codes_1 = require("../../common/color-codes");
+const inversify_1 = require("../../di/inversify");
+const color_codes_1 = require("../../console/color-codes");
 /**
  * Applies a specified color to a text string.
  *
@@ -24,13 +24,14 @@ function colorText(text, color) {
 }
 /**
  * Class that provides logging functionality with colorized text.
+ * @public API
  */
 let Logger = class Logger {
     constructor() {
-        this.name = "Logger";
-        this.version = "0.0.1";
+        this.name = "Logger Provider";
+        this.version = "3.0.0";
         this.author = "Richard Zampieri";
-        this.repo = "internal";
+        this.repo = "https://github.com/expressots/expressots";
         this.pid = process.pid;
     }
     /**
@@ -78,6 +79,7 @@ let Logger = class Logger {
      *
      * @param message - The message to log.
      * @param module - Optional module name.
+     * @public API
      */
     msg(message, module) {
         process.stdout.write(this.formatMessage("NONE", message, module));
@@ -87,6 +89,7 @@ let Logger = class Logger {
      *
      * @param message - The message to log.
      * @param module - Optional module name.
+     * @public API
      */
     info(message, module) {
         process.stdout.write(this.formatMessage("INFO", message, module));
@@ -96,6 +99,7 @@ let Logger = class Logger {
      *
      * @param message - The message to log.
      * @param module - Optional module name.
+     * @public API
      */
     warn(message, module) {
         process.stdout.write(this.formatMessage("WARN", message, module));
@@ -105,6 +109,7 @@ let Logger = class Logger {
      *
      * @param message - The message to log.
      * @param module - Optional module name.
+     * @public API
      */
     error(message, module) {
         process.stderr.write(this.formatMessage("ERROR", message, module));

package/lib/cjs/provider/provider-manager.js

@@ -1,49 +1,92 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProviderManager = void 0;
-require("reflect-metadata");
-const inversify_1 = require("inversify");
-const application_1 = require("../application");
-const decorator_1 = require("../decorator");
+const inversify_1 = require("../di/inversify");
 const logger_provider_1 = require("./logger/logger.provider");
-let ProviderManager = class ProviderManager {
-    constructor() {
-        this.container = application_1.AppFactory.container;
+/**
+ * ProviderManager Class - A class for managing dependency injection providers.
+ * @public API
+ */
+class ProviderManager {
+    constructor(container) {
         this.logger = new logger_provider_1.Logger();
+        this.container = container;
     }
-    register(serviceIdentifier, scope = inversify_1.BindingScopeEnum.Request) {
+    /**
+     * Register a provider with the container.
+     * @public API
+     */
+    register(serviceIdentifier, constructorOrScope, scope = inversify_1.BindingScopeEnum.Request) {
         if (this.container.isBound(serviceIdentifier)) {
             this.logger.warn(`${serviceIdentifier.name} already registered`, "provider-manager");
             return;
         }
+        let binding;
+        if (typeof constructorOrScope === "function") {
+            // Overload where constructor is provided
+            const constructor = constructorOrScope;
+            const scopeDefinition = scope || inversify_1.BindingScopeEnum.Transient;
+            binding = this.container.bind(serviceIdentifier).to(constructor);
+            this.applyScope(binding, scopeDefinition);
+        }
+        else {
+            const scopeDefinition = constructorOrScope ||
+                inversify_1.BindingScopeEnum.Transient;
+            binding = this.container.bind(serviceIdentifier).toSelf();
+            this.applyScope(binding, scopeDefinition);
+        }
+    }
+    /**
+     * Get a provider from the container.
+     * @param serviceIdentifier - The service identifier to get from the container.
+     * @returns An instance of the provider.
+     * @public API
+     */
+    get(serviceIdentifier) {
+        if (!this.container.isBound(serviceIdentifier)) {
+            this.logger.error(`${this.getServiceIdentifierName(serviceIdentifier)} not registered`, "ProviderManager");
+            throw new Error(`Provider ${this.getServiceIdentifierName(serviceIdentifier)} not registered`);
+        }
+        return this.container.get(serviceIdentifier);
+    }
+    /**
+     * Apply the scope to the binding.
+     * @param binding - The binding to apply the scope to.
+     * @param scope - The scope to apply.
+     * @private
+     */
+    applyScope(binding, scope) {
         switch (scope) {
             case inversify_1.BindingScopeEnum.Singleton:
-                this.container.bind(serviceIdentifier).toSelf().inSingletonScope();
-                break;
-            case inversify_1.BindingScopeEnum.Transient:
-                this.container.bind(serviceIdentifier).toSelf().inTransientScope();
+                binding.inSingletonScope();
                 break;
             case inversify_1.BindingScopeEnum.Request:
-                this.container.bind(serviceIdentifier).toSelf().inRequestScope();
+                binding.inRequestScope();
+                break;
+            case inversify_1.BindingScopeEnum.Transient:
+            default:
+                binding.inTransientScope();
                 break;
         }
     }
-    get(provider) {
-        const serviceIdentifier = this.container.get(provider);
-        if (!serviceIdentifier) {
-            this.logger.error(`${provider.name} not registered`, "provider-manager");
-            throw new Error(`Provider ${provider.name} not registered`);
+    /**
+     * Get the name of the service identifier for logging purposes.
+     * @param serviceIdentifier - The service identifier.
+     * @returns The name of the service identifier.
+     * @private
+     */
+    getServiceIdentifierName(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    serviceIdentifier) {
+        if (typeof serviceIdentifier === "function") {
+            return serviceIdentifier.name;
+        }
+        else if (typeof serviceIdentifier === "symbol") {
+            return serviceIdentifier.toString();
+        }
+        else {
+            return serviceIdentifier;
         }
-        return serviceIdentifier;
     }
-};
+}
 exports.ProviderManager = ProviderManager;
-exports.ProviderManager = ProviderManager = __decorate([
-    (0, decorator_1.provideSingleton)(ProviderManager)
-], ProviderManager);

package/lib/cjs/types/application/application-container.d.ts

@@ -1,23 +1,5 @@
 import "reflect-metadata";
-import { Container, ContainerModule, interfaces } from "inversify";
-/**
- * Interface for container options that can be passed to the AppContainer class.
- */
-interface ContainerOptions {
-    /**
-     * The default scope for bindings in the container.
-     * It can be set to Request (default), Singleton, or Transient.
-     */
-    defaultScope?: interfaces.BindingScope;
-    /**
-     * Allows skipping of base class checks when working with derived classes.
-     */
-    skipBaseClassChecks?: boolean;
-    /**
-     * Allows auto-binding of injectable classes.
-     */
-    autoBindInjectable?: boolean;
-}
+import { Container, ContainerModule, interfaces } from "../di/inversify";
 /**
  * The AppContainer class provides a container for managing dependency injection.
  * It allows the creation of a container with custom options, including default binding scope
@@ -28,10 +10,13 @@ interface ContainerOptions {
  * ```typescript
  * const container = new AppContainer();
  * container.create([new MyModule()]);
+ * ```
+ * @public API
  */
-declare class AppContainer {
+export declare class AppContainer {
     private container;
     private options;
+    private logger;
     /**
      * Constructs the AppContainer instance.
      * @param options - The options for creating the container with default request scope.
@@ -39,27 +24,29 @@ declare class AppContainer {
      * @option options.skipBaseClassChecks - Allows skipping of base class checks when working with derived classes.
      * @option options.autoBindInjectable - Allows auto-binding of injectable classes.
      */
-    constructor(options?: ContainerOptions);
+    constructor(options?: interfaces.ContainerOptions);
     /**
      * Creates and configures a new dependency injection container.
      * @param modules - An array of ContainerModule instances to load into the container.
      * @returns The configured dependency injection container.
      */
-    create(modules: Array<ContainerModule>): Container;
+    create(modules: Array<ContainerModule>): void;
     /**
      * Retrieves the binding dictionary of the container.
      * @returns(void) Print table of the binding dictionary of the container.
+     * @public API
      */
     viewContainerBindings(): void;
     /**
      * Retrieves the container options.
      * @returns The container options.
+     * @public API
      */
     getContainerOptions(): interfaces.ContainerOptions;
     /**
-     * Retrieves the container.
-     * @returns The container.
+     * Retrieves the container instance.
+     * @returns The container instance.
+     * @public API
      */
     get Container(): Container;
 }
-export { AppContainer };

package/lib/cjs/types/application/application-factory.d.ts

@@ -1,19 +1,22 @@
-import { IWebServer, IWebServerPublic, IWebServerConstructor } from "@expressots/adapter-express";
-import { Container } from "inversify";
+import { IWebServer, IWebServerConstructor, IWebServerPublic } from "@expressots/shared";
+/**
+ * Type guard to check if input is a constructor type of IWebServer.
+ * @param input - Input to check.
+ * @returns True if input is a constructor type of IWebServer.
+ */
+export declare function isWebServerConstructor<T extends IWebServer>(input: unknown): input is IWebServerConstructor<T>;
 /**
  * AppFactory Class
  *
  * Responsible for creating an instance of the IWebServer implementation using a custom application type.
+ * @public API
  */
-declare class AppFactory {
-    static container: Container;
+export declare class AppFactory {
     private static logger;
     /**
      * Create an instance of a web server.
-     * @param container - Dependency injection container.
      * @param webServerType - Constructor of a class that implements IWebServer.
      * @returns A promise that resolves to an instance of IWebServer.
      */
-    static create<T extends IWebServer>(container: Container, webServerType: IWebServerConstructor<T>): Promise<IWebServerPublic>;
+    static create<T extends IWebServer>(webServerType: IWebServerConstructor<T>): Promise<IWebServerPublic>;
 }
-export { AppFactory };

package/lib/cjs/types/{common/server-env.types.d.ts → application/application.types.d.ts}

@@ -2,6 +2,7 @@
  * Enum representing possible server environments.
  * @options Development - Development environment.
  * @options Production - Production environment.
+ * @public API
  */
 export declare enum ServerEnvironment {
     Development = "development",

package/lib/cjs/types/application/index.d.ts

@@ -1,2 +1,3 @@
 export { AppContainer } from "./application-container";
 export { AppFactory } from "./application-factory";
+export { ServerEnvironment } from "./application.types";

package/lib/cjs/types/console/console.d.ts

@@ -1,15 +1,9 @@
-/**
- * Interface representing application message details for console output.
- */
-interface IApplicationMessageToConsole {
-    appName: string;
-    appVersion: string;
-}
+import { IConsoleMessage } from "@expressots/shared";
 /**
  * The Console class provides methods for displaying styled messages in the console.
  * @provide Console
  */
-declare class Console {
+export declare class Console {
     /**
      * Print a message to the console with the specified color style.
      * @param message - The message to be printed.
@@ -22,6 +16,5 @@ declare class Console {
      * @param environment - The server environment.
      * @param consoleMessage - Optional application message details for console output.
      */
-    messageServer(port: number, environment: string, consoleMessage?: IApplicationMessageToConsole): Promise<void>;
+    messageServer(port: number, environment: string, consoleMessage?: IConsoleMessage): Promise<void>;
 }
-export { Console, IApplicationMessageToConsole };

package/lib/cjs/types/console/index.d.ts

@@ -1 +1,2 @@
-export { Console, IApplicationMessageToConsole } from "./console";
+export { IConsoleMessage } from "@expressots/shared";
+export { Console } from "./console";

package/lib/cjs/types/container-module/container-module.d.ts

@@ -1,4 +1,4 @@
-import { ContainerModule, interfaces } from "inversify";
+import { ContainerModule, interfaces } from "../di/inversify";
 /**
  * Key to be used for storing and retrieving binding type metadata.
  */
@@ -7,6 +7,7 @@ export declare const BINDING_TYPE_METADATA_KEY = "binding-type";
  * The scope decorator is a higher order function that can be used to decorate a class with a binding type.
  * @param binding An instance of interfaces.BindingScope which represents the binding type.
  * @returns A decorator function that can be used to decorate a class with a binding type.
+ * @public API
  */
 declare const scope: (binding: interfaces.BindingScope) => (target: any) => void;
 /**
@@ -26,6 +27,7 @@ export declare class BaseModule {
      * @param controllers - An array of controller classes.
      * @param scope - An optional binding scope to be used for all controllers.
      * @returns A ContainerModule with the controller bindings.
+     * @public API
      */
     static createContainerModule(controllers: Array<any>, scope?: interfaces.BindingScope): ContainerModule;
 }

package/lib/cjs/types/decorator/scope-binding.d.ts

@@ -6,15 +6,15 @@
  *
  * @example
  * ```typescript
- * @provide(ServiceIdentifier)
+ * provide(ServiceIdentifier)
  * class MyService {}
  * ```
+ * @public API
  */
-declare const provide: (identifier: any) => (target: any) => any;
+export declare const provide: (identifier: any) => (target: any) => any;
 /**
  * Provides a singleton binding for the given identifier.
  *
- * @remarks
  * Singleton binding ensures that the same instance of a dependency is reused within the entire container.
  *
  * @param identifier - The identifier (e.g., symbol, string, class) for the dependency being registered.
@@ -22,15 +22,15 @@ declare const provide: (identifier: any) => (target: any) => any;
  *
  * @example
  * ```typescript
- * @provideSingleton(ServiceIdentifier)
+ * provideSingleton(ServiceIdentifier)
  * class MyService {}
  * ```
+ * @public API
  */
-declare const provideSingleton: (identifier: any) => (target: any) => any;
+export declare const provideSingleton: (identifier: any) => (target: any) => any;
 /**
  * Provides a transient binding for the given identifier.
  *
- * @remarks
  * Transient binding ensures that a new instance of a dependency is created every time it is resolved.
  *
  * @param identifier - The identifier (e.g., symbol, string, class) for the dependency being registered.
@@ -38,9 +38,9 @@ declare const provideSingleton: (identifier: any) => (target: any) => any;
  *
  * @example
  * ```typescript
- * @provideTransient(ServiceIdentifier)
+ * provideTransient(ServiceIdentifier)
  * class MyService {}
  * ```
+ * @public API
  */
-declare const provideTransient: (identifier: any) => (target: any) => any;
-export { provide, provideSingleton, provideTransient };
+export declare const provideTransient: (identifier: any) => (target: any) => any;

package/lib/cjs/types/di/annotation/decorator_utils.d.ts

@@ -0,0 +1,16 @@
+import { interfaces } from "../interfaces/interfaces";
+type Prototype<T> = {
+    [Property in keyof T]: T[Property] extends NewableFunction ? T[Property] : T[Property] | undefined;
+} & {
+    constructor: NewableFunction;
+};
+interface ConstructorFunction<T = Record<string, unknown>> {
+    new (...args: Array<unknown>): T;
+    prototype: Prototype<T>;
+}
+export type DecoratorTarget<T = unknown> = ConstructorFunction<T> | Prototype<T>;
+declare function tagParameter(annotationTarget: DecoratorTarget, parameterName: string | symbol | undefined, parameterIndex: number, metadata: interfaces.MetadataOrMetadataArray): void;
+declare function tagProperty(annotationTarget: DecoratorTarget, propertyName: string | symbol, metadata: interfaces.MetadataOrMetadataArray): void;
+declare function createTaggedDecorator(metadata: interfaces.MetadataOrMetadataArray): <T>(target: DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;
+declare function decorate(decorator: DecoratorTarget | ParameterDecorator | MethodDecorator, target: object, parameterIndexOrProperty?: number | string): void;
+export { decorate, tagParameter, tagProperty, createTaggedDecorator };

package/lib/cjs/types/di/annotation/inject.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Marks a constructor parameter for injection.
+ * @param serviceIdentifier The service identifier
+ * @return The decorator function
+ * @example
+ * ```typescript
+ * class Engine {}
+ *
+ * class Car {
+ *  constructor(@inject(Engine) engine: Engine) {}
+ * }
+ * ```
+ * @public API
+ */
+declare const inject: <T = unknown>(serviceIdentifier: import("./lazy_service_identifier").ServiceIdentifierOrFunc<T>) => (target: import("./decorator_utils").DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;
+export { inject };

package/lib/cjs/types/di/annotation/inject_base.d.ts

@@ -0,0 +1,3 @@
+import { DecoratorTarget } from "./decorator_utils";
+import { ServiceIdentifierOrFunc } from "./lazy_service_identifier";
+export declare function injectBase(metadataKey: string): <T = unknown>(serviceIdentifier: ServiceIdentifierOrFunc<T>) => (target: DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;

package/lib/cjs/types/di/annotation/injectable.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Marks a class as injectable.
+ * @returns A decorator function
+ * @public API
+ */
+declare function injectable(): <T extends abstract new (...args: any) => unknown>(target: T) => T;
+export { injectable };

package/lib/cjs/types/di/annotation/lazy_service_identifier.d.ts

@@ -0,0 +1,7 @@
+import { interfaces } from "../interfaces/interfaces";
+export type ServiceIdentifierOrFunc<T> = interfaces.ServiceIdentifier<T> | LazyServiceIdentifier<T>;
+export declare class LazyServiceIdentifier<T = unknown> {
+    private _cb;
+    constructor(cb: () => interfaces.ServiceIdentifier<T>);
+    unwrap(): interfaces.ServiceIdentifier<T>;
+}

package/lib/cjs/types/di/annotation/multi_inject.d.ts

@@ -0,0 +1,2 @@
+declare const multiInject: <T = unknown>(serviceIdentifier: import("./lazy_service_identifier").ServiceIdentifierOrFunc<T>) => (target: import("./decorator_utils").DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;
+export { multiInject };

package/lib/cjs/types/di/annotation/named.d.ts

@@ -0,0 +1,2 @@
+declare function named(name: string | number | symbol): <T>(target: import("./decorator_utils").DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void;
+export { named };

package/lib/cjs/types/di/annotation/optional.d.ts

@@ -0,0 +1,2 @@
+declare function optional(): ParameterDecorator;
+export { optional };

package/lib/cjs/types/di/annotation/post_construct.d.ts

@@ -0,0 +1,4 @@
+declare const postConstruct: () => (target: {
+    constructor: NewableFunction;
+}, propertyKey: string) => void;
+export { postConstruct };

package/lib/cjs/types/di/annotation/pre_destroy.d.ts

@@ -0,0 +1,4 @@
+declare const preDestroy: () => (target: {
+    constructor: NewableFunction;
+}, propertyKey: string) => void;
+export { preDestroy };

package/lib/cjs/types/di/annotation/property_event_decorator.d.ts

@@ -0,0 +1,4 @@
+declare function propertyEventDecorator(eventKey: string, errorMessage: string): () => (target: {
+    constructor: NewableFunction;
+}, propertyKey: string) => void;
+export { propertyEventDecorator };

package/lib/cjs/types/di/annotation/tagged.d.ts

@@ -0,0 +1,2 @@
+declare function tagged<T>(metadataKey: string | number | symbol, metadataValue: T | unknown): ParameterDecorator;
+export { tagged };

package/lib/cjs/types/di/annotation/target_name.d.ts

@@ -0,0 +1,3 @@
+import { DecoratorTarget } from "./decorator_utils";
+declare function targetName(name: string): (target: DecoratorTarget, targetKey: string, index: number) => void;
+export { targetName };

package/lib/cjs/types/di/annotation/unmanaged.d.ts

@@ -0,0 +1,3 @@
+import { DecoratorTarget } from "./decorator_utils";
+declare function unmanaged(): (target: DecoratorTarget, targetKey: string | undefined, index: number) => void;
+export { unmanaged };

package/lib/cjs/types/di/binding-decorator/constants.d.ts

@@ -0,0 +1,4 @@
+declare const METADATA_KEY: {
+    provide: string;
+};
+export { METADATA_KEY };

package/lib/cjs/types/di/binding-decorator/decorator/fluent_provide.d.ts

@@ -0,0 +1,4 @@
+import interfaces from "../interfaces/interfaces";
+import { interfaces as inversifyInterfaces } from "../../../di/inversify";
+declare function fluentProvide(serviceIdentifier: inversifyInterfaces.ServiceIdentifier<any>): interfaces.ProvideInWhenOnSyntax<any>;
+export default fluentProvide;

package/lib/cjs/types/di/binding-decorator/decorator/provide.d.ts

@@ -0,0 +1,4 @@
+import "reflect-metadata";
+import { interfaces as inversifyInterfaces } from "../../../di/inversify";
+declare function provide(serviceIdentifier: inversifyInterfaces.ServiceIdentifier<any>, force?: boolean): any;
+export default provide;

package/lib/cjs/types/di/binding-decorator/factory/module_factory.d.ts

@@ -0,0 +1,4 @@
+import "reflect-metadata";
+import { interfaces as inversifyInterfaces } from "../../inversify";
+declare function buildProviderModule(): inversifyInterfaces.ContainerModule;
+export default buildProviderModule;

package/lib/cjs/types/di/binding-decorator/index.d.ts

@@ -0,0 +1,8 @@
+import autoProvide from "./utils/auto_wire";
+import provide from "./decorator/provide";
+import fluentProvide from "./decorator/fluent_provide";
+import buildProviderModule from "./factory/module_factory";
+export { fluentProvide };
+export { provide };
+export { autoProvide };
+export { buildProviderModule };