static-injector 6.3.1 → 7.0.0

package/import/resource/resource.d.ts

@@ -5,10 +5,11 @@
  * 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 { WritableSignal } from '../render3/reactivity/signal';
 import { Signal, ValueEqualityFn } from '../render3/reactivity/api';
-import { ResourceOptions, ResourceStatus, WritableResource, Resource, ResourceRef, ResourceStreamingLoader } from './api';
+import { WritableSignal } from '../render3/reactivity/signal';
+import { Resource, ResourceOptions, ResourceSnapshot, ResourceStatus, ResourceStreamingLoader, ResourceStreamItem, type ResourceParamsContext, type ResourceRef, type WritableResource } from './api';
 import { Injector } from '../di/injector';
+import { StateKey } from '../transfer_state';
 /**
  * Constructs a `Resource` that projects a reactive request to an asynchronous operation defined by
  * a loader function, which exposes the result of the loading operation via signals.
@@ -19,7 +20,7 @@ import { Injector } from '../di/injector';
  *
  * @see [Async reactivity with resources](guide/signals/resource)
  *
- * @experimental 19.0
+ * @publicApi 22.0
  */
 export declare function resource<T, R>(options: ResourceOptions<T, R> & {
     defaultValue: NoInfer<T>;
@@ -32,13 +33,16 @@ export declare function resource<T, R>(options: ResourceOptions<T, R> & {
  * `resource` will cancel in-progress loads via the `AbortSignal` when destroyed or when a new
  * request object becomes available, which could prematurely abort mutations.
  *
- * @experimental 19.0
+ * @publicApi 22.0
  * @see [Async reactivity with resources](guide/signals/resource)
  */
 export declare function resource<T, R>(options: ResourceOptions<T, R>): ResourceRef<T | undefined>;
+type ResourceInternalStatus = 'idle' | 'loading' | 'resolved' | 'local';
 type WrappedRequest = {
-    request: unknown;
+    request?: unknown;
     reload: number;
+    status?: ResourceInternalStatus;
+    error?: Error;
 };
 /**
  * Base class which implements `.value` as a `WritableSignal` by delegating `.set` and `.update`.
@@ -48,12 +52,14 @@ declare abstract class BaseWritableResource<T> implements WritableResource<T> {
     abstract readonly status: Signal<ResourceStatus>;
     abstract readonly error: Signal<Error | undefined>;
     abstract reload(): boolean;
-    constructor(value: Signal<T>);
+    readonly isLoading: Signal<boolean>;
+    constructor(value: Signal<T>, debugName: string | undefined);
     abstract set(value: T): void;
     private readonly isError;
     update(updateFn: (value: T) => T): void;
-    readonly isLoading: Signal<boolean>;
     private readonly isValueDefined;
+    private _snapshot;
+    get snapshot(): Signal<ResourceSnapshot<T>>;
     hasValue(): this is ResourceRef<Exclude<T, undefined>>;
     asReadonly(): Resource<T>;
 }
@@ -63,6 +69,8 @@ declare abstract class BaseWritableResource<T> implements WritableResource<T> {
 export declare class ResourceImpl<T, R> extends BaseWritableResource<T> implements ResourceRef<T> {
     private readonly loaderFn;
     private readonly equal;
+    private readonly debugName;
+    private transferCacheKey;
     private readonly pendingTasks;
     /**
      * The current state of the resource. Status, value, and error are derived from this.
@@ -78,9 +86,10 @@ export declare class ResourceImpl<T, R> extends BaseWritableResource<T> implemen
     private resolvePendingTask;
     private destroyed;
     private unregisterOnDestroy;
-    constructor(request: () => R, loaderFn: ResourceStreamingLoader<T, R>, defaultValue: T, equal: ValueEqualityFn<T> | undefined, injector: Injector);
     readonly status: Signal<ResourceStatus>;
     readonly error: Signal<Error | undefined>;
+    private readonly transferState;
+    constructor(request: (ctx: ResourceParamsContext) => R, loaderFn: ResourceStreamingLoader<T, R>, defaultValue: T, equal: ValueEqualityFn<T> | undefined, debugName: string | undefined, injector: Injector, transferCacheKey: StateKey<T> | undefined, getInitialStream?: (request: R) => Signal<ResourceStreamItem<T>> | undefined);
     /**
      * Called either directly via `WritableResource.set` or via `.value.set()`.
      */
@@ -91,4 +100,19 @@ export declare class ResourceImpl<T, R> extends BaseWritableResource<T> implemen
     private abortInProgressLoad;
 }
 export declare function encapsulateResourceError(error: unknown): Error;
+export declare function isErrorLike(error: unknown): error is Error;
+export declare class ResourceValueError extends Error {
+    constructor(error: Error);
+}
+/**
+ * Chains the value of another resource into the params of the current resource, returning the value
+ * of the other resource if it is available, or propagating the status to the current resource if it
+ * is not.
+ */
+export declare function chain<T>(resource: Resource<T>): T;
+export declare const paramsContext: ResourceParamsContext;
+export declare function isInParamsFunction(): boolean;
+export declare function setInParamsFunction(value: boolean): void;
+export declare function invalidResourceCreationInParams(): Error;
+export declare function rethrowFatalErrors(error: unknown): void;
 export {};

package/import/transfer_state.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @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
+ */
+/**
+ * A type-safe key to use with `TransferState`.
+ *
+ * Example:
+ *
+ * ```ts
+ * const COUNTER_KEY = makeStateKey<number>('counter');
+ * let value = 10;
+ *
+ * transferState.set(COUNTER_KEY, value);
+ * ```
+ *
+ * @publicApi
+ */
+export type StateKey<T> = string & {
+    __not_a_string: never;
+    __value_type?: T;
+};
+/**
+ * Create a `StateKey<T>` that can be used to store value of type T with `TransferState`.
+ *
+ * Example:
+ *
+ * ```ts
+ * const COUNTER_KEY = makeStateKey<number>('counter');
+ * let value = 10;
+ *
+ * transferState.set(COUNTER_KEY, value);
+ * ```
+ *
+ * @publicApi
+ */
+export declare function makeStateKey<T = void>(key: string): StateKey<T>;
+/**
+ * A key value store that is transferred from the application on the server side to the application
+ * on the client side.
+ *
+ * The `TransferState` is available as an injectable token.
+ * On the client, just inject this token using DI and use it, it will be lazily initialized.
+ * On the server it's already included if `renderApplication` function is used. Otherwise, import
+ * the `ServerTransferStateModule` module to make the `TransferState` available.
+ *
+ * The values in the store are serialized/deserialized using JSON.stringify/JSON.parse. So only
+ * boolean, number, string, null and non-class objects will be serialized and deserialized in a
+ * non-lossy manner.
+ *
+ * @publicApi
+ */
+export declare class TransferState {
+    /** @nocollapse */
+    static ɵprov: import("./di/interface/defs").ɵɵInjectableDeclaration<TransferState>;
+    private onSerializeCallbacks;
+    /**
+     * Get the value corresponding to a key. Return `defaultValue` if key is not found.
+     */
+    get<T>(key: StateKey<T>, defaultValue: T): T;
+    /**
+     * Set the value corresponding to a key.
+     */
+    set<T>(key: StateKey<T>, value: T): void;
+    /**
+     * Remove a key from the store.
+     */
+    remove<T>(key: StateKey<T>): void;
+    /**
+     * Test whether a key exists in the store.
+     */
+    hasKey<T>(key: StateKey<T>): boolean;
+    /**
+     * Indicates whether the state is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Register a callback to provide the value for a key when `toJson` is called.
+     */
+    onSerialize<T>(key: StateKey<T>, callback: () => T): void;
+    /**
+     * Serialize the current state of the store to JSON.
+     */
+    toJson(): string;
+}
+export declare function retrieveTransferredState(doc: Document, appId: string): Record<string, unknown | undefined>;

package/import/util/array_utils.d.ts

@@ -0,0 +1,132 @@
+/**
+ * @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
+ */
+/**
+ * Determines if the contents of two arrays is identical
+ *
+ * @param a first array
+ * @param b second array
+ * @param identityAccessor Optional function for extracting stable object identity from a value in
+ *     the array.
+ */
+export declare function arrayEquals<T>(a: T[], b: T[], identityAccessor?: (value: T) => unknown): boolean;
+/**
+ * Flattens an array.
+ */
+export declare function flatten(list: any[]): any[];
+export declare function deepForEach<T>(input: (T | any[])[], fn: (value: T) => void): void;
+export declare function addToArray(arr: any[], index: number, value: any): void;
+export declare function removeFromArray(arr: any[], index: number): any;
+export declare function newArray<T = any>(size: number): T[];
+export declare function newArray<T>(size: number, value: T): T[];
+/**
+ * Remove item from array (Same as `Array.splice()` but faster.)
+ *
+ * `Array.splice()` is not as fast because it has to allocate an array for the elements which were
+ * removed. This causes memory pressure and slows down code when most of the time we don't
+ * care about the deleted items array.
+ *
+ * https://jsperf.com/fast-array-splice (About 20x faster)
+ *
+ * @param array Array to splice
+ * @param index Index of element in array to remove.
+ * @param count Number of items to remove.
+ */
+export declare function arraySplice(array: any[], index: number, count: number): void;
+/**
+ * Same as `Array.splice(index, 0, value)` but faster.
+ *
+ * `Array.splice()` is not fast because it has to allocate an array for the elements which were
+ * removed. This causes memory pressure and slows down code when most of the time we don't
+ * care about the deleted items array.
+ *
+ * @param array Array to splice.
+ * @param index Index in array where the `value` should be added.
+ * @param value Value to add to array.
+ */
+export declare function arrayInsert(array: any[], index: number, value: any): void;
+/**
+ * Same as `Array.splice2(index, 0, value1, value2)` but faster.
+ *
+ * `Array.splice()` is not fast because it has to allocate an array for the elements which were
+ * removed. This causes memory pressure and slows down code when most of the time we don't
+ * care about the deleted items array.
+ *
+ * @param array Array to splice.
+ * @param index Index in array where the `value` should be added.
+ * @param value1 Value to add to array.
+ * @param value2 Value to add to array.
+ */
+export declare function arrayInsert2(array: any[], index: number, value1: any, value2: any): void;
+/**
+ * Get an index of an `value` in a sorted `array`.
+ *
+ * NOTE:
+ * - This uses binary search algorithm for fast removals.
+ *
+ * @param array A sorted array to binary search.
+ * @param value The value to look for.
+ * @returns index of the value.
+ *   - positive index if value found.
+ *   - negative index if value not found. (`~index` to get the value where it should have been
+ *     located)
+ */
+export declare function arrayIndexOfSorted(array: string[], value: string): number;
+/**
+ * `KeyValueArray` is an array where even positions contain keys and odd positions contain values.
+ *
+ * `KeyValueArray` provides a very efficient way of iterating over its contents. For small
+ * sets (~10) the cost of binary searching an `KeyValueArray` has about the same performance
+ * characteristics that of a `Map` with significantly better memory footprint.
+ *
+ * If used as a `Map` the keys are stored in alphabetical order so that they can be binary searched
+ * for retrieval.
+ *
+ * See: `keyValueArraySet`, `keyValueArrayGet`, `keyValueArrayIndexOf`, `keyValueArrayDelete`.
+ */
+export interface KeyValueArray<VALUE> extends Array<VALUE | string> {
+    __brand__: 'array-map';
+}
+/**
+ * Set a `value` for a `key`.
+ *
+ * @param keyValueArray to modify.
+ * @param key The key to locate or create.
+ * @param value The value to set for a `key`.
+ * @returns index (always even) of where the value vas set.
+ */
+export declare function keyValueArraySet<V>(keyValueArray: KeyValueArray<V>, key: string, value: V): number;
+/**
+ * Retrieve a `value` for a `key` (on `undefined` if not found.)
+ *
+ * @param keyValueArray to search.
+ * @param key The key to locate.
+ * @return The `value` stored at the `key` location or `undefined if not found.
+ */
+export declare function keyValueArrayGet<V>(keyValueArray: KeyValueArray<V>, key: string): V | undefined;
+/**
+ * Retrieve a `key` index value in the array or `-1` if not found.
+ *
+ * @param keyValueArray to search.
+ * @param key The key to locate.
+ * @returns index of where the key is (or should have been.)
+ *   - positive (even) index if key found.
+ *   - negative index if key not found. (`~index` (even) to get the index where it should have
+ *     been inserted.)
+ */
+export declare function keyValueArrayIndexOf<V>(keyValueArray: KeyValueArray<V>, key: string): number;
+/**
+ * Delete a `key` (and `value`) from the `KeyValueArray`.
+ *
+ * @param keyValueArray to modify.
+ * @param key The key to locate or delete (if exist).
+ * @returns index of where the key was (or should have been.)
+ *   - positive (even) index if key found and deleted.
+ *   - negative index if key not found. (`~index` (even) to get the index where it should have
+ *     been.)
+ */
+export declare function keyValueArrayDelete<V>(keyValueArray: KeyValueArray<V>, key: string): number;

package/import/util/assert.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @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 declare function assertNumber(actual: any, msg: string): asserts actual is number;
+export declare function assertNumberInRange(actual: any, minInclusive: number, maxInclusive: number): asserts actual is number;
+export declare function assertString(actual: any, msg: string): asserts actual is string;
+export declare function assertFunction(actual: any, msg: string): asserts actual is Function;
+export declare function assertEqual<T>(actual: T, expected: T, msg: string): void;
+export declare function assertNotEqual<T>(actual: T, expected: T, msg: string): asserts actual is T;
+export declare function assertSame<T>(actual: T, expected: T, msg: string): asserts actual is T;
+export declare function assertNotSame<T>(actual: T, expected: T, msg: string): void;
+export declare function assertLessThan<T>(actual: T, expected: T, msg: string): asserts actual is T;
+export declare function assertLessThanOrEqual<T>(actual: T, expected: T, msg: string): asserts actual is T;
+export declare function assertGreaterThan<T>(actual: T, expected: T, msg: string): asserts actual is T;
+export declare function assertGreaterThanOrEqual<T>(actual: T, expected: T, msg: string): asserts actual is T;
+export declare function assertNotDefined<T>(actual: T, msg: string): void;
+export declare function assertDefined<T>(actual: T | null | undefined, msg: string): asserts actual is T;
+export declare function throwError(msg: string): never;
+export declare function throwError(msg: string, actual: any, expected: any, comparison: string): never;
+export declare function assertDomNode(node: any): asserts node is Node;
+export declare function assertElement(node: any): asserts node is Element;
+export declare function assertIndexInRange(arr: any[], index: number): void;
+export declare function assertOneOf(value: any, ...validValues: any[]): boolean;
+export declare function assertNotReactive(fn: string): void;

package/import/util/default_export.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.dev/license
+ */
+/**
+ * An ES Module object with a default export of the given type.
+ *
+ * @see {@link injectAsync}
+ * @see [Route#loadComponent](/api/router/Route#loadComponent)
+ * @see [LoadChildrenCallback](/api/router/LoadChildrenCallback)
+ *
+ * @publicApi
+ */
+export interface DefaultExport<T> {
+    /**
+     * Default exports are bound under the name `"default"`, per the ES Module spec:
+     * https://tc39.es/ecma262/#table-export-forms-mapping-to-exportentry-records
+     */
+    default: T;
+}
+export declare function maybeUnwrapDefaultExport<T>(input: T | DefaultExport<T>): T;

package/import/util/promise_with_resolvers.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @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
+ */
+/**
+ * TODO(incremental-hydration): Remove this file entirely once PromiseWithResolvers lands in stable
+ * node / TS.
+ */
+export interface PromiseWithResolvers<T> {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+}
+export interface PromiseConstructor {
+    /**
+     * Creates a new Promise and returns it in an object, along with its resolve and reject functions.
+     * @returns An object with the properties `promise`, `resolve`, and `reject`.
+     *
+     * ```ts
+     * const { promise, resolve, reject } = Promise.withResolvers<T>();
+     * ```
+     */
+    withResolvers<T>(): PromiseWithResolvers<T>;
+}
+/**
+ * Replace with `Promise.withResolvers()` once it's available.
+ * NET September 2026
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers.
+ */
+export declare function promiseWithResolvers<T>(): {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};

package/import/zone/ng_zone.d.ts

@@ -0,0 +1,261 @@
+/**
+ * @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 { EventEmitter } from '../event_emitter';
+export declare const angularZoneInstanceIdProperty: string;
+/**
+ * An injectable service for executing work inside or outside of the Angular zone.
+ *
+ * The most common use of this service is to optimize performance when starting a work consisting of
+ * one or more asynchronous tasks that don't require UI updates or error handling to be handled by
+ * Angular. Such tasks can be kicked off via {@link #runOutsideAngular} and if needed, these tasks
+ * can reenter the Angular zone via {@link #run}.
+ *
+ * <!-- TODO: add/fix links to:
+ *   - docs explaining zones and the use of zones in Angular and change-detection
+ *   - link to runOutsideAngular/run (throughout this file!)
+ *   -->
+ *
+ * @usageNotes
+ * ### Example
+ *
+ * ```ts
+ * import {Component, NgZone} from '@angular/core';
+ *
+ * @Component({
+ *   selector: 'ng-zone-demo',
+ *   template: `
+ *     <h2>Demo: NgZone</h2>
+ *
+ *     <p>Progress: {{progress}}%</p>
+ *     @if(progress >= 100) {
+ *        <p>Done processing {{label}} of Angular zone!</p>
+ *     }
+ *
+ *     <button (click)="processWithinAngularZone()">Process within Angular zone</button>
+ *     <button (click)="processOutsideOfAngularZone()">Process outside of Angular zone</button>
+ *   `,
+ * })
+ * export class NgZoneDemo {
+ *   progress: number = 0;
+ *   label: string;
+ *
+ *   constructor(private _ngZone: NgZone) {}
+ *
+ *   // Loop inside the Angular zone
+ *   // so the UI DOES refresh after each setTimeout cycle
+ *   processWithinAngularZone() {
+ *     this.label = 'inside';
+ *     this.progress = 0;
+ *     this._increaseProgress(() => console.log('Inside Done!'));
+ *   }
+ *
+ *   // Loop outside of the Angular zone
+ *   // so the UI DOES NOT refresh after each setTimeout cycle
+ *   processOutsideOfAngularZone() {
+ *     this.label = 'outside';
+ *     this.progress = 0;
+ *     this._ngZone.runOutsideAngular(() => {
+ *       this._increaseProgress(() => {
+ *         // reenter the Angular zone and display done
+ *         this._ngZone.run(() => { console.log('Outside Done!'); });
+ *       });
+ *     });
+ *   }
+ *
+ *   _increaseProgress(doneCallback: () => void) {
+ *     this.progress += 1;
+ *     console.log(`Current progress: ${this.progress}%`);
+ *
+ *     if (this.progress < 100) {
+ *       window.setTimeout(() => this._increaseProgress(doneCallback), 10);
+ *     } else {
+ *       doneCallback();
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @see [Resolving zone pollution](best-practices/zone-pollution#run-tasks-outside-ngzone)
+ *
+ * @publicApi
+ */
+export declare class NgZone {
+    readonly hasPendingMacrotasks: boolean;
+    readonly hasPendingMicrotasks: boolean;
+    /**
+     * Whether there are no outstanding microtasks or macrotasks.
+     */
+    readonly isStable: boolean;
+    /**
+     * Notifies when code enters Angular Zone. This gets fired first on VM Turn.
+     */
+    readonly onUnstable: EventEmitter<any>;
+    /**
+     * Notifies when there is no more microtasks enqueued in the current VM Turn.
+     * This is a hint for Angular to do change detection, which may enqueue more microtasks.
+     * For this reason this event can fire multiple times per VM Turn.
+     */
+    readonly onMicrotaskEmpty: EventEmitter<any>;
+    /**
+     * Notifies when the last `onMicrotaskEmpty` has run and there are no more microtasks, which
+     * implies we are about to relinquish VM turn.
+     * This event gets called just once.
+     */
+    readonly onStable: EventEmitter<any>;
+    /**
+     * Notifies that an error has been delivered.
+     */
+    readonly onError: EventEmitter<any>;
+    constructor(options: {
+        enableLongStackTrace?: boolean;
+        shouldCoalesceEventChangeDetection?: boolean;
+        shouldCoalesceRunChangeDetection?: boolean;
+    });
+    /**
+      This method checks whether the method call happens within an Angular Zone instance.
+    */
+    /**
+      Assures that the method is called within the Angular Zone, otherwise throws an error.
+    */
+    /**
+      Assures that the method is called outside of the Angular Zone, otherwise throws an error.
+    */
+    /**
+     * Executes the `fn` function synchronously within the Angular zone and returns value returned by
+     * the function.
+     *
+     * Running functions via `run` allows you to reenter Angular zone from a task that was executed
+     * outside of the Angular zone (typically started via {@link #runOutsideAngular}).
+     *
+     * Any future tasks or microtasks scheduled from within this function will continue executing from
+     * within the Angular zone.
+     *
+     * If a synchronous error happens it will be rethrown and not reported via `onError`.
+     */
+    run<T>(fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[]): T;
+    /**
+     * Executes the `fn` function synchronously within the Angular zone as a task and returns value
+     * returned by the function.
+     *
+     * Running functions via `runTask` allows you to reenter Angular zone from a task that was executed
+     * outside of the Angular zone (typically started via {@link #runOutsideAngular}).
+     *
+     * Any future tasks or microtasks scheduled from within this function will continue executing from
+     * within the Angular zone.
+     *
+     * If a synchronous error happens it will be rethrown and not reported via `onError`.
+     */
+    runTask<T>(fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[], name?: string): T;
+    /**
+     * Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not
+     * rethrown.
+     */
+    runGuarded<T>(fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[]): T;
+    /**
+     * Executes the `fn` function synchronously in Angular's parent zone and returns value returned by
+     * the function.
+     *
+     * Running functions via {@link #runOutsideAngular} allows you to escape Angular's zone and do
+     * work that
+     * doesn't trigger Angular change-detection or is subject to Angular's error handling.
+     *
+     * Any future tasks or microtasks scheduled from within this function will continue executing from
+     * outside of the Angular zone.
+     *
+     * Use {@link #run} to reenter the Angular zone and do work that updates the application model.
+     */
+    runOutsideAngular<T>(fn: (...args: any[]) => T): T; /** @nocollapse */
+    static ɵprov /**
+  @pureOrBreakMyCode */: import("../di/interface/defs").ɵɵInjectableDeclaration<NoopNgZone>;
+}
+export interface NgZonePrivate extends NgZone {
+    _outer: Zone;
+    _inner: Zone;
+    _nesting: number;
+    _hasPendingMicrotasks: boolean;
+    hasPendingMacrotasks: boolean;
+    hasPendingMicrotasks: boolean;
+    callbackScheduled: boolean;
+    /**
+     * A flag to indicate if NgZone is currently inside
+     * checkStable and to prevent re-entry. The flag is
+     * needed because it is possible to invoke the change
+     * detection from within change detection leading to
+     * incorrect behavior.
+     *
+     * For detail, please refer here,
+     * https://github.com/angular/angular/pull/40540
+     */
+    isCheckStableRunning: boolean;
+    isStable: boolean;
+    /**
+     * Optionally specify coalescing event change detections or not.
+     * Consider the following case.
+     *
+     * <div (click)="doSomething()">
+     *   <button (click)="doSomethingElse()"></button>
+     * </div>
+     *
+     * When button is clicked, because of the event bubbling, both
+     * event handlers will be called and 2 change detections will be
+     * triggered. We can coalesce such kind of events to trigger
+     * change detection only once.
+     *
+     * By default, this option will be false. So the events will not be
+     * coalesced and the change detection will be triggered multiple times.
+     * And if this option be set to true, the change detection will be
+     * triggered async by scheduling it in an animation frame. So in the case above,
+     * the change detection will only be trigged once.
+     */
+    shouldCoalesceEventChangeDetection: boolean;
+    /**
+     * Optionally specify if `NgZone#run()` method invocations should be coalesced
+     * into a single change detection.
+     *
+     * Consider the following case.
+     *
+     * for (let i = 0; i < 10; i ++) {
+     *   ngZone.run(() => {
+     *     // do something
+     *   });
+     * }
+     *
+     * This case triggers the change detection multiple times.
+     * With ngZoneRunCoalescing options, all change detections in an event loops trigger only once.
+     * In addition, the change detection executes in requestAnimation.
+     *
+     */
+    shouldCoalesceRunChangeDetection: boolean;
+    /**
+     * Whether to schedule the coalesced change detection in the root zone
+     */
+    scheduleInRootZone: boolean;
+}
+/**
+ * Provides a noop implementation of `NgZone` which does nothing. This zone requires explicit calls
+ * to framework to perform rendering.
+ */
+export declare class NoopNgZone implements NgZone {
+    readonly hasPendingMicrotasks = false;
+    readonly hasPendingMacrotasks = false;
+    readonly isStable = true;
+    readonly onUnstable: EventEmitter<any>;
+    readonly onMicrotaskEmpty: EventEmitter<any>;
+    readonly onStable: EventEmitter<any>;
+    readonly onError: EventEmitter<any>;
+    run<T>(fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any): T;
+    runGuarded<T>(fn: (...args: any[]) => any, applyThis?: any, applyArgs?: any): T;
+    runOutsideAngular<T>(fn: (...args: any[]) => T): T;
+    runTask<T>(fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any, name?: string): T;
+}
+export interface InternalNgZoneOptions {
+    enableLongStackTrace?: boolean;
+    shouldCoalesceEventChangeDetection?: boolean;
+    shouldCoalesceRunChangeDetection?: boolean;
+    scheduleInRootZone?: boolean;
+}