@venok/core 1.0.0

package/interfaces/features/exception-filter.interface.d.ts

@@ -0,0 +1,21 @@
+import { Type } from "@venok/core/interfaces";
+import { ArgumentsHost } from "@venok/core/interfaces/context/arguments-host.interface";
+/**
+ * Interface describing implementation of an exception filter.
+ *
+ * @publicApi
+ */
+export interface ExceptionFilter<T = any> {
+    /**
+     * Method to implement a custom exception filter.
+     *
+     * @param exception the class of the exception being handled
+     * @param host used to access an array of arguments for
+     * the in-flight request
+     */
+    catch(exception: T, host: ArgumentsHost): any;
+}
+export interface ExceptionFilterMetadata {
+    func: ExceptionFilter["catch"];
+    exceptionMetatypes: Type[];
+}

package/interfaces/features/exception-filter.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/features/guards.interface.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from "rxjs";
+import { ExecutionContext } from "@venok/core/interfaces/context/execution.interface";
+/**
+ * Interface defining the `canActivate()` function that must be implemented
+ * by a guard.  Return value indicates whether the current request is
+ * allowed to proceed.  Return can be either synchronous (`boolean`)
+ * or asynchronous (`Promise` or `Observable`).
+ *
+ * @publicApi
+ */
+export interface CanActivate {
+    /**
+     * @param context Current execution context. Provides access to details about
+     * the current request pipeline.
+     *
+     * @returns Value indicating whether the current request is allowed to
+     * proceed.
+     */
+    canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean>;
+}

package/interfaces/features/guards.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/features/interceptor.interface.d.ts

@@ -0,0 +1,30 @@
+import { Observable } from "rxjs";
+import { ExecutionContext } from "@venok/core/interfaces/context/execution.interface";
+/**
+ * Interface providing access to the response stream.
+ *
+ * @publicApi
+ */
+export interface CallHandler<T = any> {
+    /**
+     * Returns an `Observable` representing the response stream from the route
+     * handler.
+     */
+    handle(): Observable<T>;
+}
+/**
+ * Interface describing implementation of an interceptor.
+ *
+ * @publicApi
+ */
+export interface VenokInterceptor<T = any, R = any> {
+    /**
+     * Method to implement a custom interceptor.
+     *
+     * @param context an `ExecutionContext` object providing methods to access the
+     * route handler and class about to be invoked.
+     * @param next a reference to the `CallHandler`, which provides access to an
+     * `Observable` representing the response stream from the route handler.
+     */
+    intercept(context: ExecutionContext, next: CallHandler<T>): Observable<R> | Promise<Observable<R>>;
+}

package/interfaces/features/interceptor.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/features/pipes.interface.d.ts

@@ -0,0 +1,37 @@
+import { Type } from "../type.interface";
+export type Transform<T = any> = (value: T, metadata: ArgumentMetadata) => any;
+/**
+ * Interface describing a pipe implementation's `transform()` method metadata argument.
+ *
+ * @publicApi
+ */
+export interface ArgumentMetadata {
+    /**
+     * Indicates whether custom parameter
+     */
+    readonly type: string;
+    /**
+     * Underlying base type (e.g., `String`) of the parameter, based on the type
+     * definition in the route handler.
+     */
+    readonly metatype?: Type<any> | undefined;
+    /**
+     * String passed as an argument to the decorator.
+     * Example: `@Body('userId')` would yield `userId`
+     */
+    readonly data?: string | undefined;
+}
+/**
+ * Interface describing implementation of a pipe.
+ *
+ * @publicApi
+ */
+export interface PipeTransform<T = any, R = any> {
+    /**
+     * Method to implement a custom pipe.  Called with two parameters
+     *
+     * @param value argument before it is received by route handler method
+     * @param metadata contains metadata about the value
+     */
+    transform(value: T, metadata: ArgumentMetadata): R;
+}

package/interfaces/features/pipes.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/helper.interface.d.ts

@@ -0,0 +1,3 @@
+export type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};

package/interfaces/helper.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/hooks/before-application-shutdown.interface.d.ts

@@ -0,0 +1,3 @@
+export interface BeforeApplicationShutdown {
+    beforeApplicationShutdown(signal?: string): any;
+}

package/interfaces/hooks/before-application-shutdown.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./before-application-shutdown.interface";
+export * from "./on-application-bootstrap.interface";
+export * from "./on-application-shutdown.interface";
+export * from "./on-destroy.interface";
+export * from "./on-init.interface";

package/interfaces/hooks/index.js

@@ -0,0 +1,21 @@
+"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 });
+__exportStar(require("./before-application-shutdown.interface"), exports);
+__exportStar(require("./on-application-bootstrap.interface"), exports);
+__exportStar(require("./on-application-shutdown.interface"), exports);
+__exportStar(require("./on-destroy.interface"), exports);
+__exportStar(require("./on-init.interface"), exports);

package/interfaces/hooks/on-application-bootstrap.interface.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Interface defining method called once the application has fully started and
+ * is bootstrapped.
+ *
+ * @publicApi
+ */
+export interface OnApplicationBootstrap {
+    onApplicationBootstrap(): any;
+}

package/interfaces/hooks/on-application-bootstrap.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/hooks/on-application-shutdown.interface.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Interface defining method to respond to system signals (when application gets
+ * shutdown by, e.g., SIGTERM)
+ *
+ * @publicApi
+ */
+export interface OnApplicationShutdown {
+    onApplicationShutdown(signal?: string): any;
+}

package/interfaces/hooks/on-application-shutdown.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/hooks/on-destroy.interface.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Interface defining method called just before Venok destroys the host module
+ * (`app.close()` method has been evaluated).  Use to perform cleanup on
+ * resources (e.g., Database connections).
+ *
+ * @publicApi
+ */
+export interface OnModuleDestroy {
+    onModuleDestroy(): any;
+}

package/interfaces/hooks/on-destroy.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/hooks/on-init.interface.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Interface defining method called once the host module has been initialized.
+ *
+ * @publicApi
+ */
+export interface OnModuleInit {
+    onModuleInit(): any;
+}

package/interfaces/hooks/on-init.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./application";
+export * from "./modules";
+export * from "./abstract.interface";
+export * from "./helper.interface";
+export * from "./scope.interface";
+export * from "./type.interface";

package/interfaces/index.js

@@ -0,0 +1,22 @@
+"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 });
+__exportStar(require("./application"), exports);
+__exportStar(require("./modules"), exports);
+__exportStar(require("./abstract.interface"), exports);
+__exportStar(require("./helper.interface"), exports);
+__exportStar(require("./scope.interface"), exports);
+__exportStar(require("./type.interface"), exports);

package/interfaces/injectable.interface.d.ts

@@ -0,0 +1 @@
+export type Injectable = unknown;

package/interfaces/injectable.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/modules/configurable/async-options.interface.d.ts

@@ -0,0 +1,42 @@
+import { DEFAULT_FACTORY_CLASS_METHOD_KEY } from "@venok/core/module/constants";
+import { FactoryProvider, ModuleMetadata, Provider, Type } from "@venok/core/interfaces";
+/**
+ * Interface that must be implemented by the module options factory class.
+ * Method key varies depending on the "FactoryClassMethodKey" type argument.
+ *
+ * @publicApi
+ */
+export type ConfigurableModuleOptionsFactory<ModuleOptions, FactoryClassMethodKey extends string> = Record<`${FactoryClassMethodKey}`, () => Promise<ModuleOptions> | ModuleOptions>;
+/**
+ * Interface that represents the module async options object
+ * Factory method name varies depending on the "FactoryClassMethodKey" type argument.
+ *
+ * @publicApi
+ */
+export interface ConfigurableModuleAsyncOptions<ModuleOptions, FactoryClassMethodKey extends string = typeof DEFAULT_FACTORY_CLASS_METHOD_KEY> extends Pick<ModuleMetadata, "imports"> {
+    /**
+     * Injection token resolving to an existing provider. The provider must implement
+     * the corresponding interface.
+     */
+    useExisting?: Type<ConfigurableModuleOptionsFactory<ModuleOptions, FactoryClassMethodKey>>;
+    /**
+     * Injection token resolving to a class that will be instantiated as a provider.
+     * The class must implement the corresponding interface.
+     */
+    useClass?: Type<ConfigurableModuleOptionsFactory<ModuleOptions, FactoryClassMethodKey>>;
+    /**
+     * Function returning options (or a Promise resolving to options) to configure the
+     * cache module.
+     */
+    useFactory?: (...args: any[]) => Promise<ModuleOptions> | ModuleOptions;
+    /**
+     * Dependencies that a Factory may inject.
+     */
+    inject?: FactoryProvider["inject"];
+    /**
+     * List of parent module's providers that will be filtered to only provide necessary
+     * providers for the 'inject' array
+     * useful to pass options to nested async modules
+     */
+    provideInjectionTokensFrom?: Provider[];
+}

package/interfaces/modules/configurable/async-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/modules/configurable/cls.interface.d.ts

@@ -0,0 +1,13 @@
+import { DEFAULT_FACTORY_CLASS_METHOD_KEY, DEFAULT_METHOD_KEY } from "@venok/core/module/constants";
+import { DynamicModule } from "@venok/core/interfaces";
+import { ConfigurableModuleAsyncOptions } from "@venok/core/interfaces/modules/configurable/async-options.interface";
+/**
+ * Class that represents a blueprint/prototype for a configurable Nest module.
+ * This class provides static methods for constructing dynamic modules. Their names
+ * can be controlled through the "MethodKey" type argument.
+ *
+ * @publicApi
+ */
+export type ConfigurableModuleCls<ModuleOptions, MethodKey extends string = typeof DEFAULT_METHOD_KEY, FactoryClassMethodKey extends string = typeof DEFAULT_FACTORY_CLASS_METHOD_KEY, ExtraModuleDefinitionOptions = {}> = {
+    new (): any;
+} & Record<`${MethodKey}`, (options: ModuleOptions & Partial<ExtraModuleDefinitionOptions>) => DynamicModule> & Record<`${MethodKey}Async`, (options: ConfigurableModuleAsyncOptions<ModuleOptions, FactoryClassMethodKey> & Partial<ExtraModuleDefinitionOptions>) => DynamicModule>;

package/interfaces/modules/configurable/cls.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/modules/configurable/host.interface.d.ts

@@ -0,0 +1,62 @@
+import { ConfigurableModuleCls } from "@venok/core/interfaces/modules/configurable/cls.interface";
+import { ConfigurableModuleAsyncOptions } from "@venok/core/interfaces/modules/configurable/async-options.interface";
+/**
+ * Configurable module host. See properties for more details
+ *
+ * @publicApi
+ */
+export interface ConfigurableModuleHost<ModuleOptions = Record<string, unknown>, MethodKey extends string = string, FactoryClassMethodKey extends string = string, ExtraModuleDefinitionOptions = {}> {
+    /**
+     * Class that represents a blueprint/prototype for a configurable Nest module.
+     * This class provides static methods for constructing dynamic modules. Their names
+     * can be controlled through the "MethodKey" type argument.
+     *
+     * Your module class should inherit from this class to make the static methods available.
+     *
+     * @example
+     * ```typescript
+     * @Module({})
+     * class IntegrationModule extends ConfigurableModuleCls {
+     *  // ...
+     * }
+     * ```
+     */
+    ConfigurableModuleClass: ConfigurableModuleCls<ModuleOptions, MethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * Module options provider token. Can be used to inject the "options object" to
+     * providers registered within the host module.
+     */
+    MODULE_OPTIONS_TOKEN: string | symbol;
+    /**
+     * Can be used to auto-infer the compound "async module options" type.
+     * Note: this property is not supposed to be used as a value.
+     *
+     * @example
+     * ```typescript
+     * @Module({})
+     * class IntegrationModule extends ConfigurableModuleCls {
+     *  static module = initializer(IntegrationModule);
+     *
+     * static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {
+     *  return super.registerAsync(options);
+     * }
+     * ```
+     */
+    ASYNC_OPTIONS_TYPE: ConfigurableModuleAsyncOptions<ModuleOptions, FactoryClassMethodKey> & Partial<ExtraModuleDefinitionOptions>;
+    /**
+     * Can be used to auto-infer the compound "module options" type (options interface + extra module definition options).
+     * Note: this property is not supposed to be used as a value.
+     *
+     * @example
+     * ```typescript
+     * @Module({})
+     * class IntegrationModule extends ConfigurableModuleCls {
+     *  static module = initializer(IntegrationModule);
+     *
+     * static register(options: typeof OPTIONS_TYPE): DynamicModule {
+     *  return super.register(options);
+     * }
+     * ```
+     */
+    OPTIONS_TYPE: ModuleOptions & Partial<ExtraModuleDefinitionOptions>;
+}

package/interfaces/modules/configurable/host.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/modules/configurable/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./async-options.interface";
+export * from "./cls.interface";
+export * from "./host.interface";

package/interfaces/modules/configurable/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./async-options.interface"), exports);
+__exportStar(require("./cls.interface"), exports);
+__exportStar(require("./host.interface"), exports);

package/interfaces/modules/definition.interface.d.ts

@@ -0,0 +1,4 @@
+import { ForwardReference } from "@venok/core/interfaces/modules/forward-reference.interface";
+import { Type } from "@venok/core/interfaces";
+import { DynamicModule } from "@venok/core/interfaces/modules/dynamic-module.interface";
+export type ModuleDefinition = ForwardReference | Type<unknown> | DynamicModule | Promise<DynamicModule>;

package/interfaces/modules/definition.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/modules/dynamic-module.interface.d.ts

@@ -0,0 +1,23 @@
+import { ModuleMetadata } from "@venok/core/interfaces/modules";
+import { Type } from "@venok/core/interfaces";
+/**
+ * Interface defining a Dynamic Module.
+ *
+ * @publicApi
+ */
+export interface DynamicModule extends ModuleMetadata {
+    /**
+     * A module reference
+     */
+    module: Type<any>;
+    /**
+     * When "true", makes a module global-scoped.
+     *
+     * Once imported into any module, a global-scoped module will be visible
+     * in all modules. Thereafter, modules that wish to inject a service exported
+     * from a global module do not need to import the provider module.
+     *
+     * @default false
+     */
+    global?: boolean;
+}

package/interfaces/modules/dynamic-module.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/modules/forward-reference.interface.d.ts

@@ -0,0 +1,3 @@
+export interface ForwardReference<T = any> {
+    forwardRef: T;
+}

package/interfaces/modules/forward-reference.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/modules/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./definition.interface";
+export * from "./dynamic-module.interface";
+export * from "./forward-reference.interface";
+export * from "./injection-token.interface";
+export * from "./introspection-result.interface";
+export * from "./module.interface";
+export * from "./module-metadata.interface";
+export * from "./optional-factory-dependency.interface";
+export * from "./provider.interface";

package/interfaces/modules/index.js

@@ -0,0 +1,25 @@
+"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 });
+__exportStar(require("./definition.interface"), exports);
+__exportStar(require("./dynamic-module.interface"), exports);
+__exportStar(require("./forward-reference.interface"), exports);
+__exportStar(require("./injection-token.interface"), exports);
+__exportStar(require("./introspection-result.interface"), exports);
+__exportStar(require("./module.interface"), exports);
+__exportStar(require("./module-metadata.interface"), exports);
+__exportStar(require("./optional-factory-dependency.interface"), exports);
+__exportStar(require("./provider.interface"), exports);

package/interfaces/modules/injection-token.interface.d.ts

@@ -0,0 +1,5 @@
+import { Abstract, Type } from "@venok/core/interfaces";
+/**
+ * @publicApi
+ */
+export type InjectionToken<T = any> = string | symbol | Type<T> | Abstract<T> | Function;

package/interfaces/modules/injection-token.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/modules/introspection-result.interface.d.ts

@@ -0,0 +1,10 @@
+import { Scope } from "@venok/core/interfaces";
+/**
+ * @publicApi
+ */
+export interface IntrospectionResult {
+    /**
+     * Enum defining lifetime of host class or factory.
+     */
+    scope: Scope;
+}

package/interfaces/modules/introspection-result.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/modules/module-metadata.interface.d.ts

@@ -0,0 +1,24 @@
+import { Abstract, Type } from "@venok/core/interfaces";
+import { DynamicModule, Provider, ForwardReference } from "@venok/core/interfaces/modules";
+/**
+ * Interface defining the property object that describes the module.
+ *
+ * @publicApi
+ */
+export interface ModuleMetadata {
+    /**
+     * Optional list of imported modules that export the providers which are
+     * required in this module.
+     */
+    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    /**
+     * Optional list of providers that will be instantiated by the Venok injector
+     * and that may be shared at least across this module.
+     */
+    providers?: Provider[];
+    /**
+     * Optional list of the subset of providers that are provided by this module
+     * and should be available in other modules which import this module.
+     */
+    exports?: Array<DynamicModule | Promise<DynamicModule> | string | symbol | Provider | ForwardReference | Abstract<any> | Function>;
+}

package/interfaces/modules/module-metadata.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/modules/module.interface.d.ts

@@ -0,0 +1,2 @@
+export interface VenokModule {
+}

package/interfaces/modules/module.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/modules/optional-factory-dependency.interface.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken } from "@venok/core/interfaces/modules";
+/**
+ * @publicApi
+ */
+export type OptionalFactoryDependency = {
+    token: InjectionToken;
+    optional: boolean;
+};

package/interfaces/modules/optional-factory-dependency.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/modules/override.interface.d.ts

@@ -0,0 +1,5 @@
+import { ModuleDefinition } from "@venok/core/interfaces/modules/definition.interface";
+export interface ModuleOverride {
+    moduleToReplace: ModuleDefinition;
+    newModule: ModuleDefinition;
+}

package/interfaces/modules/override.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });