static-injector 5.0.2 → 6.0.1

package/import/change_detection/scheduling/zoneless_scheduling.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @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.dev/license
+ */
+import { InjectionToken } from '../../di/injection_token';
+export declare const enum NotificationSource {
+    MarkAncestorsForTraversal = 0,
+    SetInput = 1,
+    DeferBlockStateUpdate = 2,
+    DebugApplyChanges = 3,
+    MarkForCheck = 4,
+    Listener = 5,
+    CustomElement = 6,
+    RenderHook = 7,
+    ViewAttached = 8,
+    ViewDetachedFromDOM = 9,
+    AsyncAnimationsLoaded = 10,
+    PendingTaskRemoved = 11,
+    RootEffect = 12,
+    ViewEffect = 13
+}
+/**
+ * Injectable that is notified when an `LView` is made aware of changes to application state.
+ */
+export declare abstract class ChangeDetectionScheduler {
+    abstract notify(source: NotificationSource): void;
+    abstract runningTick: boolean;
+}
+/** Token used to indicate if zoneless was enabled via provideZonelessChangeDetection(). */
+export declare const ZONELESS_ENABLED: InjectionToken<boolean>;
+/** Token used to indicate `provideExperimentalZonelessChangeDetection` was used. */
+export declare const PROVIDED_ZONELESS: InjectionToken<boolean>;
+export declare const ZONELESS_SCHEDULER_DISABLED: InjectionToken<boolean>;
+export declare const SCHEDULE_IN_ROOT_ZONE: InjectionToken<boolean>;

package/import/change_detection/scheduling/zoneless_scheduling_impl.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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.dev/license
+ */
+import { ChangeDetectionScheduler, NotificationSource } from './zoneless_scheduling';
+export declare class ChangeDetectionSchedulerImpl implements ChangeDetectionScheduler {
+    #private;
+    runningTick: boolean;
+    private cancelScheduledCallback;
+    notify(source: NotificationSource): void;
+    private cleanup;
+    ngOnDestroy(): void;
+}

package/import/core_reactivity_export_internal.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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.dev/license
+ */
+export { SIGNAL as ɵSIGNAL } from '@angular/core/primitives/signals';
+export { isSignal, Signal, ValueEqualityFn } from './render3/reactivity/api';
+export { computed, CreateComputedOptions } from './render3/reactivity/computed';
+export { CreateSignalOptions, signal, WritableSignal, ɵunwrapWritableSignal, } from './render3/reactivity/signal';
+export { linkedSignal } from './render3/reactivity/linked_signal';
+export { untracked } from './render3/reactivity/untracked';
+export { CreateEffectOptions, effect, EffectRef, EffectCleanupFn, EffectCleanupRegisterFn, } from './render3/reactivity/effect';
+export { MicrotaskEffectScheduler as ɵMicrotaskEffectScheduler, microtaskEffect as ɵmicrotaskEffect, } from './render3/reactivity/microtask_effect';
+export { EffectScheduler as ɵEffectScheduler } from './render3/reactivity/root_effect_scheduler';
+export { assertNotInReactiveContext } from './render3/reactivity/asserts';

package/import/di/contextual.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @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.dev/license
+ */
+import type { Injector } from './injector';
+/**
+ * Runs the given function in the [context](guide/di/dependency-injection-context) of the given
+ * `Injector`.
+ *
+ * Within the function's stack frame, [`inject`](api/core/inject) can be used to inject dependencies
+ * from the given `Injector`. Note that `inject` is only usable synchronously, and cannot be used in
+ * any asynchronous callbacks or after any `await` points.
+ *
+ * @param injector the injector which will satisfy calls to [`inject`](api/core/inject) while `fn`
+ *     is executing
+ * @param fn the closure to be run in the context of `injector`
+ * @returns the return value of the function, if any
+ * @publicApi
+ */
+export declare function runInInjectionContext<ReturnT>(injector: Injector, fn: () => ReturnT): ReturnT;
+/**
+ * Whether the current stack frame is inside an injection context.
+ */
+export declare function isInInjectionContext(): boolean;
+/**
+ * Asserts that the current stack frame is within an [injection
+ * context](guide/di/dependency-injection-context) and has access to `inject`.
+ *
+ * @param debugFn a reference to the function making the assertion (used for the error message).
+ *
+ * @publicApi
+ */
+export declare function assertInInjectionContext(debugFn: Function): void;

package/{typings → import}/di/create_injector.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import type { Injector } from './injector';
 import type { Provider, StaticProvider } from './interface/provider';

package/{typings → import}/di/forward_ref.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { Type } from '../interface/type';
 /**
@@ -32,7 +32,7 @@ export interface ForwardRefFn {
  * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref'}
  *
  * ### Circular standalone reference import example
- * ```ts
+ * ```angular-ts
  * @Component({
  *   standalone: true,
  *   imports: [ChildComponent],

package/import/di/index.d.ts

@@ -0,0 +1,3 @@
+export { ProviderToken } from './provider_token';
+export { assertInInjectionContext, runInInjectionContext } from './contextual';
+export { EnvironmentInjector } from './r3_injector';

package/{typings → import}/di/initializer_token.d.ts

@@ -3,13 +3,20 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { InjectionToken } from './injection_token';
 /**
  * A multi-provider token for initialization functions that will run upon construction of an
  * environment injector.
  *
+ * @deprecated from v19.0.0, use provideEnvironmentInitializer instead
+ *
+ * @see {@link provideEnvironmentInitializer}
+ *
+ * Note: As opposed to the `APP_INITIALIZER` token, the `ENVIRONMENT_INITIALIZER` functions are not awaited,
+ * hence they should not be `async`.
+ *
  * @publicApi
  */
 export declare const ENVIRONMENT_INITIALIZER: InjectionToken<readonly (() => void)[]>;

package/{typings → import}/di/inject_switch.d.ts

@@ -3,11 +3,11 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { InjectFlags } from './interface/injector';
 import { ProviderToken } from './provider_token';
-export declare function getInjectImplementation(): (<T>(token: ProviderToken<T>, flags?: InjectFlags | undefined) => T | null) | undefined;
+export declare function getInjectImplementation(): (<T>(token: ProviderToken<T>, flags?: InjectFlags) => T | null) | undefined;
 /**
  * Sets the current inject implementation.
  */

package/{typings → import}/di/injectable.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { Type } from '../interface/type';
 import { TypeDecorator } from '../util/decorators';
@@ -36,7 +36,7 @@ export interface InjectableDecorator {
      * The following example shows how a service class is properly
      *  marked so that a supporting service can be injected upon creation.
      *
-     * <code-example path="core/di/ts/metadata_spec.ts" region="Injectable"></code-example>
+     * {@example core/di/ts/metadata_spec.ts region='Injectable'}
      *
      */
     (): TypeDecorator;

package/{typings → import}/di/injection_token.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { Type } from '../interface/type';
 /**
@@ -16,7 +16,7 @@ import { Type } from '../interface/type';
  * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by
  * the `Injector`. This provides an additional level of type safety.
  *
- * <div class="alert is-helpful">
+ * <div class="docs-alert docs-alert-helpful">
  *
  * **Important Note**: Ensure that you use the same instance of the `InjectionToken` in both the
  * provider and the injection call. Creating a new instance of `InjectionToken` in different places,
@@ -25,8 +25,7 @@ import { Type } from '../interface/type';
  *
  * </div>
  *
- * <code-example format="typescript" language="typescript" path="injection-token/src/main.ts"
- * region="InjectionToken"></code-example>
+ * {@example injection-token/src/main.ts region='InjectionToken'}
  *
  * When creating an `InjectionToken`, you can optionally specify a factory function which returns
  * (possibly by creating) a default value of the parameterized type `T`. This sets up the

package/{typings → import}/di/injector.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { InjectorMarkers } from './injector_marker';
 import { InjectFlags, InjectOptions } from './interface/injector';

package/{typings → import}/di/injector_compatibility.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import type { Injector } from './injector';
 import { DecoratorFlags, InjectFlags, InjectOptions, InternalInjectFlags } from './interface/injector';

package/{typings → import}/di/injector_marker.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 /**
  * Special markers which can be left on `Type.__NG_ELEMENT_ID__` which are used by the Ivy's

package/{typings → import}/di/injector_token.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { InjectionToken } from './injection_token';
 import type { Injector } from './injector';

package/{typings → import}/di/interface/defs.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { Type } from '../../interface/type';
 import { ClassProvider, ConstructorProvider, EnvironmentProviders, ExistingProvider, FactoryProvider, StaticClassProvider, ValueProvider } from './provider';

package/{typings → import}/di/interface/injector.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 /**
  * Special flag indicating that a decorator is of type `Inject`. It's used to make `Inject`

package/{typings → import}/di/interface/provider.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { Type } from '../../interface/type';
 /**

package/{typings → import}/di/internal_tokens.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { Type } from '../interface/type';
 import { InjectionToken } from './injection_token';

package/{typings → import}/di/metadata.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 /**
  * Type of the Inject decorator / constructor function.
@@ -22,8 +22,7 @@ export interface InjectDecorator {
      * When `@Inject()` is not present, the injector uses the type annotation of the
      * parameter as the provider.
      *
-     * <code-example path="core/di/ts/metadata_spec.ts" region="InjectWithoutDecorator">
-     * </code-example>
+     * {@example core/di/ts/metadata_spec.ts region='InjectWithoutDecorator'}
      *
      * @see [Dependency Injection Guide](guide/di/dependency-injection
      *
@@ -67,8 +66,7 @@ export interface OptionalDecorator {
      *
      * The following code allows the possibility of a `null` result:
      *
-     * <code-example path="core/di/ts/metadata_spec.ts" region="Optional">
-     * </code-example>
+     * {@example core/di/ts/metadata_spec.ts region='Optional'}
      *
      * @see [Dependency Injection Guide](guide/di/dependency-injection.
      */
@@ -108,8 +106,7 @@ export interface SelfDecorator {
      * by the local injector when instantiating the class itself, but not
      * when instantiating a child.
      *
-     * <code-example path="core/di/ts/metadata_spec.ts" region="Self">
-     * </code-example>
+     * {@example core/di/ts/metadata_spec.ts region='Self'}
      *
      * @see {@link SkipSelf}
      * @see {@link Optional}
@@ -149,8 +146,7 @@ export interface SkipSelfDecorator {
      * In the following example, the dependency can be resolved when
      * instantiating a child, but not when instantiating the class itself.
      *
-     * <code-example path="core/di/ts/metadata_spec.ts" region="SkipSelf">
-     * </code-example>
+     * {@example core/di/ts/metadata_spec.ts region='SkipSelf'}
      *
      * @see [Dependency Injection guide](guide/di/di-in-action#skip).
      * @see {@link Self}

package/{typings → import}/di/null_injector.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import type { Injector } from './injector';
 export declare class NullInjector implements Injector {

package/{typings → import}/di/provider_collection.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { Type } from '../interface/type';
 import { ClassProvider, ConstructorProvider, EnvironmentProviders, ExistingProvider, FactoryProvider, ModuleWithProviders, Provider, StaticClassProvider, TypeProvider, ValueProvider } from './interface/provider';
@@ -12,6 +12,34 @@ import { ClassProvider, ConstructorProvider, EnvironmentProviders, ExistingProvi
  * referenced in `@Component` in a component injector.
  */
 export declare function makeEnvironmentProviders(providers: (Provider | EnvironmentProviders)[]): EnvironmentProviders;
+/**
+ * @description
+ * This function is used to provide initialization functions that will be executed upon construction
+ * of an environment injector.
+ *
+ * Note that the provided initializer is run in the injection context.
+ *
+ * Previously, this was achieved using the `ENVIRONMENT_INITIALIZER` token which is now deprecated.
+ *
+ * @see {@link ENVIRONMENT_INITIALIZER}
+ *
+ * @usageNotes
+ * The following example illustrates how to configure an initialization function using
+ * `provideEnvironmentInitializer()`
+ * ```ts
+ * createEnvironmentInjector(
+ *   [
+ *     provideEnvironmentInitializer(() => {
+ *       console.log('environment initialized');
+ *     }),
+ *   ],
+ *   parentInjector
+ * );
+ * ```
+ *
+ * @publicApi
+ */
+export declare function provideEnvironmentInitializer(initializerFn: () => void): EnvironmentProviders;
 /**
  * A source of providers for the `importProvidersFrom` function.
  *
@@ -32,7 +60,7 @@ export type ImportProvidersSource = Type<unknown> | ModuleWithProviders<unknown>
  * @usageNotes
  * The results of the `importProvidersFrom` call can be used in the `bootstrapApplication` call:
  *
- * ```typescript
+ * ```ts
  * await bootstrapApplication(RootComponent, {
  *   providers: [
  *     importProvidersFrom(NgModuleOne, NgModuleTwo)
@@ -43,7 +71,7 @@ export type ImportProvidersSource = Type<unknown> | ModuleWithProviders<unknown>
  * You can also use the `importProvidersFrom` results in the `providers` field of a route, when a
  * standalone component is used:
  *
- * ```typescript
+ * ```ts
  * export const ROUTES: Route[] = [
  *   {
  *     path: 'foo',

package/{typings → import}/di/provider_token.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { AbstractType, Type } from '../interface/type';
 import { InjectionToken } from './injection_token';

package/{typings → import}/di/r3_injector.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import type { Injector } from './injector';
 import { InjectorType } from './interface/defs';
@@ -103,7 +103,6 @@ export declare class R3Injector extends EnvironmentInjector {
     /** @internal */
     resolveInjectorInitializers(): void;
     toString(): string;
-    assertNotDestroyed(): void;
     /**
      * Process a `SingleProvider` and add it.
      */
@@ -118,3 +117,4 @@ export declare class R3Injector extends EnvironmentInjector {
  * @param provider provider to convert to factory
  */
 export declare function providerToFactory(provider: SingleProvider, ngModuleType?: InjectorType<any>, providers?: any[]): () => any;
+export declare function assertNotDestroyed(injector: R3Injector): void;

package/{typings → import}/di/scope.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { InjectionToken } from './injection_token';
 export type InjectorScope = 'root' | 'platform' | 'environment';

package/{typings → import}/di.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 /**
  * This file should not be necessary because node resolution should just default to `./di/index`!

package/import/error_handler.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @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.dev/license
+ */
+/**
+ * Provides a hook for centralized exception handling.
+ *
+ * The default implementation of `ErrorHandler` prints error messages to the `console`. To
+ * intercept error handling, write a custom exception handler that replaces this default as
+ * appropriate for your app.
+ *
+ * @usageNotes
+ * ### Example
+ *
+ * ```ts
+ * class MyErrorHandler implements ErrorHandler {
+ *   handleError(error) {
+ *     // do something with the exception
+ *   }
+ * }
+ *
+ * // Provide in standalone apps
+ * bootstrapApplication(AppComponent, {
+ *   providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]
+ * })
+ *
+ * // Provide in module-based apps
+ * @NgModule({
+ *   providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]
+ * })
+ * class MyModule {}
+ * ```
+ *
+ * @publicApi
+ */
+export declare class ErrorHandler {
+    /**
+     * @internal
+     */
+    _console: Console;
+    handleError(error: any): void;
+}

package/{typings → import}/errors.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 /**
  * The list of error codes used in runtime code of the `core` package.
@@ -13,7 +13,7 @@
  * angular.io. This extra annotation is needed to avoid introducing a separate set to store
  * error codes which have guides, which might leak into runtime code.
  *
- * Full list of available error guides can be found at https://angular.io/errors.
+ * Full list of available error guides can be found at https://angular.dev/errors.
  *
  * Error code ranges per package:
  *  - core (this package): 100-999
@@ -51,6 +51,7 @@ export declare const enum RuntimeErrorCode {
     HOST_DIRECTIVE_UNDEFINED_BINDING = 311,
     HOST_DIRECTIVE_CONFLICTING_ALIAS = 312,
     MULTIPLE_MATCHING_PIPES = 313,
+    UNINITIALIZED_LET_ACCESS = 314,
     MULTIPLE_PLATFORMS = 400,
     PLATFORM_NOT_FOUND = 401,
     MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP = 402,
@@ -68,12 +69,13 @@ export declare const enum RuntimeErrorCode {
     MISSING_HYDRATION_ANNOTATIONS = -505,
     HYDRATION_STABLE_TIMEDOUT = -506,
     MISSING_SSR_CONTENT_INTEGRITY_MARKER = -507,
+    MISCONFIGURED_INCREMENTAL_HYDRATION = 508,
     SIGNAL_WRITE_FROM_ILLEGAL_CONTEXT = 600,
     REQUIRE_SYNC_WITHOUT_SYNC_EMIT = 601,
     ASSERTION_NOT_INSIDE_REACTIVE_CONTEXT = -602,
     INVALID_I18N_STRUCTURE = 700,
     MISSING_LOCALE_DATA = 701,
-    DEFER_LOADING_FAILED = 750,
+    DEFER_LOADING_FAILED = -750,
     IMPORT_PROVIDERS_FROM_STANDALONE = 800,
     INVALID_DIFFER_INPUT = 900,
     NO_SUPPORTING_DIFFER_FACTORY = 901,
@@ -92,19 +94,19 @@ export declare const enum RuntimeErrorCode {
     UNEXPECTED_ZONEJS_PRESENT_IN_ZONELESS_MODE = 914,
     REQUIRED_INPUT_NO_VALUE = -950,
     REQUIRED_QUERY_NO_VALUE = -951,
-    REQUIRED_MODEL_NO_VALUE = -952,
+    REQUIRED_MODEL_NO_VALUE = 952,
     OUTPUT_REF_DESTROYED = 953,
     LOOP_TRACK_DUPLICATE_KEYS = -955,
     LOOP_TRACK_RECREATE = -956,
-    RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 1000,
-    RUNTIME_DEPS_ORPHAN_COMPONENT = 1001
+    RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 980,
+    RUNTIME_DEPS_ORPHAN_COMPONENT = 981
 }
 /**
  * Class that represents a runtime error.
  * Formats and outputs the error message in a consistent way.
  *
  * Example:
- * ```
+ * ```ts
  *  throw new RuntimeError(
  *    RuntimeErrorCode.INJECTOR_ALREADY_DESTROYED,
  *    ngDevMode && 'Injector has already been destroyed.');

package/import/index.d.ts

@@ -0,0 +1,37 @@
+import type { InjectableDecorator } from './di/injectable';
+import { Injector } from './di/injector';
+import { EnvironmentProviders, Provider } from './di/interface/provider';
+import { R3Injector } from './di/r3_injector';
+import { InjectorScope } from './di/scope';
+export * from './di/injectable';
+export * from './di/metadata';
+export * from './di/r3_injector';
+export * from './di/interface/defs';
+export * from './di/injector_compatibility';
+export * from './di/injection_token';
+export * from './di/null_injector';
+export * from './di/injector';
+export * from './di/interface/injector';
+export * from './di/scope';
+export * from './render3/instructions/di';
+export * from './core_reactivity_export_internal';
+export * from './change_detection/scheduling/zoneless_scheduling';
+export * from './change_detection/scheduling/zoneless_scheduling_impl';
+export * from './resource';
+export declare class StaticInjectOptions {
+    static injectOptions: Parameters<InjectableDecorator>[0];
+}
+export declare class RootStaticInjectOptions {
+    static injectOptions: Parameters<InjectableDecorator>[0];
+}
+export declare function createInjector(options: {
+    providers: Array<Provider | EnvironmentProviders>;
+    parent: Injector;
+    name?: string;
+    scopes?: Set<InjectorScope>;
+}): R3Injector;
+export declare function createRootInjector(options: {
+    providers: Array<Provider | EnvironmentProviders>;
+    name?: string;
+    scopes?: Set<InjectorScope>;
+}): R3Injector;

package/{typings → import}/interface/lifecycle_hooks.d.ts

@@ -3,7 +3,7 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 /**
  * A lifecycle hook that is called when a directive, pipe, or service is destroyed.