@nx-ddd/core 3.1.0

package/README.md

@@ -0,0 +1,11 @@
+# core
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test core` to execute the unit tests via [Jest](https://jestjs.io).
+
+## Running lint
+
+Run `nx lint core` to execute the lint via [ESLint](https://eslint.org/).

package/_testing/index.d.ts

@@ -0,0 +1,23 @@
+import { InjectionToken } from 'injection-js';
+import 'reflect-metadata';
+export declare const EXAMPLE_VALUE: InjectionToken<unknown>;
+export declare abstract class Repository {
+    get name(): string;
+}
+export declare class AppService {
+    repository: Repository;
+    constructor(repository: Repository);
+}
+export declare class FeatureModule {
+}
+export declare class LibraryModule {
+    static forRoot(): {
+        nxModule: typeof LibraryModule;
+        providers: {
+            provide: InjectionToken<unknown>;
+            useValue: string;
+        }[];
+    };
+}
+export declare class AppModule {
+}

package/_testing/index.js

@@ -0,0 +1,71 @@
+"use strict";
+var LibraryModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppModule = exports.LibraryModule = exports.FeatureModule = exports.AppService = exports.Repository = exports.EXAMPLE_VALUE = void 0;
+const tslib_1 = require("tslib");
+const nx_module_1 = require("../nx-module");
+const injection_js_1 = require("injection-js");
+require("reflect-metadata");
+exports.EXAMPLE_VALUE = new injection_js_1.InjectionToken('examole value');
+let Repository = class Repository {
+    get name() {
+        throw new Error('Repository.name is not implemented!');
+    }
+};
+Repository = tslib_1.__decorate([
+    (0, injection_js_1.Injectable)()
+], Repository);
+exports.Repository = Repository;
+let AppService = class AppService {
+    constructor(repository) {
+        this.repository = repository;
+    }
+};
+AppService = tslib_1.__decorate([
+    (0, injection_js_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [Repository])
+], AppService);
+exports.AppService = AppService;
+let FeatureModule = class FeatureModule {
+};
+FeatureModule = tslib_1.__decorate([
+    (0, nx_module_1.NxModule)({
+        imports: [],
+        providers: [{ provide: exports.EXAMPLE_VALUE, useValue: 'featureValue' }],
+    })
+], FeatureModule);
+exports.FeatureModule = FeatureModule;
+let LibraryModule = LibraryModule_1 = class LibraryModule {
+    static forRoot() {
+        return {
+            nxModule: LibraryModule_1,
+            providers: [
+                { provide: exports.EXAMPLE_VALUE, useValue: 'rootValue' },
+            ],
+        };
+    }
+};
+LibraryModule = LibraryModule_1 = tslib_1.__decorate([
+    (0, nx_module_1.NxModule)({
+        imports: [
+            FeatureModule,
+        ],
+        providers: []
+    })
+], LibraryModule);
+exports.LibraryModule = LibraryModule;
+let AppModule = class AppModule {
+};
+AppModule = tslib_1.__decorate([
+    (0, nx_module_1.NxModule)({
+        imports: [
+            LibraryModule.forRoot(),
+        ],
+        providers: [
+            AppService,
+            Repository,
+        ]
+    })
+], AppModule);
+exports.AppModule = AppModule;
+//# sourceMappingURL=index.js.map

package/_testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/core/src/_testing/index.ts"],"names":[],"mappings":";;;;;AAAA,4CAAwC;AACxC,+CAA0D;AAC1D,4BAA0B;AAEb,QAAA,aAAa,GAAG,IAAI,6BAAc,CAAC,eAAe,CAAC,CAAC;AAIjE,IAAsB,UAAU,GAAhC,MAAsB,UAAU;IAC9B,IAAI,IAAI;QACN,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;IACzD,CAAC;CACF,CAAA;AAJqB,UAAU;IAD/B,IAAA,yBAAU,GAAE;GACS,UAAU,CAI/B;AAJqB,gCAAU;AAOhC,IAAa,UAAU,GAAvB,MAAa,UAAU;IACrB,YAAmB,UAAsB;QAAtB,eAAU,GAAV,UAAU,CAAY;IAAI,CAAC;CAC/C,CAAA;AAFY,UAAU;IADtB,IAAA,yBAAU,GAAE;6CAEoB,UAAU;GAD9B,UAAU,CAEtB;AAFY,gCAAU;AAQvB,IAAa,aAAa,GAA1B,MAAa,aAAa;CAAI,CAAA;AAAjB,aAAa;IAJzB,IAAA,oBAAQ,EAAC;QACR,OAAO,EAAE,EAAE;QACX,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,qBAAa,EAAE,QAAQ,EAAE,cAAc,EAAC,CAAC;KACjE,CAAC;GACW,aAAa,CAAI;AAAjB,sCAAa;AAQ1B,IAAa,aAAa,qBAA1B,MAAa,aAAa;IACxB,MAAM,CAAC,OAAO;QACZ,OAAO;YACL,QAAQ,EAAE,eAAa;YACvB,SAAS,EAAE;gBACT,EAAC,OAAO,EAAE,qBAAa,EAAE,QAAQ,EAAE,WAAW,EAAC;aAChD;SACF,CAAA;IACH,CAAC;CACF,CAAA;AATY,aAAa;IANzB,IAAA,oBAAQ,EAAC;QACR,OAAO,EAAE;YACP,aAAa;SACd;QACD,SAAS,EAAE,EAAE;KACd,CAAC;GACW,aAAa,CASzB;AATY,sCAAa;AAoB1B,IAAa,SAAS,GAAtB,MAAa,SAAS;CAAI,CAAA;AAAb,SAAS;IATrB,IAAA,oBAAQ,EAAC;QACR,OAAO,EAAE;YACP,aAAa,CAAC,OAAO,EAAE;SACxB;QACD,SAAS,EAAE;YACT,UAAU;YACV,UAAU;SACX;KACF,CAAC;GACW,SAAS,CAAI;AAAb,8BAAS"}

package/di/create-injector.d.ts

@@ -0,0 +1,4 @@
+import { Injector } from './injector';
+import { StaticProvider } from './interface/provider';
+export declare function createInjector(defType: any, additionalProviders?: StaticProvider[] | null, parent?: Injector | null, name?: string): Injector;
+export declare function createInjectorWithoutInjectorInstances(defType: any, parent?: Injector | null, additionalProviders?: StaticProvider[] | null, name?: string): Injector;

package/di/create-injector.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInjectorWithoutInjectorInstances = exports.createInjector = void 0;
+const empty_1 = require("../util/empty");
+const stringify_1 = require("../util/stringify");
+const injector_1 = require("./injector");
+const provider_collection_1 = require("./provider-collection");
+function createInjector(defType, additionalProviders = null, parent = null, name) {
+    return createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
+}
+exports.createInjector = createInjector;
+function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name) {
+    const providers = [
+        ...(0, provider_collection_1.internalImportProvidersFrom)(defType),
+        ...(additionalProviders || empty_1.EMPTY_ARRAY),
+    ];
+    name = name || (typeof defType === 'object' ? undefined : (0, stringify_1.stringify)(defType));
+    return (0, injector_1.resolveAndCreate)(providers, parent || injector_1.Injector.NULL);
+}
+exports.createInjectorWithoutInjectorInstances = createInjectorWithoutInjectorInstances;
+//# sourceMappingURL=create-injector.js.map

package/di/create-injector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-injector.js","sourceRoot":"","sources":["../../../../libs/core/src/di/create-injector.ts"],"names":[],"mappings":";;;AAAA,yCAA4C;AAC5C,iDAA8C;AAC9C,yCAAwD;AAExD,+DAAoE;AAEpE,SAAgB,cAAc,CAC5B,OAAoC,EACpC,sBAA+C,IAAI,EACnD,SAA0B,IAAI,EAC9B,IAAa;IAEb,OAAO,sCAAsC,CAAC,OAAO,EAAE,MAAM,EAAE,mBAAmB,EAAE,IAAI,CAAC,CAAC;AAC5F,CAAC;AAPD,wCAOC;AAED,SAAgB,sCAAsC,CACpD,OAAoC,EACpC,SAA0B,IAAI,EAC9B,sBAA+C,IAAI,EACnD,IAAa;IAEb,MAAM,SAAS,GAAG;QAChB,GAAG,IAAA,iDAA2B,EAAC,OAAO,CAAC;QACvC,GAAG,CAAC,mBAAmB,IAAI,mBAAW,CAAC;KACxC,CAAC;IACF,IAAI,GAAG,IAAI,IAAI,CAAC,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAA,qBAAS,EAAC,OAAO,CAAC,CAAC,CAAC;IAC9E,OAAO,IAAA,2BAAgB,EAAC,SAAS,EAAE,MAAM,IAAI,mBAAQ,CAAC,IAAI,CAAC,CAAC;AAC9D,CAAC;AAZD,wFAYC"}

package/di/definition-factory.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Type } from './interface/type';
+/**
+ * Definition of what a factory function should look like.
+ */
+export declare type FactoryFn<T> = {
+    /**
+     * Subclasses without an explicit constructor call through to the factory of their base
+     * definition, providing it with their own constructor to instantiate.
+     */
+    <U extends T>(t?: Type<U>): U;
+    /**
+     * If no constructor to instantiate is provided, an instance of type T itself is created.
+     */
+    (t?: undefined): T;
+};
+export declare function getFactoryDef<T>(type: any, throwNotFound: true): FactoryFn<T>;
+export declare function getFactoryDef<T>(type: any): FactoryFn<T> | null;

package/di/definition-factory.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFactoryDef = void 0;
+const stringify_1 = require("../util/stringify");
+// import {NG_FACTORY_DEF} from './fields';
+const NG_FACTORY_DEF = 'ɵfac';
+function getFactoryDef(type, throwNotFound) {
+    const hasFactoryDef = type.hasOwnProperty(NG_FACTORY_DEF);
+    if (!hasFactoryDef && throwNotFound === true) {
+        throw new Error(`Type ${(0, stringify_1.stringify)(type)} does not have 'ɵfac' property.`);
+    }
+    return hasFactoryDef ? type[NG_FACTORY_DEF] : null;
+}
+exports.getFactoryDef = getFactoryDef;
+//# sourceMappingURL=definition-factory.js.map

package/di/definition-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-factory.js","sourceRoot":"","sources":["../../../../libs/core/src/di/definition-factory.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAGH,iDAA4C;AAC5C,2CAA2C;AAE3C,MAAM,cAAc,GAAG,MAAM,CAAC;AAoB9B,SAAgB,aAAa,CAAI,IAAS,EAAE,aAAuB;IACjE,MAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;IAC1D,IAAI,CAAC,aAAa,IAAI,aAAa,KAAK,IAAI,EAAE;QAC5C,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAA,qBAAS,EAAC,IAAI,CAAC,iCAAiC,CAAC,CAAC;KAC3E;IACD,OAAO,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACrD,CAAC;AAND,sCAMC"}

package/di/forward_ref.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Type } from './interface/type';
+/**
+ * An interface that a function passed into {@link forwardRef} has to implement.
+ *
+ * @usageNotes
+ * ### Example
+ *
+ * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref_fn'}
+ * @publicApi
+ */
+export interface ForwardRefFn {
+    (): any;
+}
+/**
+ * Allows to refer to references which are not yet defined.
+ *
+ * For instance, `forwardRef` is used when the `token` which we need to refer to for the purposes of
+ * DI is declared, but not yet defined. It is also used when the `token` which we use when creating
+ * a query is not yet defined.
+ *
+ * @usageNotes
+ * ### Example
+ * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref'}
+ * @publicApi
+ */
+export declare function forwardRef(forwardRefFn: ForwardRefFn): Type<any>;
+/**
+ * Lazily retrieves the reference value from a forwardRef.
+ *
+ * Acts as the identity function when given a non-forward-ref value.
+ *
+ * @usageNotes
+ * ### Example
+ *
+ * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}
+ *
+ * @see `forwardRef`
+ * @publicApi
+ */
+export declare function resolveForwardRef<T>(type: T): T;
+/** Checks whether a function is wrapped by a `forwardRef`. */
+export declare function isForwardRef(fn: any): fn is () => any;

package/di/forward_ref.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isForwardRef = exports.resolveForwardRef = exports.forwardRef = void 0;
+const property_1 = require("../util/property");
+const stringify_1 = require("../util/stringify");
+const __forward_ref__ = (0, property_1.getClosureSafeProperty)({ __forward_ref__: property_1.getClosureSafeProperty });
+/**
+ * Allows to refer to references which are not yet defined.
+ *
+ * For instance, `forwardRef` is used when the `token` which we need to refer to for the purposes of
+ * DI is declared, but not yet defined. It is also used when the `token` which we use when creating
+ * a query is not yet defined.
+ *
+ * @usageNotes
+ * ### Example
+ * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref'}
+ * @publicApi
+ */
+function forwardRef(forwardRefFn) {
+    forwardRefFn.__forward_ref__ = forwardRef;
+    forwardRefFn.toString = function () {
+        return (0, stringify_1.stringify)(this());
+    };
+    return forwardRefFn;
+}
+exports.forwardRef = forwardRef;
+/**
+ * Lazily retrieves the reference value from a forwardRef.
+ *
+ * Acts as the identity function when given a non-forward-ref value.
+ *
+ * @usageNotes
+ * ### Example
+ *
+ * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}
+ *
+ * @see `forwardRef`
+ * @publicApi
+ */
+function resolveForwardRef(type) {
+    return isForwardRef(type) ? type() : type;
+}
+exports.resolveForwardRef = resolveForwardRef;
+/** Checks whether a function is wrapped by a `forwardRef`. */
+function isForwardRef(fn) {
+    return typeof fn === 'function' && fn.hasOwnProperty(__forward_ref__) &&
+        fn.__forward_ref__ === forwardRef;
+}
+exports.isForwardRef = isForwardRef;
+//# sourceMappingURL=forward_ref.js.map

package/di/forward_ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forward_ref.js","sourceRoot":"","sources":["../../../../libs/core/src/di/forward_ref.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAGH,+CAAwD;AACxD,iDAA4C;AAiB5C,MAAM,eAAe,GAAG,IAAA,iCAAsB,EAAC,EAAC,eAAe,EAAE,iCAAsB,EAAC,CAAC,CAAC;AAE1F;;;;;;;;;;;GAWG;AACH,SAAgB,UAAU,CAAC,YAA0B;IAC7C,YAAa,CAAC,eAAe,GAAG,UAAU,CAAC;IAC3C,YAAa,CAAC,QAAQ,GAAG;QAC7B,OAAO,IAAA,qBAAS,EAAC,IAAI,EAAE,CAAC,CAAC;IAC3B,CAAC,CAAC;IACF,OAAwB,YAAa,CAAC;AACxC,CAAC;AAND,gCAMC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,iBAAiB,CAAI,IAAO;IAC1C,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AAC5C,CAAC;AAFD,8CAEC;AAED,8DAA8D;AAC9D,SAAgB,YAAY,CAAC,EAAO;IAClC,OAAO,OAAO,EAAE,KAAK,UAAU,IAAI,EAAE,CAAC,cAAc,CAAC,eAAe,CAAC;QACjE,EAAE,CAAC,eAAe,KAAK,UAAU,CAAC;AACxC,CAAC;AAHD,oCAGC"}

package/di/index.d.ts

@@ -0,0 +1,3 @@
+export * from './create-injector';
+export * from './injectable';
+export * from './injector';

package/di/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./create-injector"), exports);
+tslib_1.__exportStar(require("./injectable"), exports);
+tslib_1.__exportStar(require("./injector"), exports);
+//# sourceMappingURL=index.js.map

package/di/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/core/src/di/index.ts"],"names":[],"mappings":";;;AAAA,4DAAkC;AAClC,uDAA6B;AAC7B,qDAA2B"}

package/di/injectable.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+export { Injectable, Inject, Optional, InjectionToken } from 'injection-js';

package/di/injectable.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectionToken = exports.Optional = exports.Inject = exports.Injectable = void 0;
+require("reflect-metadata");
+var injection_js_1 = require("injection-js");
+Object.defineProperty(exports, "Injectable", { enumerable: true, get: function () { return injection_js_1.Injectable; } });
+Object.defineProperty(exports, "Inject", { enumerable: true, get: function () { return injection_js_1.Inject; } });
+Object.defineProperty(exports, "Optional", { enumerable: true, get: function () { return injection_js_1.Optional; } });
+Object.defineProperty(exports, "InjectionToken", { enumerable: true, get: function () { return injection_js_1.InjectionToken; } });
+//# sourceMappingURL=injectable.js.map

package/di/injectable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectable.js","sourceRoot":"","sources":["../../../../libs/core/src/di/injectable.ts"],"names":[],"mappings":";;;AAAA,4BAA0B;AAC1B,6CAA4E;AAAnE,0GAAA,UAAU,OAAA;AAAE,sGAAA,MAAM,OAAA;AAAE,wGAAA,QAAQ,OAAA;AAAE,8GAAA,cAAc,OAAA"}

package/di/injector.d.ts

@@ -0,0 +1,3 @@
+import { Injector, ReflectiveInjector } from 'injection-js';
+export { Injector };
+export declare function resolveAndCreate(providers: any, parent?: Injector): ReflectiveInjector;

package/di/injector.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAndCreate = exports.Injector = void 0;
+const injection_js_1 = require("injection-js");
+Object.defineProperty(exports, "Injector", { enumerable: true, get: function () { return injection_js_1.Injector; } });
+function resolveAndCreate(providers, parent = injection_js_1.Injector.NULL) {
+    return injection_js_1.ReflectiveInjector.resolveAndCreate(providers, parent);
+}
+exports.resolveAndCreate = resolveAndCreate;
+//# sourceMappingURL=injector.js.map

package/di/injector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injector.js","sourceRoot":"","sources":["../../../../libs/core/src/di/injector.ts"],"names":[],"mappings":";;;AAAA,+CAA4D;AAEnD,yFAFA,uBAAQ,OAEA;AAEjB,SAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,uBAAQ,CAAC,IAAI;IAChE,OAAO,iCAAkB,CAAC,gBAAgB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;AAChE,CAAC;AAFD,4CAEC"}

package/di/interface/defs.d.ts

@@ -0,0 +1,181 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Type } from './type';
+import { ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, ValueProvider } from './provider';
+/**
+ * Information about how a type or `InjectionToken` interfaces with the DI system.
+ *
+ * At a minimum, this includes a `factory` which defines how to create the given type `T`, possibly
+ * requesting injection of other types if necessary.
+ *
+ * Optionally, a `providedIn` parameter specifies that the given type belongs to a particular
+ * `Injector`, `NgModule`, or a special scope (e.g. `'root'`). A value of `null` indicates
+ * that the injectable does not belong to any scope.
+ *
+ * @codeGenApi
+ * @publicApi The ViewEngine compiler emits code with this type for injectables. This code is
+ *   deployed to npm, and should be treated as public api.
+
+ */
+export interface ɵɵInjectableDeclaration<T> {
+    /**
+     * Specifies that the given type belongs to a particular injector:
+     * - `InjectorType` such as `NgModule`,
+     * - `'root'` the root injector
+     * - `'any'` all injectors.
+     * - `null`, does not belong to any injector. Must be explicitly listed in the injector
+     *   `providers`.
+     */
+    providedIn: InjectorType<any> | 'root' | 'platform' | 'any' | 'environment' | null;
+    /**
+     * The token to which this definition belongs.
+     *
+     * Note that this may not be the same as the type that the `factory` will create.
+     */
+    token: unknown;
+    /**
+     * Factory method to execute to create an instance of the injectable.
+     */
+    factory: (t?: Type<any>) => T;
+    /**
+     * In a case of no explicit injector, a location where the instance of the injectable is stored.
+     */
+    value: T | undefined;
+}
+/**
+ * Information about the providers to be included in an `Injector` as well as how the given type
+ * which carries the information should be created by the DI system.
+ *
+ * An `InjectorDef` can import other types which have `InjectorDefs`, forming a deep nested
+ * structure of providers with a defined priority (identically to how `NgModule`s also have
+ * an import/dependency structure).
+ *
+ * NOTE: This is a private type and should not be exported
+ *
+ * @codeGenApi
+ */
+export interface ɵɵInjectorDef<T> {
+    providers: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | any[])[];
+    imports: (InjectorType<any> | InjectorTypeWithProviders<any>)[];
+}
+/**
+ * A `Type` which has a `ɵprov: ɵɵInjectableDeclaration` static field.
+ *
+ * `InjectableType`s contain their own Dependency Injection metadata and are usable in an
+ * `InjectorDef`-based `StaticInjector`.
+ *
+ * @publicApi
+ */
+export interface InjectableType<T> extends Type<T> {
+    /**
+     * Opaque type whose structure is highly version dependent. Do not rely on any properties.
+     */
+    ɵprov: unknown;
+}
+/**
+ * A type which has an `InjectorDef` static field.
+ *
+ * `InjectorTypes` can be used to configure a `StaticInjector`.
+ *
+ * This is an opaque type whose structure is highly version dependent. Do not rely on any
+ * properties.
+ *
+ * @publicApi
+ */
+export interface InjectorType<T> extends Type<T> {
+    ɵfac?: unknown;
+    ɵinj: unknown;
+}
+/**
+ * Describes the `InjectorDef` equivalent of a `ModuleWithProviders`, an `InjectorType` with an
+ * associated array of providers.
+ *
+ * Objects of this type can be listed in the imports section of an `InjectorDef`.
+ *
+ * NOTE: This is a private type and should not be exported
+ */
+export interface InjectorTypeWithProviders<T> {
+    nxModule: InjectorType<T>;
+    providers?: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | any[])[];
+}
+/**
+ * Construct an injectable definition which defines how a token will be constructed by the DI
+ * system, and in which injectors (if any) it will be available.
+ *
+ * This should be assigned to a static `ɵprov` field on a type, which will then be an
+ * `InjectableType`.
+ *
+ * Options:
+ * * `providedIn` determines which injectors will include the injectable, by either associating it
+ *   with an `@NgModule` or other `InjectorType`, or by specifying that this injectable should be
+ *   provided in the `'root'` injector, which will be the application-level injector in most apps.
+ * * `factory` gives the zero argument function which will create an instance of the injectable.
+ *   The factory can call `inject` to access the `Injector` and request injection of dependencies.
+ *
+ * @codeGenApi
+ * @publicApi This instruction has been emitted by ViewEngine for some time and is deployed to npm.
+ */
+export declare function ɵɵdefineInjectable<T>(opts: {
+    token: unknown;
+    providedIn?: Type<any> | 'root' | 'platform' | 'any' | 'environment' | null;
+    factory: () => T;
+}): unknown;
+/**
+ * @deprecated in v8, delete after v10. This API should be used only by generated code, and that
+ * code should now use ɵɵdefineInjectable instead.
+ * @publicApi
+ */
+export declare const defineInjectable: typeof ɵɵdefineInjectable;
+/**
+ * Construct an `InjectorDef` which configures an injector.
+ *
+ * This should be assigned to a static injector def (`ɵinj`) field on a type, which will then be an
+ * `InjectorType`.
+ *
+ * Options:
+ *
+ * * `providers`: an optional array of providers to add to the injector. Each provider must
+ *   either have a factory or point to a type which has a `ɵprov` static property (the
+ *   type must be an `InjectableType`).
+ * * `imports`: an optional array of imports of other `InjectorType`s or `InjectorTypeWithModule`s
+ *   whose providers will also be added to the injector. Locally provided types will override
+ *   providers from imports.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵdefineInjector(options: {
+    providers?: any[];
+    imports?: any[];
+}): unknown;
+/**
+ * Read the injectable def (`ɵprov`) for `type` in a way which is immune to accidentally reading
+ * inherited value.
+ *
+ * @param type A type which may have its own (non-inherited) `ɵprov`.
+ */
+export declare function getInjectableDef<T>(type: any): ɵɵInjectableDeclaration<T> | null;
+/**
+ * Read the injectable def (`ɵprov`) for `type` or read the `ɵprov` from one of its ancestors.
+ *
+ * @param type A type which may have `ɵprov`, via inheritance.
+ *
+ * @deprecated Will be removed in a future version of Angular, where an error will occur in the
+ *     scenario if we find the `ɵprov` on an ancestor only.
+ */
+export declare function getInheritedInjectableDef<T>(type: any): ɵɵInjectableDeclaration<T> | null;
+export declare function hasInjectaorDef(type: any): boolean;
+/**
+ * Read the injector def type in a way which is immune to accidentally reading inherited value.
+ *
+ * @param type type which may have an injector def (`ɵinj`)
+ */
+export declare function getInjectorDef<T>(type: any): ɵɵInjectorDef<T> | null;
+export declare const NG_PROV_DEF: string;
+export declare const NG_INJ_DEF: string;
+export declare const NG_INJECTABLE_DEF: string;
+export declare const NG_INJECTOR_DEF: string;