Initial commit - Event Planner application

node_modules/@nestjs/common/interfaces/modules/dynamic-module.interface.d.ts

@@ -0,0 +1,25 @@
+import { Type } from '../type.interface';
+import { ModuleMetadata } from './module-metadata.interface';
+/**
+ * Interface defining a Dynamic Module.
+ *
+ * @see [Dynamic Modules](https://docs.nestjs.com/modules#dynamic-modules)
+ *
+ * @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;
+}

node_modules/@nestjs/common/interfaces/modules/dynamic-module.interface.js

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

node_modules/@nestjs/common/interfaces/modules/forward-reference.interface.d.ts

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

node_modules/@nestjs/common/interfaces/modules/forward-reference.interface.js

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

node_modules/@nestjs/common/interfaces/modules/index.d.ts

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

node_modules/@nestjs/common/interfaces/modules/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./dynamic-module.interface"), exports);
+tslib_1.__exportStar(require("./forward-reference.interface"), exports);
+tslib_1.__exportStar(require("./injection-token.interface"), exports);
+tslib_1.__exportStar(require("./introspection-result.interface"), exports);
+tslib_1.__exportStar(require("./module-metadata.interface"), exports);
+tslib_1.__exportStar(require("./nest-module.interface"), exports);
+tslib_1.__exportStar(require("./optional-factory-dependency.interface"), exports);
+tslib_1.__exportStar(require("./provider.interface"), exports);

node_modules/@nestjs/common/interfaces/modules/injection-token.interface.d.ts

@@ -0,0 +1,6 @@
+import { Abstract } from '../abstract.interface';
+import { Type } from '../type.interface';
+/**
+ * @publicApi
+ */
+export type InjectionToken<T = any> = string | symbol | Type<T> | Abstract<T> | Function;

node_modules/@nestjs/common/interfaces/modules/injection-token.interface.js

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

node_modules/@nestjs/common/interfaces/modules/introspection-result.interface.d.ts

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

node_modules/@nestjs/common/interfaces/modules/introspection-result.interface.js

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

node_modules/@nestjs/common/interfaces/modules/module-metadata.interface.d.ts

@@ -0,0 +1,34 @@
+import { Abstract } from '../abstract.interface';
+import { Type } from '../type.interface';
+import { DynamicModule } from './dynamic-module.interface';
+import { ForwardReference } from './forward-reference.interface';
+import { Provider } from './provider.interface';
+/**
+ * Interface defining the property object that describes the module.
+ *
+ * @see [Modules](https://docs.nestjs.com/modules)
+ *
+ * @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 controllers defined in this module which have to be
+     * instantiated.
+     */
+    controllers?: Type<any>[];
+    /**
+     * Optional list of providers that will be instantiated by the Nest 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 | string | symbol | Provider | ForwardReference | Abstract<any> | Function>;
+}

node_modules/@nestjs/common/interfaces/modules/module-metadata.interface.js

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

node_modules/@nestjs/common/interfaces/modules/nest-module.interface.d.ts

@@ -0,0 +1,7 @@
+import { MiddlewareConsumer } from '../middleware/middleware-consumer.interface';
+/**
+ * @publicApi
+ */
+export interface NestModule {
+    configure(consumer: MiddlewareConsumer): any;
+}

node_modules/@nestjs/common/interfaces/modules/nest-module.interface.js

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

node_modules/@nestjs/common/interfaces/modules/optional-factory-dependency.interface.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken } from './injection-token.interface';
+/**
+ * @publicApi
+ */
+export type OptionalFactoryDependency = {
+    token: InjectionToken;
+    optional: boolean;
+};

node_modules/@nestjs/common/interfaces/modules/optional-factory-dependency.interface.js

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

node_modules/@nestjs/common/interfaces/modules/provider.interface.d.ts

@@ -0,0 +1,156 @@
+import { Scope } from '../scope-options.interface';
+import { Type } from '../type.interface';
+import { InjectionToken } from './injection-token.interface';
+import { OptionalFactoryDependency } from './optional-factory-dependency.interface';
+/**
+ *
+ * @publicApi
+ */
+export type Provider<T = any> = Type<any> | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | ExistingProvider<T>;
+/**
+ * Interface defining a *Class* type provider.
+ *
+ * For example:
+ * ```typescript
+ * const configServiceProvider = {
+ * provide: ConfigService,
+ * useClass:
+ *   process.env.NODE_ENV === 'development'
+ *     ? DevelopmentConfigService
+ *     : ProductionConfigService,
+ * };
+ * ```
+ *
+ * @see [Class providers](https://docs.nestjs.com/fundamentals/custom-providers#class-providers-useclass)
+ * @see [Injection scopes](https://docs.nestjs.com/fundamentals/injection-scopes)
+ *
+ * @publicApi
+ */
+export interface ClassProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Type (class name) of provider (instance to be injected).
+     */
+    useClass: Type<T>;
+    /**
+     * Optional enum defining lifetime of the provider that is injected.
+     */
+    scope?: Scope;
+    /**
+     * This option is only available on factory providers!
+     *
+     * @see [Use factory](https://docs.nestjs.com/fundamentals/custom-providers#factory-providers-usefactory)
+     */
+    inject?: never;
+    /**
+     * Flags provider as durable. This flag can be used in combination with custom context id
+     * factory strategy to construct lazy DI subtrees.
+     *
+     * This flag can be used only in conjunction with scope = Scope.REQUEST.
+     */
+    durable?: boolean;
+}
+/**
+ * Interface defining a *Value* type provider.
+ *
+ * For example:
+ * ```typescript
+ * const connectionProvider = {
+ *   provide: 'CONNECTION',
+ *   useValue: connection,
+ * };
+ * ```
+ *
+ * @see [Value providers](https://docs.nestjs.com/fundamentals/custom-providers#value-providers-usevalue)
+ *
+ * @publicApi
+ */
+export interface ValueProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Instance of a provider to be injected.
+     */
+    useValue: T;
+    /**
+     * This option is only available on factory providers!
+     *
+     * @see [Use factory](https://docs.nestjs.com/fundamentals/custom-providers#factory-providers-usefactory)
+     */
+    inject?: never;
+}
+/**
+ * Interface defining a *Factory* type provider.
+ *
+ * For example:
+ * ```typescript
+ * const connectionFactory = {
+ *   provide: 'CONNECTION',
+ *   useFactory: (optionsProvider: OptionsProvider) => {
+ *     const options = optionsProvider.get();
+ *     return new DatabaseConnection(options);
+ *   },
+ *   inject: [OptionsProvider],
+ * };
+ * ```
+ *
+ * @see [Factory providers](https://docs.nestjs.com/fundamentals/custom-providers#factory-providers-usefactory)
+ * @see [Injection scopes](https://docs.nestjs.com/fundamentals/injection-scopes)
+ *
+ * @publicApi
+ */
+export interface FactoryProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Factory function that returns an instance of the provider to be injected.
+     */
+    useFactory: (...args: any[]) => T | Promise<T>;
+    /**
+     * Optional list of providers to be injected into the context of the Factory function.
+     */
+    inject?: Array<InjectionToken | OptionalFactoryDependency>;
+    /**
+     * Optional enum defining lifetime of the provider that is returned by the Factory function.
+     */
+    scope?: Scope;
+    /**
+     * Flags provider as durable. This flag can be used in combination with custom context id
+     * factory strategy to construct lazy DI subtrees.
+     *
+     * This flag can be used only in conjunction with scope = Scope.REQUEST.
+     */
+    durable?: boolean;
+}
+/**
+ * Interface defining an *Existing* (aliased) type provider.
+ *
+ * For example:
+ * ```typescript
+ * const loggerAliasProvider = {
+ *   provide: 'AliasedLoggerService',
+ *   useExisting: LoggerService
+ * };
+ * ```
+ *
+ * @see [Alias providers](https://docs.nestjs.com/fundamentals/custom-providers#alias-providers-useexisting)
+ *
+ * @publicApi
+ */
+export interface ExistingProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Provider to be aliased by the Injection token.
+     */
+    useExisting: any;
+}

node_modules/@nestjs/common/interfaces/modules/provider.interface.js

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