@angular-wave/angular.ts 0.9.2 → 0.9.4

package/legacy.d.ts

@@ -1,138 +1,5 @@
-declare var angular: angular.IAngularStatic;
-
-// Support for painless dependency injection
-declare global {
-  interface Function {
-    $inject?: readonly string[] | undefined;
-  }
-}
-
-export as namespace angular;
-export as namespace ng;
-
-// Support AMD require
-export = angular;
-
-import ng = angular;
-
-///////////////////////////////////////////////////////////////////////////////
-// ng module (angular.js)
-///////////////////////////////////////////////////////////////////////////////
 declare namespace angular {
-  type Injectable<T extends Function> = T | Array<string | T>;
-
   // not directly implemented, but ensures that constructed class implements $get
-  interface IServiceProviderClass {
-    new (...args: any[]): IServiceProvider;
-  }
-
-  interface IServiceProviderFactory {
-    (...args: any[]): IServiceProvider;
-  }
-
-  // All service providers extend this interface
-  interface IServiceProvider {
-    $get: any;
-  }
-
-  interface IAngularBootstrapConfig {
-    strictDi?: boolean | undefined;
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // AngularStatic
-  // see http://docs.angularjs.org/api
-  ///////////////////////////////////////////////////////////////////////////
-  interface IAngularStatic {
-    bind(context: any, fn: Function, ...args: any[]): Function;
-
-    /**
-     * Use this function to manually start up angular application.
-     *
-     * @param element DOM element which is the root of angular application.
-     * @param modules An array of modules to load into the application.
-     *     Each item in the array should be the name of a predefined module or a (DI annotated)
-     *     function that will be invoked by the injector as a config block.
-     * @param config an object for defining configuration options for the application. The following keys are supported:
-     *     - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
-     */
-    bootstrap(
-      element: string | Element | JQuery | Document,
-      modules?: Array<string | Function | any[]>,
-      config?: IAngularBootstrapConfig,
-    ): auto.IInjectorService;
-
-    /**
-     * Creates a deep copy of source, which should be an object or an array.
-     *
-     * - If no destination is supplied, a copy of the object or array is created.
-     * - If a destination is provided, all of its elements (for array) or properties (for objects) are deleted and then all elements/properties from the source are copied to it.
-     * - If source is not an object or array (inc. null and undefined), source is returned.
-     * - If source is identical to 'destination' an exception will be thrown.
-     *
-     * @param source The source that will be used to make a copy. Can be any type, including primitives, null, and undefined.
-     * @param destination Destination into which the source is copied. If provided, must be of the same type as source.
-     */
-    copy<T>(source: T, destination?: T): T;
-
-    /**
-     * Wraps a raw DOM element or HTML string as a jQuery element.
-     *
-     * If jQuery is available, angular.element is an alias for the jQuery function. If jQuery is not available, angular.element delegates to Angular's built-in subset of jQuery, called "jQuery lite" or "jqLite."
-     */
-    element: JQueryStatic;
-    /**
-     * Configure several aspects of error handling in AngularJS if used as a setter
-     * or return the current configuration if used as a getter
-     */
-    errorHandlingConfig(): IErrorHandlingConfig;
-    errorHandlingConfig(config: IErrorHandlingConfig): void;
-    equals(value1: any, value2: any): boolean;
-    extend(destination: any, ...sources: any[]): any;
-
-    /**
-     * The angular.module is a global place for creating, registering and retrieving Angular modules. All modules (angular core or 3rd party) that should be available to an application must be registered using this mechanism.
-     *
-     * When passed two or more arguments, a new module is created. If passed only one argument, an existing module (the name passed as the first argument to module) is retrieved.
-     *
-     * @param name The name of the module to create or retrieve.
-     * @param requires The names of modules this module depends on. If specified then new module is being created. If unspecified then the module is being retrieved for further configuration.
-     * @param configFn Optional configuration function for the module.
-     */
-    module(
-      name: string,
-      requires?: string[],
-      configFn?: Injectable<Function>,
-    ): IModule;
-
-    noop(...args: any[]): void;
-    reloadWithDebugInfo(): void;
-    toJson(obj: any, pretty?: boolean | number): string;
-    version: {
-      full: string;
-      major: number;
-      minor: number;
-      dot: number;
-      codeName: string;
-    };
-
-    /**
-     * If window.name contains prefix NG_DEFER_BOOTSTRAP! when angular.bootstrap is called, the bootstrap process will be paused until angular.resumeBootstrap() is called.
-     * @param extraModules An optional array of modules that should be added to the original list of modules that the app was about to be bootstrapped with.
-     */
-    resumeBootstrap?(extraModules?: string[]): ng.auto.IInjectorService;
-
-    /**
-     * Restores the pre-1.8 behavior of jqLite that turns XHTML-like strings like
-     * `<div /><span />` to `<div></div><span></span>` instead of `<div><span></span></div>`.
-     * The new behavior is a security fix so if you use this method, please try to adjust
-     * to the change & remove the call as soon as possible.
-     * Note that this only patches jqLite. If you use jQuery 3.5.0 or newer, please read
-     * [jQuery 3.5 upgrade guide](https://jquery.com/upgrade-guide/3.5/) for more details
-     * about the workarounds.
-     */
-    UNSAFE_restoreLegacyJqLiteXHTMLReplacement(): void;
-  }
 
   ///////////////////////////////////////////////////////////////////////////
   // Module
@@ -466,184 +333,6 @@ declare namespace angular {
     (): void;
   }
 
-  /**
-   * $rootScope - $rootScopeProvider - service in module ng
-   * see https://docs.angularjs.org/api/ng/type/$rootScope.Scope and https://docs.angularjs.org/api/ng/service/$rootScope
-   */
-  interface IRootScopeService {
-    $apply(): any;
-    $apply(exp: string): any;
-    $apply(exp: (scope: IScope) => any): any;
-
-    $applyAsync(): any;
-    $applyAsync(exp: string): any;
-    $applyAsync(exp: (scope: IScope) => any): any;
-
-    /**
-     * Dispatches an event name downwards to all child scopes (and their children) notifying the registered $rootScope.Scope listeners.
-     *
-     * The event life cycle starts at the scope on which $broadcast was called. All 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 listeners will be passed onto the $exceptionHandler service.
-     *
-     * @param name Event name to broadcast.
-     * @param args Optional one or more arguments which will be passed onto the event listeners.
-     */
-    $broadcast(name: string, ...args: any[]): IAngularEvent;
-    $destroy(): void;
-    $digest(): void;
-
-    /**
-     * 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;
-
-    /**
-     * 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;
-
-    /**
-     * Resume watchers of this scope subtree in case it was suspended.
-     *
-     * See {$rootScope.Scope#$suspend} for information about the dangers of using this approach.
-     */
-    $resume(): void;
-
-    /**
-     * Dispatches an event name upwards through the scope hierarchy notifying the registered $rootScope.Scope listeners.
-     *
-     * The event life cycle starts at the scope on which $emit was called. All 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 listeners will be passed onto the $exceptionHandler service.
-     *
-     * @param name Event name to emit.
-     * @param args Optional one or more arguments which will be passed onto the event listeners.
-     */
-    $emit(name: string, ...args: any[]): IAngularEvent;
-
-    $eval(): any;
-    $eval(expression: string, locals?: Object): any;
-    $eval(expression: (scope: IScope) => any, locals?: Object): any;
-
-    // Defaults to false by the implementation checking strategy
-    $new(isolate?: boolean, parent?: IScope): IScope;
-
-    /**
-     * Listens on events of a given type. See $emit for discussion of event life cycle.
-     *
-     * The event listener function format is: function(event, args...).
-     *
-     * @param name Event name to listen on.
-     * @param listener Function to call when the event is emitted.
-     */
-    $on(
-      name: string,
-      listener: (event: IAngularEvent, ...args: any[]) => any,
-    ): () => void;
-
-    $watch(
-      watchExpression: string,
-      listener?: string,
-      objectEquality?: boolean,
-    ): () => void;
-    $watch<T>(
-      watchExpression: string,
-      listener?: (newValue: T, oldValue: T, scope: IScope) => any,
-      objectEquality?: boolean,
-    ): () => void;
-    $watch(
-      watchExpression: (scope: IScope) => any,
-      listener?: string,
-      objectEquality?: boolean,
-    ): () => void;
-    $watch<T>(
-      watchExpression: (scope: IScope) => T,
-      listener?: (newValue: T, oldValue: T, scope: IScope) => any,
-      objectEquality?: boolean,
-    ): () => void;
-
-    $watchCollection<T>(
-      watchExpression: string,
-      listener: (newValue: T, oldValue: T, scope: IScope) => any,
-    ): () => void;
-    $watchCollection<T>(
-      watchExpression: (scope: IScope) => T,
-      listener: (newValue: T, oldValue: T, scope: IScope) => any,
-    ): () => void;
-
-    $watchGroup(
-      watchExpressions: any[],
-      listener: (newValue: any, oldValue: any, scope: IScope) => any,
-    ): () => void;
-    $watchGroup(
-      watchExpressions: Array<{ (scope: IScope): any }>,
-      listener: (newValue: any, oldValue: any, scope: IScope) => any,
-    ): () => void;
-
-    $parent: IScope;
-    $root: IRootScopeService;
-    $id: number;
-
-    // Hidden members
-    $$isolateBindings: any;
-    $$phase: any;
-  }
-
-  interface IScope extends IRootScopeService {}
-
   /**
    * $scope for ngRepeat directive.
    * see https://docs.angularjs.org/api/ng/directive/ngRepeat
@@ -707,44 +396,6 @@ declare namespace angular {
     defaultPrevented: boolean;
   }
 
-  ///////////////////////////////////////////////////////////////////////////
-  // WindowService
-  // see http://docs.angularjs.org/api/ng/service/$window
-  ///////////////////////////////////////////////////////////////////////////
-  interface IWindowService extends Window {
-    [key: string]: any;
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // TimeoutService
-  // see http://docs.angularjs.org/api/ng/service/$timeout
-  ///////////////////////////////////////////////////////////////////////////
-  interface ITimeoutService {
-    (delay?: number, invokeApply?: boolean): IPromise<void>;
-    <T>(
-      fn: (...args: any[]) => T | IPromise<T>,
-      delay?: number,
-      invokeApply?: boolean,
-      ...args: any[]
-    ): IPromise<T>;
-    cancel(promise?: IPromise<any>): boolean;
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // IntervalService
-  // see http://docs.angularjs.org/api/ng/service/$interval
-  ///////////////////////////////////////////////////////////////////////////
-  interface IIntervalService {
-    (
-      func: Function,
-      delay: number,
-      count?: number,
-      invokeApply?: boolean,
-      ...args: any[]
-    ): IPromise<any>;
-    cancel(promise: IPromise<any>): boolean;
-  }
-
   /**
    * $filter - $filterProvider - service in module ng
    *
@@ -1129,15 +780,6 @@ declare namespace angular {
     }): ILocationProvider;
   }
 
-  ///////////////////////////////////////////////////////////////////////////
-  // DocumentService
-  // see http://docs.angularjs.org/api/ng/service/$document
-  ///////////////////////////////////////////////////////////////////////////
-  interface IDocumentService extends JQLite {
-    // Must return intersection type for index signature compatibility with JQuery
-    [index: number]: HTMLElement & Document;
-  }
-
   ///////////////////////////////////////////////////////////////////////////
   // ExceptionHandlerService
   // see http://docs.angularjs.org/api/ng/service/$exceptionHandler
@@ -1146,389 +788,6 @@ declare namespace angular {
     (exception: Error, cause?: string): void;
   }
 
-  ///////////////////////////////////////////////////////////////////////////
-  // RootElementService
-  // see http://docs.angularjs.org/api/ng/service/$rootElement
-  ///////////////////////////////////////////////////////////////////////////
-  interface IRootElementService extends JQLite {}
-
-  interface IQResolveReject<T> {
-    (): void;
-    (value: T): void;
-  }
-  /**
-   * $q - service in module ng
-   * A promise/deferred implementation inspired by Kris Kowal's Q.
-   * See http://docs.angularjs.org/api/ng/service/$q
-   */
-  interface IQService {
-    new <T>(
-      resolver: (
-        resolve: IQResolveReject<T>,
-        reject: IQResolveReject<any>,
-      ) => any,
-    ): IPromise<T>;
-    <T>(
-      resolver: (
-        resolve: IQResolveReject<T>,
-        reject: IQResolveReject<any>,
-      ) => any,
-    ): IPromise<T>;
-
-    /**
-     * Combines multiple promises into a single promise that is resolved when all of the input promises are resolved.
-     *
-     * Returns a single promise that will be resolved with an array of values, each value corresponding to the promise at the same index in the promises array. If any of the promises is resolved with a rejection, this resulting promise will be rejected with the same rejection value.
-     *
-     * @param promises An array of promises.
-     */
-    all<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
-      values: [
-        T1 | IPromise<T1>,
-        T2 | IPromise<T2>,
-        T3 | IPromise<T3>,
-        T4 | IPromise<T4>,
-        T5 | IPromise<T5>,
-        T6 | IPromise<T6>,
-        T7 | IPromise<T7>,
-        T8 | IPromise<T8>,
-        T9 | IPromise<T9>,
-        T10 | IPromise<T10>,
-      ],
-    ): IPromise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
-    all<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
-      values: [
-        T1 | IPromise<T1>,
-        T2 | IPromise<T2>,
-        T3 | IPromise<T3>,
-        T4 | IPromise<T4>,
-        T5 | IPromise<T5>,
-        T6 | IPromise<T6>,
-        T7 | IPromise<T7>,
-        T8 | IPromise<T8>,
-        T9 | IPromise<T9>,
-      ],
-    ): IPromise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
-    all<T1, T2, T3, T4, T5, T6, T7, T8>(
-      values: [
-        T1 | IPromise<T1>,
-        T2 | IPromise<T2>,
-        T3 | IPromise<T3>,
-        T4 | IPromise<T4>,
-        T5 | IPromise<T5>,
-        T6 | IPromise<T6>,
-        T7 | IPromise<T7>,
-        T8 | IPromise<T8>,
-      ],
-    ): IPromise<[T1, T2, T3, T4, T5, T6, T7, T8]>;
-    all<T1, T2, T3, T4, T5, T6, T7>(
-      values: [
-        T1 | IPromise<T1>,
-        T2 | IPromise<T2>,
-        T3 | IPromise<T3>,
-        T4 | IPromise<T4>,
-        T5 | IPromise<T5>,
-        T6 | IPromise<T6>,
-        T7 | IPromise<T7>,
-      ],
-    ): IPromise<[T1, T2, T3, T4, T5, T6, T7]>;
-    all<T1, T2, T3, T4, T5, T6>(
-      values: [
-        T1 | IPromise<T1>,
-        T2 | IPromise<T2>,
-        T3 | IPromise<T3>,
-        T4 | IPromise<T4>,
-        T5 | IPromise<T5>,
-        T6 | IPromise<T6>,
-      ],
-    ): IPromise<[T1, T2, T3, T4, T5, T6]>;
-    all<T1, T2, T3, T4, T5>(
-      values: [
-        T1 | IPromise<T1>,
-        T2 | IPromise<T2>,
-        T3 | IPromise<T3>,
-        T4 | IPromise<T4>,
-        T5 | IPromise<T5>,
-      ],
-    ): IPromise<[T1, T2, T3, T4, T5]>;
-    all<T1, T2, T3, T4>(
-      values: [
-        T1 | IPromise<T1>,
-        T2 | IPromise<T2>,
-        T3 | IPromise<T3>,
-        T4 | IPromise<T4>,
-      ],
-    ): IPromise<[T1, T2, T3, T4]>;
-    all<T1, T2, T3>(
-      values: [T1 | IPromise<T1>, T2 | IPromise<T2>, T3 | IPromise<T3>],
-    ): IPromise<[T1, T2, T3]>;
-    all<T1, T2>(
-      values: [T1 | IPromise<T1>, T2 | IPromise<T2>],
-    ): IPromise<[T1, T2]>;
-    all<TAll>(promises: Array<TAll | IPromise<TAll>>): IPromise<TAll[]>;
-    /**
-     * Combines multiple promises into a single promise that is resolved when all of the input promises are resolved.
-     *
-     * Returns a single promise that will be resolved with a hash of values, each value corresponding to the promise at the same key in the promises hash. If any of the promises is resolved with a rejection, this resulting promise will be rejected with the same rejection value.
-     *
-     * @param promises A hash of promises.
-     */
-    all<T>(promises: { [K in keyof T]: IPromise<T[K]> | T[K] }): IPromise<T>;
-    /**
-     * Creates a Deferred object which represents a task which will finish in the future.
-     */
-    defer<T>(): IDeferred<T>;
-    /**
-     * Returns a promise that resolves or rejects as soon as one of those promises resolves or rejects, with the value or reason from that promise.
-     *
-     * @param promises A list or hash of promises.
-     */
-    race<T>(
-      promises: Array<IPromise<T>> | { [key: string]: IPromise<T> },
-    ): IPromise<T>;
-    /**
-     * Creates a promise that is resolved as rejected with the specified reason. This api should be used to forward rejection in a chain of promises. If you are dealing with the last promise in a promise chain, you don't need to worry about it.
-     *
-     * When comparing deferreds/promises to the familiar behavior of try/catch/throw, think of reject as the throw keyword in JavaScript. This also means that if you "catch" an error via a promise error callback and you want to forward the error to the promise derived from the current promise, you have to "rethrow" the error by returning a rejection constructed via reject.
-     *
-     * @param reason Constant, message, exception or an object representing the rejection reason.
-     */
-    reject(reason?: any): IPromise<never>;
-    /**
-     * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted.
-     *
-     * @param value Value or a promise
-     */
-    resolve<T>(value: PromiseLike<T> | T): IPromise<T>;
-    /**
-     * @deprecated Since TS 2.4, inference is stricter and no longer produces the desired type when T1 !== T2.
-     * To use resolve with two different types, pass a union type to the single-type-argument overload.
-     */
-    resolve<T1, T2>(value: PromiseLike<T1> | T2): IPromise<T1 | T2>;
-    /**
-     * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted.
-     */
-    resolve(): IPromise<void>;
-    /**
-     * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted.
-     *
-     * @param value Value or a promise
-     */
-    when<T>(value: PromiseLike<T> | T): IPromise<T>;
-    when<T1, T2>(value: PromiseLike<T1> | T2): IPromise<T1 | T2>;
-    when<TResult, T>(
-      value: PromiseLike<T> | T,
-      successCallback: (promiseValue: T) => PromiseLike<TResult> | TResult,
-    ): IPromise<TResult>;
-    when<TResult, T>(
-      value: T,
-      successCallback: (promiseValue: T) => PromiseLike<TResult> | TResult,
-      errorCallback: null | undefined | ((reason: any) => any),
-      notifyCallback?: (state: any) => any,
-    ): IPromise<TResult>;
-    when<TResult, TResult2, T>(
-      value: PromiseLike<T>,
-      successCallback: (promiseValue: T) => PromiseLike<TResult> | TResult,
-      errorCallback: (reason: any) => TResult2 | PromiseLike<TResult2>,
-      notifyCallback?: (state: any) => any,
-    ): IPromise<TResult | TResult2>;
-    /**
-     * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted.
-     */
-    when(): IPromise<void>;
-  }
-
-  interface IQProvider {
-    /**
-     * Retrieves or overrides whether to generate an error when a rejected promise is not handled.
-     * This feature is enabled by default.
-     *
-     * @returns Current value
-     */
-    errorOnUnhandledRejections(): boolean;
-
-    /**
-     * Retrieves or overrides whether to generate an error when a rejected promise is not handled.
-     * This feature is enabled by default.
-     *
-     * @param value Whether to generate an error when a rejected promise is not handled.
-     * @returns Self for chaining otherwise.
-     */
-    errorOnUnhandledRejections(value: boolean): IQProvider;
-  }
-
-  interface IPromise<T> {
-    /**
-     * Regardless of when the promise was or will be resolved or rejected, then calls one of
-     * the success or error callbacks asynchronously as soon as the result is available. The
-     * callbacks are called with a single argument: the result or rejection reason.
-     * Additionally, the notify callback may be called zero or more times to provide a
-     * progress indication, before the promise is resolved or rejected.
-     * The `successCallBack` may return `IPromise<never>` for when a `$q.reject()` needs to
-     * be returned.
-     * This method returns a new promise which is resolved or rejected via the return value
-     * of the `successCallback`, `errorCallback`. It also notifies via the return value of
-     * the `notifyCallback` method. The promise can not be resolved or rejected from the
-     * `notifyCallback` method.
-     */
-    then<TResult1 = T, TResult2 = never>(
-      successCallback?:
-        | ((value: T) => PromiseLike<never> | PromiseLike<TResult1> | TResult1)
-        | null,
-      errorCallback?:
-        | ((
-            reason: any,
-          ) => PromiseLike<never> | PromiseLike<TResult2> | TResult2)
-        | null,
-      notifyCallback?: (state: any) => any,
-    ): IPromise<TResult1 | TResult2>;
-    then<TResult1 = T, TResult2 = never>(
-      successCallback?:
-        | ((value: T) => IPromise<never> | IPromise<TResult1> | TResult1)
-        | null,
-      errorCallback?:
-        | ((reason: any) => IPromise<never> | IPromise<TResult2> | TResult2)
-        | null,
-      notifyCallback?: (state: any) => any,
-    ): IPromise<TResult1 | TResult2>;
-
-    /**
-     * Shorthand for promise.then(null, errorCallback)
-     */
-    catch<TResult = never>(
-      onRejected?:
-        | ((reason: any) => PromiseLike<never> | PromiseLike<TResult> | TResult)
-        | null,
-    ): IPromise<T | TResult>;
-    catch<TResult = never>(
-      onRejected?:
-        | ((reason: any) => IPromise<never> | IPromise<TResult> | TResult)
-        | null,
-    ): IPromise<T | TResult>;
-
-    /**
-     * Allows you to observe either the fulfillment or rejection of a promise, but to do so without modifying the final value. This is useful to release resources or do some clean-up that needs to be done whether the promise was rejected or resolved. See the full specification for more information.
-     *
-     * Because finally is a reserved word in JavaScript and reserved keywords are not supported as property names by ES3, you'll need to invoke the method like promise['finally'](callback) to make your code IE8 and Android 2.x compatible.
-     */
-    finally(finallyCallback: () => void): IPromise<T>;
-  }
-
-  interface IDeferred<T> {
-    resolve(value?: T | IPromise<T>): void;
-    reject(reason?: any): void;
-    notify(state?: any): void;
-    promise: IPromise<T>;
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // AnchorScrollService
-  // see http://docs.angularjs.org/api/ng/service/$anchorScroll
-  ///////////////////////////////////////////////////////////////////////////
-  interface IAnchorScrollService {
-    (): void;
-    (hash: string): void;
-    yOffset: any;
-  }
-
-  interface IAnchorScrollProvider extends IServiceProvider {
-    disableAutoScrolling(): void;
-  }
-
-  /**
-   * $cacheFactory - service in module ng
-   *
-   * Factory that constructs Cache objects and gives access to them.
-   *
-   * see https://docs.angularjs.org/api/ng/service/$cacheFactory
-   */
-  interface ICacheFactoryService {
-    /**
-     * Factory that constructs Cache objects and gives access to them.
-     *
-     * @param cacheId Name or id of the newly created cache.
-     * @param optionsMap Options object that specifies the cache behavior. Properties:
-     *
-     * capacity — turns the cache into LRU cache.
-     */
-    (
-      cacheId: string,
-      optionsMap?: { capacity?: number | undefined },
-    ): ICacheObject;
-
-    /**
-     * Get information about all the caches that have been created.
-     * @returns key-value map of cacheId to the result of calling cache#info
-     */
-    info(): any;
-
-    /**
-     * Get access to a cache object by the cacheId used when it was created.
-     *
-     * @param cacheId Name or id of a cache to access.
-     */
-    get(cacheId: string): ICacheObject;
-  }
-
-  /**
-   * $cacheFactory.Cache - type in module ng
-   *
-   * A cache object used to store and retrieve data, primarily used by $http and the script directive to cache templates and other data.
-   *
-   * see https://docs.angularjs.org/api/ng/type/$cacheFactory.Cache
-   */
-  interface ICacheObject {
-    /**
-     * Retrieve information regarding a particular Cache.
-     */
-    info(): {
-      /**
-       * the id of the cache instance
-       */
-      id: string;
-
-      /**
-       * the number of entries kept in the cache instance
-       */
-      size: number;
-      // ...: any additional properties from the options object when creating the cache.
-    };
-
-    /**
-     * Inserts a named entry into the Cache object to be retrieved later, and incrementing the size of the cache if the key was not already present in the cache. If behaving like an LRU cache, it will also remove stale entries from the set.
-     *
-     * It will not insert undefined values into the cache.
-     *
-     * @param key the key under which the cached data is stored.
-     * @param value the value to store alongside the key. If it is undefined, the key will not be stored.
-     */
-    put<T>(key: string, value?: T): T;
-
-    /**
-     * Retrieves named data stored in the Cache object.
-     *
-     * @param key the key of the data to be retrieved
-     */
-    get<T>(key: string): T | undefined;
-
-    /**
-     * Removes an entry from the Cache object.
-     *
-     * @param key the key of the entry to be removed
-     */
-    remove(key: string): void;
-
-    /**
-     * Clears the cache object of any entries.
-     */
-    removeAll(): void;
-
-    /**
-     * Destroys the Cache object entirely, removing it from the $cacheFactory set.
-     */
-    destroy(): void;
-  }
-
   ///////////////////////////////////////////////////////////////////////////
   // CompileService
   // see http://docs.angularjs.org/api/ng/service/$compile
@@ -1684,14 +943,6 @@ declare namespace angular {
   // see http://docs.angularjs.org/api/ng/provider/$controllerProvider
   ///////////////////////////////////////////////////////////////////////////
 
-  /**
-   * The minimal local definitions required by $controller(ctrl, locals) calls.
-   */
-  interface IControllerLocals {
-    $scope: ng.IScope;
-    $element: JQuery;
-  }
-
   interface IControllerService {
     // Although the documentation doesn't state this, locals are optional
     <T>(controllerConstructor: new (...args: any[]) => T, locals?: any): T;
@@ -2024,39 +1275,6 @@ declare namespace angular {
     ): void;
   }
 
-  ///////////////////////////////////////////////////////////////////////////
-  // InterpolateService
-  // see http://docs.angularjs.org/api/ng/service/$interpolate
-  // see http://docs.angularjs.org/api/ng/provider/$interpolateProvider
-  ///////////////////////////////////////////////////////////////////////////
-  interface IInterpolateService {
-    (
-      text: string,
-      mustHaveExpression?: boolean,
-      trustedContext?: string,
-      allOrNothing?: boolean,
-    ): IInterpolationFunction;
-    endSymbol(): string;
-    startSymbol(): string;
-  }
-
-  interface IInterpolationFunction {
-    (context: any): string;
-  }
-
-  interface IInterpolateProvider extends IServiceProvider {
-    startSymbol(): string;
-    startSymbol(value: string): IInterpolateProvider;
-    endSymbol(): string;
-    endSymbol(value: string): IInterpolateProvider;
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // TemplateCacheService
-  // see http://docs.angularjs.org/api/ng/service/$templateCache
-  ///////////////////////////////////////////////////////////////////////////
-  interface ITemplateCacheService extends ICacheObject {}
-
   ///////////////////////////////////////////////////////////////////////////
   // SCEService
   // see http://docs.angularjs.org/api/ng/service/$sce
@@ -2119,88 +1337,6 @@ declare namespace angular {
     trustedResourceUrlList(trustedList: any[]): void;
   }
 
-  /**
-   * $templateRequest service
-   * see http://docs.angularjs.org/api/ng/service/$templateRequest
-   */
-  interface ITemplateRequestService {
-    /**
-     * Downloads a template using $http and, upon success, stores the
-     * contents inside of $templateCache.
-     *
-     * If the HTTP request fails or the response data of the HTTP request is
-     * empty then a $compile error will be thrown (unless
-     * {ignoreRequestError} is set to true).
-     *
-     * @param tpl                  The template URL.
-     * @param ignoreRequestError   Whether or not to ignore the exception
-     *                             when the request fails or the template is
-     *                             empty.
-     *
-     * @return   A promise whose value is the template content.
-     */
-    (tpl: string, ignoreRequestError?: boolean): IPromise<string>;
-    /**
-     * total amount of pending template requests being downloaded.
-     */
-    totalPendingRequests: number;
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // Component
-  // see http://angularjs.blogspot.com.br/2015/11/angularjs-15-beta2-and-14-releases.html
-  // and http://toddmotto.com/exploring-the-angular-1-5-component-method/
-  ///////////////////////////////////////////////////////////////////////////
-  /**
-   * Component definition object (a simplified directive definition object)
-   */
-  interface IComponentOptions {
-    /**
-     * Controller constructor function that should be associated with newly created scope or the name of a registered
-     * controller if passed as a string. Empty function by default.
-     * Use the array form to define dependencies (necessary if strictDi is enabled and you require dependency injection)
-     */
-    controller?: string | Injectable<IControllerConstructor> | undefined;
-    /**
-     * An identifier name for a reference to the controller. If present, the controller will be published to its scope under
-     * the specified name. If not present, this will default to '$ctrl'.
-     */
-    controllerAs?: string | undefined;
-    /**
-     * html template as a string or a function that returns an html template as a string which should be used as the
-     * contents of this component. Empty string by default.
-     * If template is a function, then it is injected with the following locals:
-     * $element - Current element
-     * $attrs - Current attributes object for the element
-     * Use the array form to define dependencies (necessary if strictDi is enabled and you require dependency injection)
-     */
-    template?: string | Injectable<(...args: any[]) => string> | undefined;
-    /**
-     * Path or function that returns a path to an html template that should be used as the contents of this component.
-     * If templateUrl is a function, then it is injected with the following locals:
-     * $element - Current element
-     * $attrs - Current attributes object for the element
-     * Use the array form to define dependencies (necessary if strictDi is enabled and you require dependency injection)
-     */
-    templateUrl?: string | Injectable<(...args: any[]) => string> | undefined;
-    /**
-     * Define DOM attribute binding to component properties. Component properties are always bound to the component
-     * controller and not to the scope.
-     */
-    bindings?: { [boundProperty: string]: string } | undefined;
-    /**
-     * Whether transclusion is enabled. Disabled by default.
-     */
-    transclude?: boolean | { [slot: string]: string } | undefined;
-    /**
-     * Requires the controllers of other directives and binds them to this component's controller.
-     * The object keys specify the property names under which the required controllers (object values) will be bound.
-     * Note that the required controllers will not be available during the instantiation of the controller,
-     * but they are guaranteed to be available just before the $onInit method is executed!
-     */
-    require?: { [controller: string]: string } | undefined;
-  }
-
   type IControllerConstructor =
     | (new (...args: any[]) => IController) // Instead of classes, plain functions are often used as controller constructors, especially in examples.
     | ((...args: any[]) => void | IController);
@@ -2267,22 +1403,6 @@ declare namespace angular {
     $onInit(): void;
   }
 
-  /**
-   * Interface for the $doCheck lifecycle hook
-   * https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks
-   */
-  interface IDoCheck {
-    /**
-     * Called on each turn of the digest cycle. Provides an opportunity to detect and act on changes.
-     * Any actions that you wish to take in response to the changes that you detect must be invoked from this hook;
-     * implementing this has no effect on when `$onChanges` is called. For example, this hook could be useful if you wish
-     * to perform a deep equality check, or to check a `Dat`e object, changes to which would not be detected by Angular's
-     * change detector and thus not trigger `$onChanges`. This hook is invoked with no arguments; if detecting changes,
-     * you must store the previous value(s) for comparison to the current values.
-     */
-    $doCheck(): void;
-  }
-
   /**
    * Interface for the $onChanges lifecycle hook
    * https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks
@@ -2456,21 +1576,6 @@ declare namespace angular {
     transclude?: boolean | "element" | { [slot: string]: string } | undefined;
   }
 
-  /**
-   * These interfaces are kept for compatibility with older versions of these type definitions.
-   * Actually, Angular doesn't create a special subclass of jQuery objects. It extends jQuery.prototype
-   * like jQuery plugins do, that's why all jQuery objects have these Angular-specific methods, not
-   * only those returned from angular.element.
-   * See: http://docs.angularjs.org/api/angular.element
-   */
-  interface IAugmentedJQueryStatic extends JQueryStatic {}
-  interface IAugmentedJQuery extends JQLite {}
-
-  /**
-   * Same as IController. Keeping it for compatibility with older versions of these type definitions.
-   */
-  interface IComponentController extends IController {}
-
   ///////////////////////////////////////////////////////////////////////////
   // AUTO module (angular.js)
   ///////////////////////////////////////////////////////////////////////////
@@ -2484,32 +1589,23 @@ declare namespace angular {
       annotate(inlineAnnotatedFunction: any[]): string[];
       get<T>(name: string, caller?: string): T;
       get(name: "$anchorScroll"): IAnchorScrollService;
-      get(name: "$cacheFactory"): ICacheFactoryService;
       get(name: "$compile"): ICompileService;
       get(name: "$controller"): IControllerService;
-      get(name: "$document"): IDocumentService;
       get(name: "$exceptionHandler"): IExceptionHandlerService;
       get(name: "$filter"): IFilterService;
       get(name: "$http"): IHttpService;
-      get(name: "$httpBackend"): IHttpBackendService;
       get(name: "$httpParamSerializer"): IHttpParamSerializer;
-      get(name: "$httpParamSerializerJQLike"): IHttpParamSerializer;
       get(name: "$interpolate"): IInterpolateService;
-      get(name: "$interval"): IIntervalService;
       get(name: "$locale"): ILocaleService;
       get(name: "$location"): ILocationService;
       get(name: "$log"): ILogService;
       get(name: "$parse"): IParseService;
-      get(name: "$q"): IQService;
       get(name: "$rootElement"): IRootElementService;
       get(name: "$rootScope"): IRootScopeService;
       get(name: "$sce"): ISCEService;
       get(name: "$sceDelegate"): ISCEDelegateService;
       get(name: "$templateCache"): ITemplateCacheService;
       get(name: "$templateRequest"): ITemplateRequestService;
-      get(name: "$timeout"): ITimeoutService;
-      get(name: "$window"): IWindowService;
-      get<T>(name: "$xhrFactory"): IXhrFactory<T>;
       has(name: string): boolean;
       instantiate<T>(
         typeConstructor: { new (...args: any[]): T },
@@ -2579,21 +1675,4 @@ declare namespace angular {
       value(name: string, value: any): IServiceProvider;
     }
   }
-
-  /**
-   * $http params serializer that converts objects to strings
-   * see https://docs.angularjs.org/api/ng/service/$httpParamSerializer
-   */
-  interface IHttpParamSerializer {
-    (obj: Object): string;
-  }
-
-  interface IFilterFunction extends Function {
-    /**
-     * By default, filters are only run once the input value changes. By marking the filter as `$stateful`, the filter will be run on every `$digest` to update the output. **This is strongly discouraged.**
-     * See https://docs.angularjs.org/guide/filter#stateful-filters
-     */
-    $stateful?: boolean | undefined;
-  }
-  type FilterFactory = (...I: any[]) => IFilterFunction;
 }