@angular-wave/angular.ts 0.0.38 → 0.0.39

package/types/core/scope/scope.d.ts

@@ -0,0 +1,727 @@
+/**
+ * Counts all the watchers of direct and indirect child scopes of the current scope.
+ *
+ * The watchers of the current scope are included in the count and so are all the watchers of
+ * isolate child scopes.
+ * @param {Scope} scope
+ * @returns {number} Total number of watchers.
+ */
+export function countWatchers(scope: Scope): number;
+/**
+ * Counts all the direct and indirect child scopes of the current scope.
+ *
+ * The current scope is excluded from the count. The count includes all isolate child scopes.
+ * @param {Scope} scope
+ * @returns {number} Total number of child scopes.
+ */
+export function countChildScopes(scope: Scope): number;
+export type ScopePhase = number;
+export namespace ScopePhase {
+    let NONE: number;
+    let APPLY: number;
+    let DIGEST: number;
+}
+/**
+ * The number of digest iterations
+ */
+export type TTL = number;
+/**
+ * @typedef {Object} AsyncQueueTask
+ * @property {Scope} scope
+ * @property {Function} fn
+ * @property {Object} locals
+ */
+/**
+ *
+ * The default number of `$digest` iterations the scope should attempt to execute before giving up and
+ * assuming that the model is unstable. In complex applications it's possible that the dependencies between `$watch`s will result in
+ * several digest iterations.
+ *
+ * @typedef {number} TTL The number of digest iterations
+ *
+ * @type {TTL}
+ */
+export const TTL: TTL;
+/** @type {AsyncQueueTask[]} */
+export const $$asyncQueue: AsyncQueueTask[];
+export const $$postDigestQueue: any[];
+export const $$applyAsyncQueue: any[];
+/**
+ * Provider responsible for instantiating the initial scope, aka - root scope.
+ * Every application has a single root {@link ng.$rootScope.Scope scope}.
+ * All other scopes are descendant scopes of the root scope. Scopes provide separation
+ * between the model and the view, via a mechanism for watching the model for changes.
+ * They also provide event emission/broadcast and subscription facility. See the
+ * {@link guide/scope developer guide on scopes}.
+ *
+ * The provider also injects runtime services to make them available to all scopes.
+ *
+ */
+export class $RootScopeProvider {
+    $get: (string | ((exceptionHandler: angular.IExceptionHandlerService, parse: angular.IParseService, browser: any) => Scope))[];
+}
+/**
+ * DESIGN NOTES
+ *
+ * The design decisions behind the scope are heavily favored for speed and memory consumption.
+ *
+ * The typical use of scope is to watch the expressions, which most of the time return the same
+ * value as last time so we optimize the operation.
+ *
+ * Closures construction is expensive in terms of speed as well as memory:
+ *   - No closures, instead use prototypical inheritance for API
+ *   - Internal state needs to be stored on scope directly, which means that private state is
+ *     exposed as $$____ properties
+ *
+ * Loop operations are optimized by using while(count--) { ... }
+ *   - This means that in order to keep the same order of execution as addition we have to add
+ *     items to the array at the beginning (unshift) instead of at the end (push)
+ *
+ * Child scopes are created and removed often
+ *   - Using an array would be slow since inserts in the middle are expensive; so we use linked lists
+ *
+ * There are fewer watches than observers. This is why you don't want the observer to be implemented
+ * in the same way as watch. Watch requires return of the initialization function which is expensive
+ * to construct.
+ */
+export class Scope {
+    /**
+     * @type {number} Unique scope ID (monotonically increasing) useful for debugging.
+     */
+    $id: number;
+    /** @type {ScopePhase} */
+    $$phase: ScopePhase;
+    /**
+     * @type {?Scope} Reference to the parent scope.
+     */
+    $parent: Scope | null;
+    /**
+     * @type {?Scope}
+     */
+    $root: Scope | null;
+    /**
+     * @type {[]}
+     */
+    $$watchers: [];
+    /**
+     * @type {number}
+     */
+    $$digestWatchIndex: number;
+    /**
+     * @type {?Scope}
+     */
+    $$nextSibling: Scope | null;
+    /**
+     * @type {?Scope}
+     */
+    $$prevSibling: Scope | null;
+    /**
+     * @type {?Scope}
+     */
+    $$childHead: Scope | null;
+    /**
+     * @type {?Scope}
+     */
+    $$childTail: Scope | null;
+    /** @type {boolean} */
+    $$destroyed: boolean;
+    /** @type {boolean} */
+    $$suspended: boolean;
+    /** @type {object} */
+    $$listeners: object;
+    /** @type {object} */
+    $$listenerCount: object;
+    /** @type {number} */
+    $$watchersCount: number;
+    $$isolateBindings: any;
+    /**
+     * @type {?Scope}
+     */
+    $$ChildScope: Scope | null;
+    /**
+     * Creates a new child {@link Scope}.
+     *
+     * The parent scope will propagate the {@link ng.$rootScope.Scope#$digest $digest()} event.
+     * The scope can be removed from the scope hierarchy using {@link ng.$rootScope.Scope#$destroy $destroy()}.
+     *
+     * {@link ng.$rootScope.Scope#$destroy $destroy()} must be called on a scope when it is
+     * desired for the scope and its child scopes to be permanently detached from the parent and
+     * thus stop participating in model change detection and listener notification by invoking.
+     *
+     * @param {?boolean} isolate If true, then the scope does not prototypically inherit from the
+     *         parent scope. The scope is isolated, as it can not see parent scope properties.
+     *         When creating widgets, it is useful for the widget to not accidentally read parent
+     *         state.
+     *
+     * @param {?Scope} [parent=this] The {@link ng.$rootScope.Scope `Scope`} that will be the `$parent`
+     *                              of the newly created scope. Defaults to `this` scope if not provided.
+     *                              This is used when creating a transclude scope to correctly place it
+     *                              in the scope hierarchy while maintaining the correct prototypical
+     *                              inheritance.
+     *
+     * @returns {Scope} The newly created child scope.
+     *
+     */
+    $new(isolate: boolean | null, parent?: Scope | null): Scope;
+    /**
+   * @ngdoc method
+   * @name $rootScope.Scope#$watch
+   * @kind function
+   *
+   * @description
+   * Registers a `listener` callback to be executed whenever the `watchExpression` changes.
+   *
+   * - The `watchExpression` is called on every call to {@link ng.$rootScope.Scope#$digest
+   *   $digest()} and should return the value that will be watched. (`watchExpression` should not change
+   *   its value when executed multiple times with the same input because it may be executed multiple
+   *   times by {@link ng.$rootScope.Scope#$digest $digest()}. That is, `watchExpression` should be
+   *   [idempotent](http://en.wikipedia.org/wiki/Idempotence).)
+   * - The `listener` is called only when the value from the current `watchExpression` and the
+   *   previous call to `watchExpression` are not equal (with the exception of the initial run,
+   *   see below). Inequality is determined according to reference inequality,
+   *   [strict comparison](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators)
+   *    via the `!==` Javascript operator, unless `objectEquality == true`
+   *   (see next point)
+   * - When `objectEquality == true`, inequality of the `watchExpression` is determined
+   *   according to the {@link angular.equals} function. To save the value of the object for
+   *   later comparison, the {@link structuredClone} function is used. This therefore means that
+   *   watching complex objects will have adverse memory and performance implications.
+   * - This should not be used to watch for changes in objects that are (or contain)
+   *   [File](https://developer.mozilla.org/docs/Web/API/File) objects due to limitations with {@link structuredClone `structuredClone`}.
+   * - The watch `listener` may change the model, which may trigger other `listener`s to fire.
+   *   This is achieved by rerunning the watchers until no changes are detected. The rerun
+   *   iteration limit is 10 to prevent an infinite loop deadlock.
+   *
+   *
+   * If you want to be notified whenever {@link ng.$rootScope.Scope#$digest $digest} is called,
+   * you can register a `watchExpression` function with no `listener`. (Be prepared for
+   * multiple calls to your `watchExpression` because it will execute multiple times in a
+   * single {@link ng.$rootScope.Scope#$digest $digest} cycle if a change is detected.)
+   *
+   * After a watcher is registered with the scope, the `listener` fn is called asynchronously
+   * (via {@link ng.$rootScope.Scope#$evalAsync $evalAsync}) to initialize the
+   * watcher. In rare cases, this is undesirable because the listener is called when the result
+   * of `watchExpression` didn't change. To detect this scenario within the `listener` fn, you
+   * can compare the `newVal` and `oldVal`. If these two values are identical (`===`) then the
+   * listener was called due to initialization.
+   *
+   *
+   *
+   * @example
+   * ```js
+       // let's assume that scope was dependency injected as the $rootScope
+       let scope = $rootScope;
+       scope.name = 'misko';
+       scope.counter = 0;
+  
+       expect(scope.counter).toEqual(0);
+       scope.$watch('name', function(newValue, oldValue) {
+         scope.counter = scope.counter + 1;
+       });
+       expect(scope.counter).toEqual(0);
+  
+       scope.$digest();
+       // the listener is always called during the first $digest loop after it was registered
+       expect(scope.counter).toEqual(1);
+  
+       scope.$digest();
+       // but now it will not be called unless the value changes
+       expect(scope.counter).toEqual(1);
+  
+       scope.name = 'adam';
+       scope.$digest();
+       expect(scope.counter).toEqual(2);
+  
+       // Using a function as a watchExpression
+       let food;
+       scope.foodCounter = 0;
+       expect(scope.foodCounter).toEqual(0);
+       scope.$watch(
+         // This function returns the value being watched. It is called for each turn of the $digest loop
+         function() { return food; },
+         // This is the change listener, called when the value returned from the above function changes
+         function(newValue, oldValue) {
+           if ( newValue !== oldValue ) {
+             // Only increment the counter if the value changed
+             scope.foodCounter = scope.foodCounter + 1;
+           }
+         }
+       );
+       // No digest has been run so the counter will be zero
+       expect(scope.foodCounter).toEqual(0);
+  
+       // Run the digest but since food has not changed count will still be zero
+       scope.$digest();
+       expect(scope.foodCounter).toEqual(0);
+  
+       // Update food and run digest.  Now the counter will increment
+       food = 'cheeseburger';
+       scope.$digest();
+       expect(scope.foodCounter).toEqual(1);
+  
+   * ```
+   *
+   *
+   *
+   * @param {string | ((scope: Scope) => any)} watchExp Expression that is evaluated on each
+   *    {@link ng.$rootScope.Scope#$digest $digest} cycle. A change in the return value triggers
+   *    a call to the `listener`.
+   *
+   *    - `string`: Evaluated as {@link guide/expression expression}
+   *    - `function(scope)`: called with current `scope` as a parameter.
+   * @param {(newVal: any, oldVal: any, scope: Scope) => any} listener Callback called whenever the value
+   *    of `watchExpression` changes.
+   *
+   *    - `newVal` contains the current value of the `watchExpression`
+   *    - `oldVal` contains the previous value of the `watchExpression`
+   *    - `scope` refers to the current scope
+   * @param {boolean=} [objectEquality=false] Compare for object equality using {@link angular.equals} instead of
+   *     comparing for reference equality.
+   * @returns {function()} Returns a deregistration function for this listener.
+   */
+    $watch(watchExp: string | ((scope: Scope) => any), listener: (newVal: any, oldVal: any, scope: Scope) => any, objectEquality?: boolean | undefined): () => any;
+    /**
+     * @ngdoc method
+     * @name $rootScope.Scope#$watchGroup
+     * @kind function
+     *
+     * @description
+     * A variant of {@link ng.$rootScope.Scope#$watch $watch()} where it watches an array of `watchExpressions`.
+     * If any one expression in the collection changes the `listener` is executed.
+     *
+     * - The items in the `watchExpressions` array are observed via the standard `$watch` operation. Their return
+     *   values are examined for changes on every call to `$digest`.
+     * - The `listener` is called whenever any expression in the `watchExpressions` array changes.
+     *
+     * @param {Array.<string|Function(scope)>} watchExpressions Array of expressions that will be individually
+     * watched using {@link ng.$rootScope.Scope#$watch $watch()}
+     *
+     * @param {function(newValues, oldValues, scope)} listener Callback called whenever the return value of any
+     *    expression in `watchExpressions` changes
+     *    The `newValues` array contains the current values of the `watchExpressions`, with the indexes matching
+     *    those of `watchExpression`
+     *    and the `oldValues` array contains the previous values of the `watchExpressions`, with the indexes matching
+     *    those of `watchExpression`
+     *    The `scope` refers to the current scope.
+     * @returns {function()} Returns a de-registration function for all listeners.
+     */
+    $watchGroup(watchExpressions: any, listener: (arg0: any[], arg1: any[], arg2: scope) => any): () => any;
+    /**
+     * @ngdoc method
+     * @name $rootScope.Scope#$watchCollection
+     * @kind function
+     *
+     * @description
+     * Shallow watches the properties of an object and fires whenever any of the properties change
+     * (for arrays, this implies watching the array items; for object maps, this implies watching
+     * the properties). If a change is detected, the `listener` callback is fired.
+     *
+     * - The `obj` collection is observed via standard $watch operation and is examined on every
+     *   call to $digest() to see if any items have been added, removed, or moved.
+     * - The `listener` is called whenever anything within the `obj` has changed. Examples include
+     *   adding, removing, and moving items belonging to an object or array.
+     *
+     *
+     *
+     *
+     * @param {string|function(scope)} obj Evaluated as {@link guide/expression expression}. The
+     *    expression value should evaluate to an object or an array which is observed on each
+     *    {@link ng.$rootScope.Scope#$digest $digest} cycle. Any shallow change within the
+     *    collection will trigger a call to the `listener`.
+     *
+     * @param {function(newCollection, oldCollection, scope)} listener a callback function called
+     *    when a change is detected.
+     *    - The `newCollection` object is the newly modified data obtained from the `obj` expression
+     *    - The `oldCollection` object is a copy of the former collection data.
+     *      Due to performance considerations, the`oldCollection` value is computed only if the
+     *      `listener` function declares two or more arguments.
+     *    - The `scope` argument refers to the current scope.
+     *
+     * @returns {function()} Returns a de-registration function for this listener. When the
+     *    de-registration function is executed, the internal watch operation is terminated.
+     */
+    $watchCollection(obj: string | ((arg0: scope) => any), listener: (arg0: newCollection, arg1: oldCollection, arg2: scope) => any): () => any;
+    /**
+   * @ngdoc method
+   * @name $rootScope.Scope#$digest
+   * @kind function
+   *
+   * @description
+   * Processes all of the {@link ng.$rootScope.Scope#$watch watchers} of the current scope and
+   * its children. Because a {@link ng.$rootScope.Scope#$watch watcher}'s listener can change
+   * the model, the `$digest()` keeps calling the {@link ng.$rootScope.Scope#$watch watchers}
+   * until no more listeners are firing. This means that it is possible to get into an infinite
+   * loop. This function will throw `'Maximum iteration limit exceeded.'` if the number of
+   * iterations exceeds 10.
+   *
+   * Usually, you don't call `$digest()` directly in
+   * {@link ng.directive:ngController controllers} or in
+   * {@link ng.$compileProvider#directive directives}.
+   * Instead, you should call {@link ng.$rootScope.Scope#$apply $apply()} (typically from within
+   * a {@link ng.$compileProvider#directive directive}), which will force a `$digest()`.
+   *
+   * If you want to be notified whenever `$digest()` is called,
+   * you can register a `watchExpression` function with
+   * {@link ng.$rootScope.Scope#$watch $watch()} with no `listener`.
+   *
+   * In unit tests, you may need to call `$digest()` to simulate the scope life cycle.
+   *
+   * @example
+   * ```js
+       let scope = ...;
+       scope.name = 'misko';
+       scope.counter = 0;
+  
+       expect(scope.counter).toEqual(0);
+       scope.$watch('name', function(newValue, oldValue) {
+         scope.counter = scope.counter + 1;
+       });
+       expect(scope.counter).toEqual(0);
+  
+       scope.$digest();
+       // the listener is always called during the first $digest loop after it was registered
+       expect(scope.counter).toEqual(1);
+  
+       scope.$digest();
+       // but now it will not be called unless the value changes
+       expect(scope.counter).toEqual(1);
+  
+       scope.name = 'adam';
+       scope.$digest();
+       expect(scope.counter).toEqual(2);
+   * ```
+   *
+   */
+    $digest(): void;
+    /**
+     * @private
+     * @param {ScopePhase} phase
+     */
+    private beginPhase;
+    /**
+     * @ngdoc method
+     * @name $rootScope.Scope#$suspend
+     * @kind function
+     *
+     * @description
+     * Suspend watchers of this scope subtree so that they will not be invoked during digest.
+     *
+     * This can be used to optimize your application when you know that running those watchers
+     * is redundant.
+     *
+     * **Warning**
+     *
+     * Suspending scopes from the digest cycle can have unwanted and difficult to debug results.
+     * Only use this approach if you are confident that you know what you are doing and have
+     * ample tests to ensure that bindings get updated as you expect.
+     *
+     * Some of the things to consider are:
+     *
+     * * Any external event on a directive/component will not trigger a digest while the hosting
+     *   scope is suspended - even if the event handler calls `$apply()` or `$rootScope.$digest()`.
+     * * Transcluded content exists on a scope that inherits from outside a directive but exists
+     *   as a child of the directive's containing scope. If the containing scope is suspended the
+     *   transcluded scope will also be suspended, even if the scope from which the transcluded
+     *   scope inherits is not suspended.
+     * * Multiple directives trying to manage the suspended status of a scope can confuse each other:
+     *    * A call to `$suspend()` on an already suspended scope is a no-op.
+     *    * A call to `$resume()` on a non-suspended scope is a no-op.
+     *    * If two directives suspend a scope, then one of them resumes the scope, the scope will no
+     *      longer be suspended. This could result in the other directive believing a scope to be
+     *      suspended when it is not.
+     * * If a parent scope is suspended then all its descendants will be also excluded from future
+     *   digests whether or not they have been suspended themselves. Note that this also applies to
+     *   isolate child scopes.
+     * * Calling `$digest()` directly on a descendant of a suspended scope will still run the watchers
+     *   for that scope and its descendants. When digesting we only check whether the current scope is
+     *   locally suspended, rather than checking whether it has a suspended ancestor.
+     * * Calling `$resume()` on a scope that has a suspended ancestor will not cause the scope to be
+     *   included in future digests until all its ancestors have been resumed.
+     * * Resolved promises, e.g. from explicit `$q` deferreds and `$http` calls, trigger `$apply()`
+     *   against the `$rootScope` and so will still trigger a global digest even if the promise was
+     *   initiated by a component that lives on a suspended scope.
+     */
+    $suspend(): void;
+    /**
+     * @ngdoc method
+     * @name $rootScope.Scope#$isSuspended
+     * @kind function
+     *
+     * @description
+     * Call this method to determine if this scope has been explicitly suspended. It will not
+     * tell you whether an ancestor has been suspended.
+     * To determine if this scope will be excluded from a digest triggered at the $rootScope,
+     * for example, you must check all its ancestors:
+     *
+     * ```
+     * function isExcludedFromDigest(scope) {
+     *   while(scope) {
+     *     if (scope.$isSuspended()) return true;
+     *     scope = scope.$parent;
+     *   }
+     *   return false;
+     * ```
+     *
+     * Be aware that a scope may not be included in digests if it has a suspended ancestor,
+     * even if `$isSuspended()` returns false.
+     *
+     * @returns true if the current scope has been suspended.
+     */
+    $isSuspended(): boolean;
+    /**
+     * @ngdoc method
+     * @name $rootScope.Scope#$resume
+     * @kind function
+     *
+     * @description
+     * Resume watchers of this scope subtree in case it was suspended.
+     *
+     * See {@link $rootScope.Scope#$suspend} for information about the dangers of using this approach.
+     */
+    $resume(): void;
+    /**
+     * @ngdoc event
+     * @name $rootScope.Scope#$destroy
+     * @eventType broadcast on scope being destroyed
+     *
+     * @description
+     * Broadcasted when a scope and its children are being destroyed.
+     *
+     * Note that, in AngularTS, there is also a `$destroy` jQuery event, which can be used to
+     * clean up DOM bindings before an element is removed from the DOM.
+     */
+    /**
+     * @ngdoc method
+     * @name $rootScope.Scope#$destroy
+     * @kind function
+     *
+     * @description
+     * Removes the current scope (and all of its children) from the parent scope. Removal implies
+     * that calls to {@link ng.$rootScope.Scope#$digest $digest()} will no longer
+     * propagate to the current scope and its children. Removal also implies that the current
+     * scope is eligible for garbage collection.
+     *
+     * The `$destroy()` is usually used by directives such as
+     * {@link ng.directive:ngRepeat ngRepeat} for managing the
+     * unrolling of the loop.
+     *
+     * Just before a scope is destroyed, a `$destroy` event is broadcasted on this scope.
+     * Application code can register a `$destroy` event handler that will give it a chance to
+     * perform any necessary cleanup.
+     *
+     * Note that, in AngularTS, there is also a `$destroy` event, which can be used to
+     * clean up DOM bindings before an element is removed from the DOM.
+     */
+    $destroy(): void;
+    /**
+   * @ngdoc method
+   * @name $rootScope.Scope#$apply
+   * @kind function
+   *
+   * @description
+   * `$apply()` is used to execute an expression in AngularTS from outside of the AngularTS
+   * framework. (For example from browser DOM events, setTimeout, XHR or third party libraries).
+   * Because we are calling into the AngularTS framework we need to perform proper scope life
+   * cycle of {@link ng.$exceptionHandler exception handling},
+   * {@link ng.$rootScope.Scope#$digest executing watches}.
+   *
+   * **Life cycle: Pseudo-Code of `$apply()`**
+   *
+   * ```js
+       function $apply(expr) {
+         try {
+           return $eval(expr);
+         } catch (e) {
+           $exceptionHandler(e);
+         } finally {
+           $root.$digest();
+         }
+       }
+   * ```
+   *
+   *
+   * Scope's `$apply()` method transitions through the following stages:
+   *
+   * 1. The {@link guide/expression expression} is executed using the
+   *    {@link ng.$rootScope.Scope#$eval $eval()} method.
+   * 2. Any exceptions from the execution of the expression are forwarded to the
+   *    {@link ng.$exceptionHandler $exceptionHandler} service.
+   * 3. The {@link ng.$rootScope.Scope#$watch watch} listeners are fired immediately after the
+   *    expression was executed using the {@link ng.$rootScope.Scope#$digest $digest()} method.
+   *
+   *
+   * @param {string|function(Scope): any} [expr] An AngularTS expression to be executed.
+   *
+   *    - `string`: execute using the rules as defined in {@link guide/expression expression}.
+   *    - `function(scope)`: execute the function with current `scope` parameter.
+   *
+   * @returns {*} The result of evaluating the expression.
+   */
+    $apply(expr?: string | ((arg0: Scope) => any)): any;
+    /**
+     * @ngdoc method
+     * @name $rootScope.Scope#$evalAsync
+     * @kind function
+     *
+     * @description
+     * Executes the expression on the current scope at a later point in time.
+     *
+     * The `$evalAsync` makes no guarantees as to when the `expression` will be executed, only
+     * that:
+     *
+     *   - it will execute after the function that scheduled the evaluation (preferably before DOM
+     *     rendering).
+     *   - at least one {@link ng.$rootScope.Scope#$digest $digest cycle} will be performed after
+     *     `expression` execution.
+     *
+     * Any exceptions from the execution of the expression are forwarded to the
+     * {@link ng.$exceptionHandler $exceptionHandler} service.
+     *
+     * __Note:__ if this function is called outside of a `$digest` cycle, a new `$digest` cycle
+     * will be scheduled. However, it is encouraged to always call code that changes the model
+     * from within an `$apply` call. That includes code evaluated via `$evalAsync`.
+     *
+     * @param {(string|function())=} expr An AngularTS expression to be executed.
+     *
+     *    - `string`: execute using the rules as defined in {@link guide/expression expression}.
+     *    - `function(scope)`: execute the function with the current `scope` parameter.
+     *
+     * @param {(object)=} locals Local variables object, useful for overriding values in scope.
+     */
+    $evalAsync(expr?: (string | (() => any)) | undefined, locals?: (object) | undefined): any;
+    /**
+     * @ngdoc method
+     * @name $rootScope.Scope#$applyAsync
+     * @kind function
+     *
+     * @description
+     * Schedule the invocation of $apply to occur at a later time. The actual time difference
+     * varies across browsers, but is typically around ~10 milliseconds.
+     *
+     * This can be used to queue up multiple expressions which need to be evaluated in the same
+     * digest.
+     *
+     * @param {(string|function())=} expr An AngularTS expression to be executed.
+     *
+     *    - `string`: execute using the rules as defined in {@link guide/expression expression}.
+     *    - `function(scope)`: execute the function with current `scope` parameter.
+     */
+    $applyAsync(expr?: (string | (() => any)) | undefined): void;
+    /**
+     * @description
+     * Listens on events of a given type. See {@link ng.$rootScope.Scope#$emit $emit} for
+     * discussion of event life cycle.
+     *
+     * The event listener function format is: `function(event, args...)`. The `event` object
+     * passed into the listener has the following attributes:
+     *
+     *   - `targetScope` - `{Scope}`: the scope on which the event was `$emit`-ed or
+     *     `$broadcast`-ed.
+     *   - `currentScope` - `{Scope}`: the scope that is currently handling the event. Once the
+     *     event propagates through the scope hierarchy, this property is set to null.
+     *   - `name` - `{string}`: name of the event.
+     *   - `stopPropagation` - `{function=}`: calling `stopPropagation` function will cancel
+     *     further event propagation (available only for events that were `$emit`-ed).
+     *   - `preventDefault` - `{function}`: calling `preventDefault` sets `defaultPrevented` flag
+     *     to true.
+     *   - `defaultPrevented` - `{boolean}`: true if `preventDefault` was called.
+     *
+     * @param {string} name Event name to listen on.
+     * @param {function(angular.IAngularEvent): any} listener Function to call when the event is emitted.
+     * @returns {function()} Returns a deregistration function for this listener.
+     */
+    $on(name: string, listener: (arg0: angular.IAngularEvent) => any): () => any;
+    /**
+   * @ngdoc method
+   * @name $rootScope.Scope#$eval
+   * @kind function
+   *
+   * @description
+   * Executes the `expression` on the current scope and returns the result. Any exceptions in
+   * the expression are propagated (uncaught). This is useful when evaluating AngularTS
+   * expressions.
+   *
+   * @example
+   * ```js
+       let scope = new Scope();
+       scope.a = 1;
+       scope.b = 2;
+  
+       expect(scope.$eval('a+b')).toEqual(3);
+       expect(scope.$eval(function(scope){ return scope.a + scope.b; })).toEqual(3);
+   * ```
+   *
+   * @param {string|function(Scope): any} [expr] An AngularTS expression to be executed.
+   *
+   *    - `string`: execute using the rules as defined in  {@link guide/expression expression}.
+   *    - `function(scope)`: execute the function with the current `scope` parameter.
+   *
+   * @param {(object)=} locals Local variables object, useful for overriding values in scope.
+   * @returns {*} The result of evaluating the expression.
+   */
+    $eval(expr?: string | ((arg0: Scope) => any), locals?: (object) | undefined): any;
+    /**
+     * @private
+     */
+    private $$postDigest;
+    clearPhase(): void;
+    /**
+     * @param {number} count
+     */
+    incrementWatchersCount(count: number): void;
+    /**
+     * @param {number} count
+     * @param {string} name
+     */
+    decrementListenerCount(count: number, name: string): void;
+    /**
+     * @ngdoc method
+     * @name $rootScope.Scope#$emit
+     * @kind function
+     *
+     * @description
+     * Dispatches an event `name` upwards through the scope hierarchy notifying the
+     * registered {@link ng.$rootScope.Scope#$on} listeners.
+     *
+     * The event life cycle starts at the scope on which `$emit` was called. All
+     * {@link ng.$rootScope.Scope#$on listeners} listening for `name` event on this scope get
+     * notified. Afterwards, the event traverses upwards toward the root scope and calls all
+     * registered listeners along the way. The event will stop propagating if one of the listeners
+     * cancels it.
+     *
+     * Any exception emitted from the {@link ng.$rootScope.Scope#$on listeners} will be passed
+     * onto the {@link ng.$exceptionHandler $exceptionHandler} service.
+     *
+     * @param {string} name Event name to emit.
+     * @param {...*} args Optional one or more arguments which will be passed onto the event listeners.
+     * @return {Object} Event object (see {@link ng.$rootScope.Scope#$on}).
+     */
+    $emit(name: string, ...args: any[]): any;
+    /**
+     * @ngdoc method
+     * @name $rootScope.Scope#$broadcast
+     * @kind function
+     *
+     * @description
+     * Dispatches an event `name` downwards to all child scopes (and their children) notifying the
+     * registered {@link ng.$rootScope.Scope#$on} listeners.
+     *
+     * The event life cycle starts at the scope on which `$broadcast` was called. All
+     * {@link ng.$rootScope.Scope#$on listeners} listening for `name` event on this scope get
+     * notified. Afterwards, the event propagates to all direct and indirect scopes of the current
+     * scope and calls all registered listeners along the way. The event cannot be canceled.
+     *
+     * Any exception emitted from the {@link ng.$rootScope.Scope#$on listeners} will be passed
+     * onto the {@link ng.$exceptionHandler $exceptionHandler} service.
+     *
+     * @param {string} name Event name to broadcast.
+     * @param {...*} args Optional one or more arguments which will be passed onto the event listeners.
+     * @return {Object} Event object, see {@link ng.$rootScope.Scope#$on}
+     */
+    $broadcast(name: string, ...args: any[]): any;
+}
+export type AsyncQueueTask = {
+    scope: Scope;
+    fn: Function;
+    locals: any;
+};