graphql-modules 3.1.2-alpha-20260121024117-e03d9c26de1cfd3971986f82b995963e1cc77056 → 3.1.2-alpha-20260121024633-8af430e29a180a1d00c50c4bf74d342b3518267c

package/typings/application/application.d.ts

@@ -0,0 +1,32 @@
+import { ResolvedModule } from '../module/factory';
+import { ID } from '../shared/types';
+import { ApplicationConfig, Application } from './types';
+export type ModulesMap = Map<ID, ResolvedModule>;
+/**
+ * @internal
+ */
+export interface InternalAppContext {
+    ɵgetModuleContext(moduleId: ID, context: GraphQLModules.GlobalContext): GraphQLModules.ModuleContext;
+}
+/**
+ * @api
+ * Creates Application out of Modules. Accepts `ApplicationConfig`.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createApplication } from 'graphql-modules';
+ * import { usersModule } from './users';
+ * import { postsModule } from './posts';
+ * import { commentsModule } from './comments';
+ *
+ * const app = createApplication({
+ *   modules: [
+ *     usersModule,
+ *     postsModule,
+ *     commentsModule
+ *   ]
+ * })
+ * ```
+ */
+export declare function createApplication(applicationConfig: ApplicationConfig): Application;

package/typings/application/context.d.ts

@@ -0,0 +1,24 @@
+import { Injector, ReflectiveInjector } from '../di';
+import { ResolvedProvider } from '../di/resolution';
+import type { InternalAppContext, ModulesMap } from './application';
+export type ExecutionContextBuilder<TContext extends {
+    [key: string]: any;
+} = {}> = (context: TContext) => ExecutionContextEnv & {
+    runWithContext<TReturn = any>(cb: (env: ExecutionContextEnv) => TReturn): TReturn;
+};
+export type ExecutionContextEnv = {
+    context: InternalAppContext;
+    ɵdestroy(): void;
+    ɵinjector: Injector;
+};
+export declare function createContextBuilder({ appInjector, modulesMap, appLevelOperationProviders, singletonGlobalProvidersMap, operationGlobalProvidersMap, }: {
+    appInjector: ReflectiveInjector;
+    appLevelOperationProviders: ResolvedProvider[];
+    singletonGlobalProvidersMap: {
+        [key: string]: string;
+    };
+    operationGlobalProvidersMap: {
+        [key: string]: string;
+    };
+    modulesMap: ModulesMap;
+}): ExecutionContextBuilder<GraphQLModules.GlobalContext>;

package/typings/application/di.d.ts

@@ -0,0 +1,22 @@
+import { ModulesMap } from './application';
+import { ResolvedModule } from '../module/factory';
+import { ReflectiveInjector, Scope } from '../di';
+import { ResolvedProvider } from '../di/resolution';
+export declare function instantiateSingletonProviders({ appInjector, modulesMap, }: {
+    appInjector: ReflectiveInjector;
+    modulesMap: ModulesMap;
+}): void;
+export declare function createGlobalProvidersMap({ modules, scope, }: {
+    modules: ResolvedModule[];
+    scope: Scope;
+}): {
+    [key: string]: string;
+};
+export declare function attachGlobalProvidersMap({ injector, globalProvidersMap, moduleInjectorGetter, }: {
+    injector: ReflectiveInjector;
+    globalProvidersMap: {
+        [key: string]: string;
+    };
+    moduleInjectorGetter: (moduleId: string) => ReflectiveInjector;
+}): void;
+export declare function duplicatedGlobalTokenError(provider: ResolvedProvider, modules: [string, string]): Error;

package/typings/application/execution.d.ts

@@ -0,0 +1,8 @@
+import { execute } from 'graphql';
+import { ExecutionContextBuilder } from './context';
+export declare function executionCreator({ contextBuilder, }: {
+    contextBuilder: ExecutionContextBuilder;
+}): (options?: {
+    execute?: typeof execute;
+    controller?: import("./types").OperationController;
+}) => typeof execute;

package/typings/application/operation-controller.d.ts

@@ -0,0 +1,5 @@
+import type { Application } from './types';
+import type { ExecutionContextBuilder } from './context';
+export declare function operationControllerCreator(options: {
+    contextBuilder: ExecutionContextBuilder<GraphQLModules.GlobalContext>;
+}): Application['createOperationController'];

package/typings/application/subscription.d.ts

@@ -0,0 +1,8 @@
+import { subscribe } from 'graphql';
+import { ExecutionContextBuilder } from './context';
+export declare function subscriptionCreator({ contextBuilder, }: {
+    contextBuilder: ExecutionContextBuilder;
+}): (options?: {
+    subscribe?: typeof subscribe;
+    controller?: import("./types").OperationController;
+}) => typeof subscribe;

package/typings/application/tokens.d.ts

@@ -0,0 +1,17 @@
+import { InjectionToken } from '../di';
+/**
+ * @api
+ * `CONTEXT` is an InjectionToken representing the provided `GraphQLModules.GlobalContext`
+ *
+ * @example
+ *
+ * ```typescript
+ * import { CONTEXT, Inject, Injectable } from 'graphql-modules';
+ *
+ * (A)Injectable()
+ * export class Data {
+ *   constructor((A)Inject(CONTEXT) private context: GraphQLModules.GlobalContext) {}
+ * }
+ * ```
+ */
+export declare const CONTEXT: InjectionToken<any>;

package/typings/application/types.d.ts

@@ -0,0 +1,130 @@
+import { execute, subscribe, DocumentNode, GraphQLSchema, ExecutionResult } from 'graphql';
+import type { Provider, Injector } from '../di';
+import type { Resolvers, Module, MockedModule } from '../module/types';
+import type { MiddlewareMap } from '../shared/middleware';
+import type { ApolloRequestContext } from './apollo';
+import type { Single } from '../shared/types';
+import type { InternalAppContext } from './application';
+type Execution = typeof execute;
+type Subscription = typeof subscribe;
+export type ApolloExecutor = (requestContext: ApolloRequestContext) => Promise<ExecutionResult>;
+export interface MockedApplication extends Application {
+    replaceModule(mockedModule: MockedModule): MockedApplication;
+    addProviders(providers: ApplicationConfig['providers']): MockedApplication;
+}
+/**
+ * @api
+ * A return type of `createApplication` function.
+ */
+export interface Application {
+    /**
+     * A list of type definitions defined by modules.
+     */
+    readonly typeDefs: DocumentNode[];
+    /**
+     * An object with resolve functions defined by modules.
+     */
+    readonly resolvers?: Single<Resolvers>;
+    /**
+     * Ready to use GraphQLSchema object combined from modules.
+     */
+    readonly schema: GraphQLSchema;
+    /**
+     * The application (Singleton) injector.
+     */
+    readonly injector: Injector;
+    /**
+     * Take over control of GraphQL Operation
+     */
+    createOperationController(input: {
+        context: any;
+        autoDestroy?: boolean;
+    }): OperationController;
+    /**
+     * Creates a `subscribe` function that runs the subscription phase of GraphQL.
+     * Important when using GraphQL Subscriptions.
+     */
+    createSubscription(options?: {
+        subscribe?: typeof subscribe;
+        controller?: OperationController;
+    }): Subscription;
+    /**
+     * Creates a `execute` function that runs the execution phase of GraphQL.
+     * Important when using GraphQL Queries and Mutations.
+     */
+    createExecution(options?: {
+        execute?: typeof execute;
+        controller?: OperationController;
+    }): Execution;
+    /**
+     * @deprecated Use `createApolloExecutor`, `createExecution` and `createSubscription` methods instead.
+     */
+    createSchemaForApollo(): GraphQLSchema;
+    /**
+     * Experimental
+     */
+    createApolloExecutor(options?: {
+        controller?: OperationController;
+    }): ApolloExecutor;
+    /**
+     * @internal
+     */
+    ɵfactory(config?: ApplicationConfig | undefined): Application;
+    /**
+     * @internal
+     */
+    ɵconfig: ApplicationConfig;
+}
+export interface OperationController {
+    /**
+     * Destroys
+     */
+    destroy(): void;
+    /**
+     * @internal
+     */
+    ɵdestroy(): void;
+    context: InternalAppContext;
+    /**
+     * Operation Injector (application)
+     */
+    injector: Injector;
+}
+/**
+ * @api
+ * Application's configuration object. Represents the first argument of `createApplication` function.
+ */
+export interface ApplicationConfig {
+    /**
+     * A list of GraphQL Modules
+     */
+    modules: Module[];
+    /**
+     * A list of Providers - read the ["Providers and Tokens"](./di/providers) chapter.
+     */
+    providers?: Provider[] | (() => Provider[]);
+    /**
+     * A map of middlewares - read the ["Middlewares"](./advanced/middlewares) chapter.
+     */
+    middlewares?: MiddlewareMap;
+    /**
+     * Creates a GraphQLSchema object out of typeDefs and resolvers
+     *
+     * @example
+     *
+     * ```typescript
+     * import { createApplication } from 'graphql-modules';
+     * import { makeExecutableSchema } from '@graphql-tools/schema';
+     *
+     * const app = createApplication({
+     *   modules: [],
+     *   schemaBuilder: makeExecutableSchema
+     * })
+     * ```
+     */
+    schemaBuilder?(input: {
+        typeDefs: DocumentNode[];
+        resolvers: Record<string, any>[];
+    }): GraphQLSchema;
+}
+export {};

package/typings/di/decorators.d.ts

@@ -0,0 +1,11 @@
+import { Type, ProviderOptions, InjectionToken } from './providers';
+import { Injector } from './injector';
+export declare function Injectable(options?: ProviderOptions): ClassDecorator;
+type ParameterDecorator = (target: Object, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
+export declare function Optional(): ParameterDecorator;
+export declare function Inject(type: Type<any> | InjectionToken<any>): ParameterDecorator;
+export type ExecutionContext = {
+    injector: Injector;
+} & GraphQLModules.ModuleContext;
+export declare function ExecutionContext(): PropertyDecorator;
+export {};

package/typings/di/errors.d.ts

@@ -0,0 +1,16 @@
+import { InjectableParamMetadata } from './metadata';
+import { Type, InjectionToken } from './providers';
+import { ReflectiveInjector } from './injector';
+import { Key } from './registry';
+export declare function invalidProviderError(provider: any): Error;
+export declare function noInjectableError(type: Type<any>): Error;
+export declare function noAnnotationError(typeOrFunc: Type<any> | InjectionToken<any> | Function, params: InjectableParamMetadata[]): Error;
+export declare function cyclicDependencyError(injector: ReflectiveInjector, key: Key): InjectionError;
+export declare function noProviderError(injector: ReflectiveInjector, key: Key): InjectionError;
+export declare function instantiationError(injector: ReflectiveInjector, originalException: any, key: Key): InjectionError;
+export interface InjectionError extends Error {
+    keys: Key[];
+    injectors: ReflectiveInjector[];
+    constructResolvingMessage: (this: InjectionError) => string;
+    addKey(key: Key): void;
+}

package/typings/di/forward-ref.d.ts

@@ -0,0 +1,7 @@
+import { Type } from './providers';
+export type ForwardRefFn<T> = () => T;
+/**
+ * Useful in "circular dependencies of modules" situation
+ */
+export declare function forwardRef<T>(forwardRefFn: ForwardRefFn<T>): Type<any>;
+export declare function resolveForwardRef(type: any): any;

package/typings/di/index.d.ts

@@ -0,0 +1,5 @@
+export { Injectable, Optional, Inject, ExecutionContext } from './decorators';
+export { forwardRef } from './forward-ref';
+export { InjectionToken, Type, Provider, AbstractType, ValueProvider, ClassProvider, Factory, FactoryProvider, TypeProvider, ProviderOptions, Scope, onlySingletonProviders, onlyOperationProviders, } from './providers';
+export { Injector, ReflectiveInjector } from './injector';
+export { InjectionError } from './errors';

package/typings/di/injector.d.ts

@@ -0,0 +1,50 @@
+import { Type, InjectionToken, Provider, AbstractType } from './providers';
+import { ResolvedProvider, GlobalProviderMap } from './resolution';
+import { Key } from './registry';
+import { ExecutionContext } from './decorators';
+type ExecutionContextGetter = () => ExecutionContext | never;
+export declare abstract class Injector {
+    abstract get<T>(token: Type<T> | InjectionToken<T> | AbstractType<T>, notFoundValue?: any): T;
+}
+export declare class ReflectiveInjector implements Injector {
+    displayName: string;
+    _constructionCounter: number;
+    _providers: ResolvedProvider[];
+    _globalProvidersMap: GlobalProviderMap;
+    private _executionContextGetter;
+    private _fallbackParent;
+    private _parent;
+    private _keyIds;
+    private _objs;
+    constructor({ name, providers, parent, fallbackParent, globalProvidersMap, }: {
+        name: string;
+        proxy?: boolean;
+        providers: ResolvedProvider[];
+        parent?: Injector | null;
+        fallbackParent?: Injector | null;
+        globalProvidersMap?: GlobalProviderMap;
+    });
+    static createFromResolved({ name, providers, parent, fallbackParent, globalProvidersMap, }: {
+        name: string;
+        providers: ResolvedProvider[];
+        parent?: Injector;
+        fallbackParent?: Injector;
+        globalProvidersMap?: GlobalProviderMap;
+    }): ReflectiveInjector;
+    static resolve(providers: Provider[]): ResolvedProvider[];
+    get parent(): Injector | null;
+    get fallbackParent(): Injector | null;
+    get(token: any, notFoundValue?: any): any;
+    setExecutionContextGetter(getter: ExecutionContextGetter): void;
+    private _getByKey;
+    _isObjectDefinedByKeyId(keyId: number): boolean;
+    _getObjByKeyId(keyId: number): any;
+    _throwOrNull(key: Key, notFoundValue: any): any;
+    instantiateAll(): void;
+    private _instantiateProvider;
+    private _getByDependency;
+    private _new;
+    private _getMaxNumberOfObjects;
+    toString(): string;
+}
+export {};

package/typings/di/metadata.d.ts

@@ -0,0 +1,12 @@
+import { Type, ProviderOptions, InjectionToken } from './providers';
+export declare const INJECTABLE: unique symbol;
+export interface InjectableParamMetadata {
+    type: Type<any> | InjectionToken<any>;
+    optional: boolean;
+}
+export interface InjectableMetadata {
+    params: InjectableParamMetadata[];
+    options?: ProviderOptions;
+}
+export declare function readInjectableMetadata(type: Type<any>, throwOnMissing?: boolean): InjectableMetadata;
+export declare function ensureInjectableMetadata(type: Type<any>): void;

package/typings/di/providers.d.ts

@@ -0,0 +1,44 @@
+export declare const Type: FunctionConstructor;
+export declare class InjectionToken<T> {
+    private _desc;
+    constructor(_desc: string);
+    toString(): string;
+}
+export declare function isToken(v: any): v is InjectionToken<any>;
+export declare function isType(v: any): v is Type<any>;
+export interface AbstractType<T> extends Function {
+    prototype: T;
+}
+export interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+export interface ValueProvider<T> extends BaseProvider<T> {
+    useValue: T;
+}
+export interface ClassProvider<T> extends BaseProvider<T> {
+    useClass: Type<T>;
+}
+export type Factory<T> = (...args: any[]) => T;
+export interface FactoryProvider<T> extends BaseProvider<T> {
+    useFactory: Factory<T>;
+    deps?: any[];
+}
+export interface BaseProvider<T> extends ProviderOptions {
+    provide: Type<T> | InjectionToken<T> | AbstractType<T>;
+}
+export interface TypeProvider<T> extends Type<T> {
+}
+export type Provider<T = any> = TypeProvider<T> | ValueProvider<T> | ClassProvider<T> | FactoryProvider<T>;
+export interface ProviderOptions {
+    scope?: Scope;
+    executionContextIn?: Array<string | symbol>;
+    global?: boolean;
+}
+export declare enum Scope {
+    Singleton = 0,
+    Operation = 1
+}
+export declare function onlySingletonProviders(providers?: Provider[]): Provider[];
+export declare function onlyOperationProviders(providers?: Provider[]): Provider[];
+export declare function isClassProvider(provider: any): provider is ClassProvider<any>;
+export declare function isFactoryProvider(provider: any): provider is FactoryProvider<any>;

package/typings/di/registry.d.ts

@@ -0,0 +1,11 @@
+import { Type } from './providers';
+export declare class Key {
+    token: Type<any>;
+    id: number;
+    constructor(token: Type<any>, id: number);
+    /**
+     * Returns a stringified token.
+     */
+    get displayName(): string;
+    static get(token: Object): Key;
+}

package/typings/di/resolution.d.ts

@@ -0,0 +1,63 @@
+import { Provider, ValueProvider, ClassProvider, FactoryProvider } from './providers';
+import { Key } from './registry';
+import { ReflectiveInjector } from './injector';
+export type NormalizedProvider<T = any> = ValueProvider<T> | ClassProvider<T> | FactoryProvider<T>;
+export type GlobalProviderMap = {
+    has(key: Key['id']): boolean;
+    get(key: Key['id']): ReflectiveInjector;
+};
+export declare class ResolvedProvider {
+    key: Key;
+    factory: ResolvedFactory;
+    constructor(key: Key, factory: ResolvedFactory);
+}
+export declare class ResolvedFactory {
+    /**
+     * Factory function which can return an instance of an object represented by a key.
+     */
+    factory: Function;
+    /**
+     * Arguments (dependencies) to the `factory` function.
+     */
+    dependencies: Dependency[];
+    /**
+     * Methods invoked within ExecutionContext.
+     */
+    executionContextIn: Array<string | symbol>;
+    /**
+     * Has onDestroy hook
+     */
+    hasOnDestroyHook: boolean;
+    /**
+     * Is Global
+     */
+    isGlobal: boolean;
+    constructor(
+    /**
+     * Factory function which can return an instance of an object represented by a key.
+     */
+    factory: Function, 
+    /**
+     * Arguments (dependencies) to the `factory` function.
+     */
+    dependencies: Dependency[], 
+    /**
+     * Methods invoked within ExecutionContext.
+     */
+    executionContextIn: Array<string | symbol>, 
+    /**
+     * Has onDestroy hook
+     */
+    hasOnDestroyHook: boolean, 
+    /**
+     * Is Global
+     */
+    isGlobal: boolean);
+}
+export declare class Dependency {
+    key: Key;
+    optional: boolean;
+    constructor(key: Key, optional: boolean);
+    static fromKey(key: Key): Dependency;
+}
+export declare function resolveProviders(providers: Provider[]): ResolvedProvider[];

package/typings/di/utils.d.ts

@@ -0,0 +1,8 @@
+export declare const ERROR_TYPE = "diType";
+export declare const ERROR_ORIGINAL_ERROR = "diOriginalError";
+export declare const ERROR_LOGGER = "diErrorLogger";
+export declare function getType(error: Error): Function;
+export declare function getOriginalError(error: Error): Error;
+export declare function getErrorLogger(error: Error): (console: Console, ...values: any[]) => void;
+export declare function wrappedError(message: string, originalError: any): Error;
+export declare function stringify(token: any): string;

package/typings/index.d.ts

@@ -0,0 +1,13 @@
+export { createApplication } from './application/application';
+export * from './application/tokens';
+export * from './application/types';
+export { createModule } from './module/module';
+export * from './module/types';
+export * from './module/metadata';
+export * from './module/tokens';
+export { Injector, Inject, Injectable, Optional, ExecutionContext, Provider, ProviderOptions, FactoryProvider, ClassProvider, ValueProvider, TypeProvider, forwardRef, InjectionToken, Scope, } from './di';
+export { Middleware, MiddlewareContext } from './shared/middleware';
+import './shared/types';
+export { gql } from './shared/gql';
+export * from './shared/di';
+export * from './testing';

package/typings/module/factory.d.ts

@@ -0,0 +1,16 @@
+import { Module, ModuleConfig, Resolvers } from './types';
+import { ReflectiveInjector } from '../di';
+import { ResolvedProvider } from './../di/resolution';
+import { MiddlewareMap } from '../shared/middleware';
+import { Single } from '../shared/types';
+export type ResolvedModule = {
+    injector: ReflectiveInjector;
+    singletonProviders: Array<ResolvedProvider>;
+    operationProviders: Array<ResolvedProvider>;
+    resolvers?: Single<Resolvers>;
+} & Omit<Module, 'factory'>;
+export type ModuleFactory = (app: {
+    injector: ReflectiveInjector;
+    middlewares: MiddlewareMap;
+}) => ResolvedModule;
+export declare function moduleFactory(config: ModuleConfig): Module;

package/typings/module/metadata.d.ts

@@ -0,0 +1,12 @@
+import { DocumentNode } from 'graphql';
+import { ModuleConfig } from './types';
+import { ID } from '../shared/types';
+export type Registry = Record<string, string[]>;
+export interface ModuleMetadata {
+    id: ID;
+    typeDefs: DocumentNode[];
+    implements?: Registry;
+    extends?: Registry;
+    dirname?: string;
+}
+export declare function metadataFactory(typeDefs: DocumentNode[], config: ModuleConfig): ModuleMetadata;

package/typings/module/module.d.ts

@@ -0,0 +1,22 @@
+import { ModuleConfig } from './types';
+/**
+ * @api
+ * Creates a Module, an element used by Application. Accepts `ModuleConfig`.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createModule, gql } from 'graphql-modules';
+ *
+ * export const usersModule = createModule({
+ *   id: 'users',
+ *   typeDefs: gql`
+ *     // GraphQL SDL
+ *   `,
+ *   resolvers: {
+ *     // ...
+ *   }
+ * });
+ * ```
+ */
+export declare function createModule(config: ModuleConfig): import("./types").Module;

package/typings/module/resolvers.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLFieldExtensions } from 'graphql';
+import { ModuleConfig } from './types';
+import { ModuleMetadata } from './metadata';
+import { ResolveFn, ID } from './../shared/types';
+import { MiddlewareMap } from '../shared/middleware';
+interface ResolverMetadata {
+    moduleId: ID;
+}
+export declare function createResolvers(config: ModuleConfig, metadata: ModuleMetadata, app: {
+    middlewareMap: MiddlewareMap;
+}): Record<string, any>;
+export declare function readResolverMetadata(resolver: ResolveFn | GraphQLFieldExtensions<any, any, any>): ResolverMetadata;
+export {};

package/typings/module/tokens.d.ts

@@ -0,0 +1,18 @@
+import { InjectionToken } from '../di';
+/**
+ * @api
+ * `MODULE_ID` is an InjectionToken representing module's ID
+ *
+ * @example
+ * ```typescript
+ * import { MODULE_ID, Inject, Injectable } from 'graphql-modules';
+ *
+ * (A)Injectable()
+ * export class Data {
+ *   constructor((A)Inject(MODULE_ID) moduleId: string) {
+ *     console.log(`Data used in ${moduleId} module`)
+ *   }
+ * }
+ * ```
+ */
+export declare const MODULE_ID: InjectionToken<string>;

package/typings/module/type-defs.d.ts

@@ -0,0 +1,7 @@
+import { DocumentNode } from 'graphql';
+import { ModuleConfig } from './types';
+/**
+ * Create a list of DocumentNode objects based on Module's config.
+ * Add a location, so we get richer errors.
+ */
+export declare function createTypeDefs(config: ModuleConfig): DocumentNode[];

package/typings/module/types.d.ts

@@ -0,0 +1,51 @@
+import { DocumentNode } from 'graphql';
+import { ModuleFactory } from './factory';
+import { ID, Plural } from '../shared/types';
+import { ModuleMetadata } from './metadata';
+import { Provider } from '../di';
+import { MiddlewareMap } from '../shared/middleware';
+export type TypeDefs = Plural<DocumentNode>;
+export type Resolvers = Plural<Record<string, any>>;
+/**
+ * @api
+ * Module's configuration object. Represents the first argument of `createModule` function.
+ */
+export interface ModuleConfig {
+    /**
+     * Unique identifier of a module
+     */
+    id: ID;
+    /**
+     * Pass `__dirname` variable as a value to get better error messages.
+     */
+    dirname?: string;
+    /**
+     * An object or a list of GraphQL type definitions (SDL).
+     */
+    typeDefs: TypeDefs;
+    /**
+     * An object or a list of GraphQL resolve functions.
+     */
+    resolvers?: Resolvers;
+    /**
+     * A map of middlewares - read the ["Middlewares"](./advanced/middlewares) chapter.
+     */
+    middlewares?: MiddlewareMap;
+    /**
+     * A list of Providers - read the ["Providers and Tokens"](./di/providers) chapter.
+     */
+    providers?: Provider[] | (() => Provider[]);
+}
+export interface Module {
+    id: ID;
+    typeDefs: DocumentNode[];
+    metadata: ModuleMetadata;
+    factory: ModuleFactory;
+    config: ModuleConfig;
+}
+export interface MockedModule extends Module {
+    /**
+     * @internal
+     */
+    ɵoriginalModule: Module;
+}

package/typings/shared/di.d.ts

@@ -0,0 +1,3 @@
+export interface OnDestroy {
+    onDestroy(): void;
+}