Initial commit - Event Planner application

node_modules/@nestjs/core/errors/exception-handler.d.ts

@@ -0,0 +1,4 @@
+export declare class ExceptionHandler {
+    private static readonly logger;
+    handle(exception: Error): void;
+}

node_modules/@nestjs/core/errors/exception-handler.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionHandler = void 0;
+const logger_service_1 = require("@nestjs/common/services/logger.service");
+class ExceptionHandler {
+    handle(exception) {
+        ExceptionHandler.logger.error(exception);
+    }
+}
+exports.ExceptionHandler = ExceptionHandler;
+ExceptionHandler.logger = new logger_service_1.Logger(ExceptionHandler.name);

node_modules/@nestjs/core/errors/exceptions-zone.d.ts

@@ -0,0 +1,5 @@
+export declare class ExceptionsZone {
+    private static readonly exceptionHandler;
+    static run(callback: () => void, teardown: ((err: any) => void) | undefined, autoFlushLogs: boolean): void;
+    static asyncRun(callback: () => Promise<void>, teardown: ((err: any) => void) | undefined, autoFlushLogs: boolean): Promise<void>;
+}

node_modules/@nestjs/core/errors/exceptions-zone.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionsZone = void 0;
+const common_1 = require("@nestjs/common");
+const exception_handler_1 = require("./exception-handler");
+const DEFAULT_TEARDOWN = () => process.exit(1);
+class ExceptionsZone {
+    static run(callback, teardown = DEFAULT_TEARDOWN, autoFlushLogs) {
+        try {
+            callback();
+        }
+        catch (e) {
+            this.exceptionHandler.handle(e);
+            if (autoFlushLogs) {
+                common_1.Logger.flush();
+            }
+            teardown(e);
+        }
+    }
+    static async asyncRun(callback, teardown = DEFAULT_TEARDOWN, autoFlushLogs) {
+        try {
+            await callback();
+        }
+        catch (e) {
+            this.exceptionHandler.handle(e);
+            if (autoFlushLogs) {
+                common_1.Logger.flush();
+            }
+            teardown(e);
+        }
+    }
+}
+exports.ExceptionsZone = ExceptionsZone;
+ExceptionsZone.exceptionHandler = new exception_handler_1.ExceptionHandler();

node_modules/@nestjs/core/errors/exceptions/circular-dependency.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class CircularDependencyException extends RuntimeException {
+    constructor(context?: string);
+}

node_modules/@nestjs/core/errors/exceptions/circular-dependency.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircularDependencyException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+class CircularDependencyException extends runtime_exception_1.RuntimeException {
+    constructor(context) {
+        const ctx = context ? ` inside ${context}` : ``;
+        super(`A circular dependency has been detected${ctx}. Please, make sure that each side of a bidirectional relationships are decorated with "forwardRef()". Note that circular relationships between custom providers (e.g., factories) are not supported since functions cannot be called more than once.`);
+    }
+}
+exports.CircularDependencyException = CircularDependencyException;

node_modules/@nestjs/core/errors/exceptions/index.d.ts

@@ -0,0 +1,8 @@
+export * from './circular-dependency.exception';
+export * from './runtime.exception';
+export * from './unknown-element.exception';
+export * from './invalid-class-scope.exception';
+export * from './invalid-class.exception';
+export * from './unknown-export.exception';
+export * from './unknown-module.exception';
+export * from './undefined-forwardref.exception';

node_modules/@nestjs/core/errors/exceptions/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./circular-dependency.exception"), exports);
+tslib_1.__exportStar(require("./runtime.exception"), exports);
+tslib_1.__exportStar(require("./unknown-element.exception"), exports);
+tslib_1.__exportStar(require("./invalid-class-scope.exception"), exports);
+tslib_1.__exportStar(require("./invalid-class.exception"), exports);
+tslib_1.__exportStar(require("./unknown-export.exception"), exports);
+tslib_1.__exportStar(require("./unknown-module.exception"), exports);
+tslib_1.__exportStar(require("./undefined-forwardref.exception"), exports);

node_modules/@nestjs/core/errors/exceptions/invalid-class-module.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class InvalidClassModuleException extends RuntimeException {
+    constructor(metatypeUsedAsAModule: any, scope: any[]);
+}

node_modules/@nestjs/core/errors/exceptions/invalid-class-module.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidClassModuleException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class InvalidClassModuleException extends runtime_exception_1.RuntimeException {
+    constructor(metatypeUsedAsAModule, scope) {
+        super((0, messages_1.USING_INVALID_CLASS_AS_A_MODULE_MESSAGE)(metatypeUsedAsAModule, scope));
+    }
+}
+exports.InvalidClassModuleException = InvalidClassModuleException;

node_modules/@nestjs/core/errors/exceptions/invalid-class-scope.exception.d.ts

@@ -0,0 +1,5 @@
+import { Abstract, Type } from '@nestjs/common/interfaces';
+import { RuntimeException } from './runtime.exception';
+export declare class InvalidClassScopeException extends RuntimeException {
+    constructor(metatypeOrToken: Type<any> | Abstract<any> | string | symbol);
+}

node_modules/@nestjs/core/errors/exceptions/invalid-class-scope.exception.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidClassScopeException = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class InvalidClassScopeException extends runtime_exception_1.RuntimeException {
+    constructor(metatypeOrToken) {
+        let name = (0, shared_utils_1.isFunction)(metatypeOrToken)
+            ? metatypeOrToken.name
+            : metatypeOrToken;
+        name = name && name.toString();
+        super((0, messages_1.INVALID_CLASS_SCOPE_MESSAGE) `${name}`);
+    }
+}
+exports.InvalidClassScopeException = InvalidClassScopeException;

node_modules/@nestjs/core/errors/exceptions/invalid-class.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class InvalidClassException extends RuntimeException {
+    constructor(value: any);
+}

node_modules/@nestjs/core/errors/exceptions/invalid-class.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidClassException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class InvalidClassException extends runtime_exception_1.RuntimeException {
+    constructor(value) {
+        super((0, messages_1.INVALID_CLASS_MESSAGE) `${value}`);
+    }
+}
+exports.InvalidClassException = InvalidClassException;

node_modules/@nestjs/core/errors/exceptions/invalid-exception-filter.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class InvalidExceptionFilterException extends RuntimeException {
+    constructor();
+}

node_modules/@nestjs/core/errors/exceptions/invalid-exception-filter.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidExceptionFilterException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+const messages_1 = require("../messages");
+class InvalidExceptionFilterException extends runtime_exception_1.RuntimeException {
+    constructor() {
+        super(messages_1.INVALID_EXCEPTION_FILTER);
+    }
+}
+exports.InvalidExceptionFilterException = InvalidExceptionFilterException;

node_modules/@nestjs/core/errors/exceptions/invalid-middleware-configuration.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class InvalidMiddlewareConfigurationException extends RuntimeException {
+    constructor();
+}

node_modules/@nestjs/core/errors/exceptions/invalid-middleware-configuration.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidMiddlewareConfigurationException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+const messages_1 = require("../messages");
+class InvalidMiddlewareConfigurationException extends runtime_exception_1.RuntimeException {
+    constructor() {
+        super(messages_1.INVALID_MIDDLEWARE_CONFIGURATION);
+    }
+}
+exports.InvalidMiddlewareConfigurationException = InvalidMiddlewareConfigurationException;

node_modules/@nestjs/core/errors/exceptions/invalid-middleware.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class InvalidMiddlewareException extends RuntimeException {
+    constructor(name: string);
+}

node_modules/@nestjs/core/errors/exceptions/invalid-middleware.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidMiddlewareException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class InvalidMiddlewareException extends runtime_exception_1.RuntimeException {
+    constructor(name) {
+        super((0, messages_1.INVALID_MIDDLEWARE_MESSAGE) `${name}`);
+    }
+}
+exports.InvalidMiddlewareException = InvalidMiddlewareException;

node_modules/@nestjs/core/errors/exceptions/invalid-module.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class InvalidModuleException extends RuntimeException {
+    constructor(parentModule: any, index: number, scope: any[]);
+}

node_modules/@nestjs/core/errors/exceptions/invalid-module.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidModuleException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class InvalidModuleException extends runtime_exception_1.RuntimeException {
+    constructor(parentModule, index, scope) {
+        super((0, messages_1.INVALID_MODULE_MESSAGE)(parentModule, index, scope));
+    }
+}
+exports.InvalidModuleException = InvalidModuleException;

node_modules/@nestjs/core/errors/exceptions/runtime.exception.d.ts

@@ -0,0 +1,4 @@
+export declare class RuntimeException extends Error {
+    constructor(message?: string);
+    what(): string;
+}

node_modules/@nestjs/core/errors/exceptions/runtime.exception.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeException = void 0;
+class RuntimeException extends Error {
+    constructor(message = ``) {
+        super(message);
+    }
+    what() {
+        return this.message;
+    }
+}
+exports.RuntimeException = RuntimeException;

node_modules/@nestjs/core/errors/exceptions/undefined-dependency.exception.d.ts

@@ -0,0 +1,6 @@
+import { InjectorDependencyContext } from '../../injector/injector';
+import { Module } from '../../injector/module';
+import { RuntimeException } from './runtime.exception';
+export declare class UndefinedDependencyException extends RuntimeException {
+    constructor(type: string, undefinedDependencyContext: InjectorDependencyContext, moduleRef?: Module);
+}

node_modules/@nestjs/core/errors/exceptions/undefined-dependency.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndefinedDependencyException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class UndefinedDependencyException extends runtime_exception_1.RuntimeException {
+    constructor(type, undefinedDependencyContext, moduleRef) {
+        super((0, messages_1.UNKNOWN_DEPENDENCIES_MESSAGE)(type, undefinedDependencyContext, moduleRef));
+    }
+}
+exports.UndefinedDependencyException = UndefinedDependencyException;

node_modules/@nestjs/core/errors/exceptions/undefined-forwardref.exception.d.ts

@@ -0,0 +1,5 @@
+import { RuntimeException } from './runtime.exception';
+import { Type } from '@nestjs/common';
+export declare class UndefinedForwardRefException extends RuntimeException {
+    constructor(scope: Type<any>[]);
+}

node_modules/@nestjs/core/errors/exceptions/undefined-forwardref.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndefinedForwardRefException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class UndefinedForwardRefException extends runtime_exception_1.RuntimeException {
+    constructor(scope) {
+        super((0, messages_1.UNDEFINED_FORWARDREF_MESSAGE)(scope));
+    }
+}
+exports.UndefinedForwardRefException = UndefinedForwardRefException;

node_modules/@nestjs/core/errors/exceptions/undefined-module.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class UndefinedModuleException extends RuntimeException {
+    constructor(parentModule: any, index: number, scope: any[]);
+}

node_modules/@nestjs/core/errors/exceptions/undefined-module.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndefinedModuleException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+const messages_1 = require("../messages");
+class UndefinedModuleException extends runtime_exception_1.RuntimeException {
+    constructor(parentModule, index, scope) {
+        super((0, messages_1.UNDEFINED_MODULE_MESSAGE)(parentModule, index, scope));
+    }
+}
+exports.UndefinedModuleException = UndefinedModuleException;

node_modules/@nestjs/core/errors/exceptions/unknown-dependencies.exception.d.ts

@@ -0,0 +1,16 @@
+import { InjectorDependencyContext } from '../../injector/injector';
+import { Module } from '../../injector/module';
+import { RuntimeException } from './runtime.exception';
+export declare class UnknownDependenciesException extends RuntimeException {
+    readonly type: string | symbol;
+    readonly context: InjectorDependencyContext;
+    readonly metadata?: {
+        id: string;
+    } | undefined;
+    readonly moduleRef: {
+        id: string;
+    } | undefined;
+    constructor(type: string | symbol, context: InjectorDependencyContext, moduleRef?: Module, metadata?: {
+        id: string;
+    } | undefined);
+}

node_modules/@nestjs/core/errors/exceptions/unknown-dependencies.exception.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownDependenciesException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class UnknownDependenciesException extends runtime_exception_1.RuntimeException {
+    constructor(type, context, moduleRef, metadata) {
+        super((0, messages_1.UNKNOWN_DEPENDENCIES_MESSAGE)(type, context, moduleRef));
+        this.type = type;
+        this.context = context;
+        this.metadata = metadata;
+        this.moduleRef = moduleRef && { id: moduleRef.id };
+    }
+}
+exports.UnknownDependenciesException = UnknownDependenciesException;

node_modules/@nestjs/core/errors/exceptions/unknown-element.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class UnknownElementException extends RuntimeException {
+    constructor(name?: string | symbol);
+}

node_modules/@nestjs/core/errors/exceptions/unknown-element.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownElementException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+class UnknownElementException extends runtime_exception_1.RuntimeException {
+    constructor(name) {
+        name = name && name.toString();
+        super(`Nest could not find ${name || 'given'} element (this provider does not exist in the current context)`);
+    }
+}
+exports.UnknownElementException = UnknownElementException;

node_modules/@nestjs/core/errors/exceptions/unknown-export.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class UnknownExportException extends RuntimeException {
+    constructor(token: string | symbol, moduleName: string);
+}

node_modules/@nestjs/core/errors/exceptions/unknown-export.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownExportException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class UnknownExportException extends runtime_exception_1.RuntimeException {
+    constructor(token, moduleName) {
+        super((0, messages_1.UNKNOWN_EXPORT_MESSAGE)(token, moduleName));
+    }
+}
+exports.UnknownExportException = UnknownExportException;

node_modules/@nestjs/core/errors/exceptions/unknown-module.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class UnknownModuleException extends RuntimeException {
+    constructor(moduleName?: string);
+}

node_modules/@nestjs/core/errors/exceptions/unknown-module.exception.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownModuleException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+class UnknownModuleException extends runtime_exception_1.RuntimeException {
+    constructor(moduleName) {
+        super(`Nest could not select the given module (${moduleName ? `"${moduleName}"` : 'it'} does not exist in current context).`);
+    }
+}
+exports.UnknownModuleException = UnknownModuleException;

node_modules/@nestjs/core/errors/exceptions/unknown-request-mapping.exception.d.ts

@@ -0,0 +1,5 @@
+import type { Type } from '@nestjs/common';
+import { RuntimeException } from './runtime.exception';
+export declare class UnknownRequestMappingException extends RuntimeException {
+    constructor(metatype: Type);
+}

node_modules/@nestjs/core/errors/exceptions/unknown-request-mapping.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownRequestMappingException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+const messages_1 = require("../messages");
+class UnknownRequestMappingException extends runtime_exception_1.RuntimeException {
+    constructor(metatype) {
+        super((0, messages_1.UNKNOWN_REQUEST_MAPPING)(metatype));
+    }
+}
+exports.UnknownRequestMappingException = UnknownRequestMappingException;

node_modules/@nestjs/core/errors/messages.d.ts

@@ -0,0 +1,17 @@
+import type { ForwardReference, Type } from '@nestjs/common';
+import { InjectorDependencyContext } from '../injector/injector';
+import { Module } from '../injector/module';
+export declare const UNKNOWN_DEPENDENCIES_MESSAGE: (type: string | symbol, unknownDependencyContext: InjectorDependencyContext, moduleRef: Module | undefined) => string;
+export declare const INVALID_MIDDLEWARE_MESSAGE: (text: TemplateStringsArray, name: string) => string;
+export declare const UNDEFINED_FORWARDREF_MESSAGE: (scope: Type<any>[]) => string;
+export declare const INVALID_MODULE_MESSAGE: (parentModule: any, index: number, scope: any[]) => string;
+export declare const USING_INVALID_CLASS_AS_A_MODULE_MESSAGE: (metatypeUsedAsAModule: Type | ForwardReference, scope: any[]) => string;
+export declare const UNDEFINED_MODULE_MESSAGE: (parentModule: any, index: number, scope: any[]) => string;
+export declare const UNKNOWN_EXPORT_MESSAGE: (token: string | symbol | undefined, module: string) => string;
+export declare const INVALID_CLASS_MESSAGE: (text: TemplateStringsArray, value: any) => string;
+export declare const INVALID_CLASS_SCOPE_MESSAGE: (text: TemplateStringsArray, name: string | undefined) => string;
+export declare const UNKNOWN_REQUEST_MAPPING: (metatype: Type) => string;
+export declare const INVALID_MIDDLEWARE_CONFIGURATION = "An invalid middleware configuration has been passed inside the module 'configure()' method.";
+export declare const UNHANDLED_RUNTIME_EXCEPTION = "Unhandled Runtime Exception.";
+export declare const INVALID_EXCEPTION_FILTER = "Invalid exception filters (@UseFilters()).";
+export declare const MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = "Unable to load @nestjs/microservices package. (Please make sure that it's already installed.)";

node_modules/@nestjs/core/errors/messages.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = exports.INVALID_EXCEPTION_FILTER = exports.UNHANDLED_RUNTIME_EXCEPTION = exports.INVALID_MIDDLEWARE_CONFIGURATION = exports.UNKNOWN_REQUEST_MAPPING = exports.INVALID_CLASS_SCOPE_MESSAGE = exports.INVALID_CLASS_MESSAGE = exports.UNKNOWN_EXPORT_MESSAGE = exports.UNDEFINED_MODULE_MESSAGE = exports.USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = exports.INVALID_MODULE_MESSAGE = exports.UNDEFINED_FORWARDREF_MESSAGE = exports.INVALID_MIDDLEWARE_MESSAGE = exports.UNKNOWN_DEPENDENCIES_MESSAGE = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+/**
+ * Returns the name of an instance or `undefined`
+ * @param instance The instance which should get the name from
+ */
+const getInstanceName = (instance) => {
+    if (instance?.forwardRef) {
+        return instance.forwardRef()?.name;
+    }
+    if (instance?.module) {
+        return instance.module?.name;
+    }
+    return instance?.name;
+};
+/**
+ * Returns the name of the dependency.
+ * Tries to get the class name, otherwise the string value
+ * (= injection token). As fallback to any falsy value for `dependency`, it
+ * returns `fallbackValue`
+ * @param dependency The name of the dependency to be displayed
+ * @param fallbackValue The fallback value if the dependency is falsy
+ * @param disambiguated Whether dependency's name is disambiguated with double quotes
+ */
+const getDependencyName = (dependency, fallbackValue, disambiguated = true) => 
+// use class name
+getInstanceName(dependency) ||
+    // use injection token (symbol)
+    ((0, shared_utils_1.isSymbol)(dependency) && dependency.toString()) ||
+    // use string directly
+    (dependency
+        ? disambiguated
+            ? `"${dependency}"`
+            : dependency
+        : undefined) ||
+    // otherwise
+    fallbackValue;
+/**
+ * Returns the name of the module
+ * Tries to get the class name. As fallback it returns 'current'.
+ * @param module The module which should get displayed
+ */
+const getModuleName = (module) => (module && getInstanceName(module.metatype)) || 'current';
+const stringifyScope = (scope) => (scope || []).map(getInstanceName).join(' -> ');
+const UNKNOWN_DEPENDENCIES_MESSAGE = (type, unknownDependencyContext, moduleRef) => {
+    const { index, name, dependencies, key } = unknownDependencyContext;
+    const moduleName = getModuleName(moduleRef);
+    const dependencyName = getDependencyName(name, 'dependency');
+    const isImportTypeIssue = !(0, shared_utils_1.isNil)(index) &&
+        dependencies &&
+        (dependencies[index] === undefined ||
+            dependencies[index] === Object ||
+            (typeof dependencies[index] === 'function' &&
+                dependencies[index].name === 'Object'));
+    let potentialSolutions;
+    if (isImportTypeIssue) {
+        potentialSolutions = `\n
+Potential solutions:
+- The dependency at index [${index}] appears to be undefined at runtime
+- This commonly occurs when using 'import type' instead of 'import' for injectable classes
+- Check your imports and change:
+  ❌ import type { SomeService } from './some.service';
+  ✅ import { SomeService } from './some.service';
+- Ensure the imported class is decorated with @Injectable() or is a valid provider
+- If using dynamic imports, ensure the class is available at runtime, not just for type checking
+
+For more common dependency resolution issues, see: https://docs.nestjs.com/faq/common-errors`;
+    }
+    else {
+        potentialSolutions =
+            // If module's name is well defined
+            moduleName !== 'current'
+                ? `\n
+Potential solutions:
+- Is ${moduleName} a valid NestJS module?
+- If ${dependencyName} is a provider, is it part of the current ${moduleName}?
+- If ${dependencyName} is exported from a separate @Module, is that module imported within ${moduleName}?
+  @Module({
+    imports: [ /* the Module containing ${dependencyName} */ ]
+  })
+
+For more common dependency resolution issues, see: https://docs.nestjs.com/faq/common-errors`
+                : `\n
+Potential solutions:
+- If ${dependencyName} is a provider, is it part of the current Module?
+- If ${dependencyName} is exported from a separate @Module, is that module imported within Module?
+  @Module({
+    imports: [ /* the Module containing ${dependencyName} */ ]
+  })
+
+For more common dependency resolution issues, see: https://docs.nestjs.com/faq/common-errors`;
+    }
+    let message = `Nest can't resolve dependencies of the ${type.toString()}`;
+    if ((0, shared_utils_1.isNil)(index)) {
+        message += `. Please make sure that the "${key.toString()}" property is available in the current context.${potentialSolutions}`;
+        return message;
+    }
+    const dependenciesName = (dependencies || []).map(dependencyName => getDependencyName(dependencyName, '+', false));
+    dependenciesName[index] = '?';
+    const tokenFragment = !isImportTypeIssue && name !== undefined ? ` ${dependencyName}` : '';
+    const contextLabel = isImportTypeIssue ? 'current' : moduleName;
+    message += ` (`;
+    message += dependenciesName.join(', ');
+    message += `). Please make sure that the argument${tokenFragment} at index [${index}]`;
+    message += ` is available in the ${contextLabel} module.`;
+    message += potentialSolutions;
+    return message;
+};
+exports.UNKNOWN_DEPENDENCIES_MESSAGE = UNKNOWN_DEPENDENCIES_MESSAGE;
+const INVALID_MIDDLEWARE_MESSAGE = (text, name) => `The middleware doesn't provide the 'use' method (${name})`;
+exports.INVALID_MIDDLEWARE_MESSAGE = INVALID_MIDDLEWARE_MESSAGE;
+const UNDEFINED_FORWARDREF_MESSAGE = (scope) => `Nest cannot create the module instance. Often, this is because of a circular dependency between modules. Use forwardRef() to avoid it.
+
+(Read more: https://docs.nestjs.com/fundamentals/circular-dependency)
+Scope [${stringifyScope(scope)}]
+`;
+exports.UNDEFINED_FORWARDREF_MESSAGE = UNDEFINED_FORWARDREF_MESSAGE;
+const INVALID_MODULE_MESSAGE = (parentModule, index, scope) => {
+    const parentModuleName = parentModule?.name || 'module';
+    return `Nest cannot create the ${parentModuleName} instance.
+Received an unexpected value at index [${index}] of the ${parentModuleName} "imports" array.
+
+Scope [${stringifyScope(scope)}]`;
+};
+exports.INVALID_MODULE_MESSAGE = INVALID_MODULE_MESSAGE;
+const USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = (metatypeUsedAsAModule, scope) => {
+    const metatypeNameQuote = `"${getInstanceName(metatypeUsedAsAModule)}"`;
+    return `Classes annotated with @Injectable(), @Catch(), and @Controller() decorators must not appear in the "imports" array of a module.
+Please remove ${metatypeNameQuote} (including forwarded occurrences, if any) from all of the "imports" arrays.
+
+Scope [${stringifyScope(scope)}]
+`;
+};
+exports.USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = USING_INVALID_CLASS_AS_A_MODULE_MESSAGE;
+const UNDEFINED_MODULE_MESSAGE = (parentModule, index, scope) => {
+    const parentModuleName = parentModule?.name || 'module';
+    return `Nest cannot create the ${parentModuleName} instance.
+The module at index [${index}] of the ${parentModuleName} "imports" array is undefined.
+
+Potential causes:
+- A circular dependency between modules. Use forwardRef() to avoid it. Read more: https://docs.nestjs.com/fundamentals/circular-dependency
+- The module at index [${index}] is of type "undefined". Check your import statements and the type of the module.
+
+Scope [${stringifyScope(scope)}]`;
+};
+exports.UNDEFINED_MODULE_MESSAGE = UNDEFINED_MODULE_MESSAGE;
+const UNKNOWN_EXPORT_MESSAGE = (token = 'item', module) => {
+    token = (0, shared_utils_1.isSymbol)(token) ? token.toString() : token;
+    return `Nest cannot export a provider/module that is not a part of the currently processed module (${module}). Please verify whether the exported ${token} is available in this particular context.
+
+Possible Solutions:
+- Is ${token} part of the relevant providers/imports within ${module}?
+
+For more common dependency resolution issues, see: https://docs.nestjs.com/faq/common-errors
+`;
+};
+exports.UNKNOWN_EXPORT_MESSAGE = UNKNOWN_EXPORT_MESSAGE;
+const INVALID_CLASS_MESSAGE = (text, value) => `ModuleRef cannot instantiate class (${value} is not constructable).`;
+exports.INVALID_CLASS_MESSAGE = INVALID_CLASS_MESSAGE;
+const INVALID_CLASS_SCOPE_MESSAGE = (text, name) => `${name || 'This class'} is marked as a scoped provider. Request and transient-scoped providers can't be used in combination with "get()" method. Please, use "resolve()" instead.`;
+exports.INVALID_CLASS_SCOPE_MESSAGE = INVALID_CLASS_SCOPE_MESSAGE;
+const UNKNOWN_REQUEST_MAPPING = (metatype) => {
+    const className = metatype.name;
+    return className
+        ? `An invalid controller has been detected. "${className}" does not have the @Controller() decorator but it is being listed in the "controllers" array of some module.`
+        : `An invalid controller has been detected. Perhaps, one of your controllers is missing the @Controller() decorator.`;
+};
+exports.UNKNOWN_REQUEST_MAPPING = UNKNOWN_REQUEST_MAPPING;
+exports.INVALID_MIDDLEWARE_CONFIGURATION = `An invalid middleware configuration has been passed inside the module 'configure()' method.`;
+exports.UNHANDLED_RUNTIME_EXCEPTION = `Unhandled Runtime Exception.`;
+exports.INVALID_EXCEPTION_FILTER = `Invalid exception filters (@UseFilters()).`;
+exports.MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = `Unable to load @nestjs/microservices package. (Please make sure that it's already installed.)`;