@angular-wave/angular.ts 0.1.1 → 0.1.2

package/types/core/compile/attributes.d.ts

@@ -22,11 +22,6 @@ export class Attributes {
     $attr: {};
     $$element: import("../../shared/jqlite/jqlite").JQLite;
     /**
-     * @ngdoc method
-     * @name $compile.directive.Attributes#$normalize
-     * @kind function
-     *
-     * @description
      * Converts an attribute name (e.g. dash/colon/underscore-delimited string, optionally prefixed with `x-` or
      * `data-`) to its normalized, camelCase form.
      *
@@ -38,11 +33,6 @@ export class Attributes {
      */
     $normalize: typeof directiveNormalize;
     /**
-     * @ngdoc method
-     * @name $compile.directive.Attributes#$addClass
-     * @kind function
-     *
-     * @description
      * Adds the CSS class value specified by the classVal parameter to the element. If animations
      * are enabled then an animation will be triggered for the class addition.
      *
@@ -50,11 +40,6 @@ export class Attributes {
      */
     $addClass(classVal: string): void;
     /**
-     * @ngdoc method
-     * @name $compile.directive.Attributes#$removeClass
-     * @kind function
-     *
-     * @description
      * Removes the CSS class value specified by the classVal parameter from the element. If
      * animations are enabled then an animation will be triggered for the class removal.
      *
@@ -62,11 +47,6 @@ export class Attributes {
      */
     $removeClass(classVal: string): void;
     /**
-     * @ngdoc method
-     * @name $compile.directive.Attributes#$updateClass
-     * @kind function
-     *
-     * @description
      * Adds and removes the appropriate CSS class values to the element based on the difference
      * between the new and old CSS class values (specified as newClasses and oldClasses).
      *

package/types/core/compile/compile.d.ts

@@ -58,11 +58,6 @@ export class $CompileProvider {
      */
     component: (name: string | any, options: any) => $CompileProvider;
     /**
-     * @ngdoc method
-     * @name $compileProvider#aHrefSanitizationTrustedUrlList
-     * @kind function
-     *
-     * @description
      * Retrieves or overrides the default regular expression that is used for determining trusted safe
      * urls during a[href] sanitization.
      *

package/types/core/controller/controller.d.ts

@@ -9,14 +9,10 @@ export function identifierForController(controller: any, ident: any): any;
 export function $ControllerProvider(): void;
 export class $ControllerProvider {
     /**
-     * @ngdoc method
-     * @name $controllerProvider#has
      * @param {string} name Controller name to check.
      */
     has: (name: string) => any;
     /**
-     * @ngdoc method
-     * @name $controllerProvider#register
      * @param {string|Object} name Controller name, or an object map of controllers where the keys are
      *    the names and the values are the constructors.
      * @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI

package/types/core/exception-handler.d.ts

@@ -4,7 +4,7 @@
  */
 export function $ExceptionHandlerProvider(this: any): void;
 export class $ExceptionHandlerProvider {
-    $get: (string | (($log: any) => ErrorHandler))[];
+    $get: (string | (($log: import("../services/log").LogService) => ErrorHandler))[];
 }
 export function errorHandler(exception: any, cause: any): void;
 export type ExceptionHandlerProvider = import("../types").ServiceProvider;

package/types/core/interpolate/interpolate.d.ts

@@ -29,9 +29,6 @@ export class $InterpolateProvider {
     $get: (string | (($parse: import("../parser/parse").ParseService, $exceptionHandler: import("../exception-handler").ErrorHandler, $sce: any) => {
         (text: string, mustHaveExpression?: boolean | undefined, trustedContext?: string | undefined, allOrNothing?: boolean | undefined): Function;
         /**
-         * @ngdoc method
-         * @name $interpolate#startSymbol
-         * @description
          * Symbol to denote the start of expression in the interpolated string. Defaults to `{{`.
          *
          * Use {@link ng.$interpolateProvider#startSymbol `$interpolateProvider.startSymbol`} to change
@@ -41,9 +38,6 @@ export class $InterpolateProvider {
          */
         startSymbol(): string;
         /**
-         * @ngdoc method
-         * @name $interpolate#endSymbol
-         * @description
          * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
          *
          * Use {@link ng.$interpolateProvider#endSymbol `$interpolateProvider.endSymbol`} to change

package/types/core/q/q.d.ts

@@ -30,11 +30,6 @@ export function $QProvider(): void;
 export class $QProvider {
     $get: (string | (($rootScope: import("../scope/scope").Scope, $exceptionHandler: import("../exception-handler").ErrorHandler) => any))[];
     /**
-     * @ngdoc method
-     * @name $qProvider#errorOnUnhandledRejections
-     * @kind function
-     *
-     * @description
      * Retrieves or overrides whether to generate an error when a rejected promise is not handled.
      * This feature is enabled by default.
      *

package/types/core/sce/sce.d.ts

@@ -1,12 +1,6 @@
 export function escapeForRegexp(s: any): any;
 export function adjustMatcher(matcher: any): any;
 /**
- * @ngdoc service
- * @name $sceDelegate
- * @kind function
- *
- * @description
- *
  * `$sceDelegate` is a service that is used by the `$sce` service to provide {@link ng.$sce Strict
  * Contextual Escaping (SCE)} services to AngularJS.
  *
@@ -37,11 +31,6 @@ export function adjustMatcher(matcher: any): any;
  * ng.$sceDelegateProvider#bannedResourceUrlList $sceDelegateProvider.bannedResourceUrlList}
  */
 /**
- * @ngdoc provider
- * @name $sceDelegateProvider
- *
- *
- * @description
  *
  * The `$sceDelegateProvider` provider allows developers to configure the {@link ng.$sceDelegate
  * $sceDelegate service}, used as a delegate for {@link ng.$sce Strict Contextual Escaping (SCE)}.
@@ -100,9 +89,6 @@ export class $SceDelegateProvider {
         JS: string;
     };
     /**
-     * @ngdoc method
-     * @name $sceDelegateProvider#trustedResourceUrlList
-     * @kind function
      *
      * @param {Array=} trustedResourceUrlList When provided, replaces the trustedResourceUrlList with
      *     the value provided.  This must be an array or null.  A snapshot of this array is used so
@@ -125,9 +111,6 @@ export class $SceDelegateProvider {
      */
     trustedResourceUrlList: (value: any, ...args: any[]) => any[];
     /**
-     * @ngdoc method
-     * @name $sceDelegateProvider#bannedResourceUrlList
-     * @kind function
      *
      * @param {Array=} bannedResourceUrlList When provided, replaces the `bannedResourceUrlList` with
      *     the value provided. This must be an array or null. A snapshot of this array is used so
@@ -156,257 +139,9 @@ export class $SceDelegateProvider {
         valueOf: (maybeTrusted: any) => any;
     }))[];
 }
-/**
- * @ngdoc provider
- * @name $sceProvider
- *
- *
- * @description
- *
- * The $sceProvider provider allows developers to configure the {@link ng.$sce $sce} service.
- * -   enable/disable Strict Contextual Escaping (SCE) in a module
- * -   override the default implementation with a custom delegate
- *
- * Read more about {@link ng.$sce Strict Contextual Escaping (SCE)}.
- */
-/**
- * @ngdoc service
- * @name $sce
- * @kind function
- *
- * @description
- *
- * `$sce` is a service that provides Strict Contextual Escaping services to AngularJS.
- *
- * ## Strict Contextual Escaping
- *
- * Strict Contextual Escaping (SCE) is a mode in which AngularJS constrains bindings to only render
- * trusted values. Its goal is to assist in writing code in a way that (a) is secure by default, and
- * (b) makes auditing for security vulnerabilities such as XSS, clickjacking, etc. a lot easier.
- *
- * ### Overview
- *
- * To systematically block XSS security bugs, AngularJS treats all values as untrusted by default in
- * HTML or sensitive URL bindings. When binding untrusted values, AngularJS will automatically
- * run security checks on them (sanitizations, trusted URL resource, depending on context), or throw
- * when it cannot guarantee the security of the result. That behavior depends strongly on contexts:
- * HTML can be sanitized, but template URLs cannot, for instance.
- *
- * To illustrate this, consider the `ng-bind-html` directive. It renders its value directly as HTML:
- * we call that the *context*. When given an untrusted input, AngularJS will attempt to sanitize it
- * before rendering if a sanitizer is available, and throw otherwise. To bypass sanitization and
- * render the input as-is, you will need to mark it as trusted for that context before attempting
- * to bind it.
- *
- * As of version 1.2, AngularJS ships with SCE enabled by default.
- *
- * ### In practice
- *
- * Here's an example of a binding in a privileged context:
- *
- * ```
- * <input ng-model="userHtml" aria-label="User input">
- * <div ng-bind-html="userHtml"></div>
- * ```
- *
- * Notice that `ng-bind-html` is bound to `userHtml` controlled by the user.  With SCE
- * disabled, this application allows the user to render arbitrary HTML into the DIV, which would
- * be an XSS security bug. In a more realistic example, one may be rendering user comments, blog
- * articles, etc. via bindings. (HTML is just one example of a context where rendering user
- * controlled input creates security vulnerabilities.)
- *
- * For the case of HTML, you might use a library, either on the client side, or on the server side,
- * to sanitize unsafe HTML before binding to the value and rendering it in the document.
- *
- * How would you ensure that every place that used these types of bindings was bound to a value that
- * was sanitized by your library (or returned as safe for rendering by your server?)  How can you
- * ensure that you didn't accidentally delete the line that sanitized the value, or renamed some
- * properties/fields and forgot to update the binding to the sanitized value?
- *
- * To be secure by default, AngularJS makes sure bindings go through that sanitization, or
- * any similar validation process, unless there's a good reason to trust the given value in this
- * context.  That trust is formalized with a function call. This means that as a developer, you
- * can assume all untrusted bindings are safe. Then, to audit your code for binding security issues,
- * you just need to ensure the values you mark as trusted indeed are safe - because they were
- * received from your server, sanitized by your library, etc. You can organize your codebase to
- * help with this - perhaps allowing only the files in a specific directory to do this.
- * Ensuring that the internal API exposed by that code doesn't markup arbitrary values as safe then
- * becomes a more manageable task.
- *
- * In the case of AngularJS' SCE service, one uses {@link ng.$sce#trustAs $sce.trustAs}
- * (and shorthand methods such as {@link ng.$sce#trustAsHtml $sce.trustAsHtml}, etc.) to
- * build the trusted versions of your values.
- *
- * ### How does it work?
- *
- * In privileged contexts, directives and code will bind to the result of {@link ng.$sce#getTrusted
- * $sce.getTrusted(context, value)} rather than to the value directly.  Think of this function as
- * a way to enforce the required security context in your data sink. Directives use {@link
- * ng.$sce#parseAs $sce.parseAs} rather than `$parse` to watch attribute bindings, which performs
- * the {@link ng.$sce#getTrusted $sce.getTrusted} behind the scenes on non-constant literals. Also,
- * when binding without directives, AngularJS will understand the context of your bindings
- * automatically.
- *
- * As an example, {@link ng.directive:ngBindHtml ngBindHtml} uses {@link
- * ng.$sce#parseAsHtml $sce.parseAsHtml(binding expression)}.  Here's the actual code (slightly
- * simplified):
- *
- * ```
- * let ngBindHtmlDirective = ['$sce', function($sce) {
- *   return function(scope, element, attr) {
- *     scope.$watch($sce.parseAsHtml(attr.ngBindHtml), function(value) {
- *       element.html(value || '');
- *     });
- *   };
- * }];
- * ```
- *
- * ### Impact on loading templates
- *
- * This applies both to the {@link ng.directive:ngInclude `ng-include`} directive as well as
- * `templateUrl`'s specified by {@link guide/directive directives}.
- *
- * By default, AngularJS only loads templates from the same domain and protocol as the application
- * document.  This is done by calling {@link ng.$sce#getTrustedResourceUrl
- * $sce.getTrustedResourceUrl} on the template URL.  To load templates from other domains and/or
- * protocols, you may either add them to the {@link ng.$sceDelegateProvider#trustedResourceUrlList
- * trustedResourceUrlList} or {@link ng.$sce#trustAsResourceUrl wrap them} into trusted values.
- *
- * *Please note*:
- * The browser's
- * [Same Origin Policy](https://code.google.com/p/browsersec/wiki/Part2#Same-origin_policy_for_XMLHttpRequest)
- * and [Cross-Origin Resource Sharing (CORS)](http://www.w3.org/TR/cors/)
- * policy apply in addition to this and may further restrict whether the template is successfully
- * loaded.  This means that without the right CORS policy, loading templates from a different domain
- * won't work on all browsers.  Also, loading templates from `file://` URL does not work on some
- * browsers.
- *
- * ### This feels like too much overhead
- *
- * It's important to remember that SCE only applies to interpolation expressions.
- *
- * If your expressions are constant literals, they're automatically trusted and you don't need to
- * call `$sce.trustAs` on them (e.g.
- * `<div ng-bind-html="'<b>implicitly trusted</b>'"></div>`) just works (remember to include the
- * `ngSanitize` module). The `$sceDelegate` will also use the `$sanitize` service if it is available
- * when binding untrusted values to `$sce.HTML` context.
- * AngularJS provides an implementation in `angular-sanitize.js`, and if you
- * wish to use it, you will also need to depend on the {@link ngSanitize `ngSanitize`} module in
- * your application.
- *
- * The included {@link ng.$sceDelegate $sceDelegate} comes with sane defaults to allow you to load
- * templates in `ng-include` from your application's domain without having to even know about SCE.
- * It blocks loading templates from other domains or loading templates over http from an https
- * served document.  You can change these by setting your own custom {@link
- * ng.$sceDelegateProvider#trustedResourceUrlList trusted resource URL list} and {@link
- * ng.$sceDelegateProvider#bannedResourceUrlList banned resource URL list} for matching such URLs.
- *
- * This significantly reduces the overhead.  It is far easier to pay the small overhead and have an
- * application that's secure and can be audited to verify that with much more ease than bolting
- * security onto an application later.
- *
- * <a name="contexts"></a>
- * ### What trusted context types are supported?
- *
- * | Context             | Notes          |
- * |---------------------|----------------|
- * | `$sce.HTML`         | For HTML that's safe to source into the application.  The {@link ng.directive:ngBindHtml ngBindHtml} directive uses this context for bindings. If an unsafe value is encountered and the {@link ngSanitize $sanitize} module is present this will sanitize the value instead of throwing an error. |
- * | `$sce.CSS`          | For CSS that's safe to source into the application.  Currently unused.  Feel free to use it in your own directives. |
- * | `$sce.MEDIA_URL`    | For URLs that are safe to render as media. Is automatically converted from string by sanitizing when needed. |
- * | `$sce.URL`          | For URLs that are safe to follow as links. Is automatically converted from string by sanitizing when needed. Note that `$sce.URL` makes a stronger statement about the URL than `$sce.MEDIA_URL` does and therefore contexts requiring values trusted for `$sce.URL` can be used anywhere that values trusted for `$sce.MEDIA_URL` are required.|
- * | `$sce.RESOURCE_URL` | For URLs that are not only safe to follow as links, but whose contents are also safe to include in your application.  Examples include `ng-include`, `src` / `ngSrc` bindings for tags other than `IMG` (e.g. `IFRAME`, `OBJECT`, etc.)  <br><br>Note that `$sce.RESOURCE_URL` makes a stronger statement about the URL than `$sce.URL` or `$sce.MEDIA_URL` do and therefore contexts requiring values trusted for `$sce.RESOURCE_URL` can be used anywhere that values trusted for `$sce.URL` or `$sce.MEDIA_URL` are required. <br><br> The {@link $sceDelegateProvider#trustedResourceUrlList $sceDelegateProvider#trustedResourceUrlList()} and {@link $sceDelegateProvider#bannedResourceUrlList $sceDelegateProvider#bannedResourceUrlList()} can be used to restrict trusted origins for `RESOURCE_URL` |
- * | `$sce.JS`           | For JavaScript that is safe to execute in your application's context.  Currently unused.  Feel free to use it in your own directives. |
- *
- *
- * <div class="alert alert-warning">
- * Be aware that, before AngularJS 1.7.0, `a[href]` and `img[src]` used to sanitize their
- * interpolated values directly rather than rely upon {@link ng.$sce#getTrusted `$sce.getTrusted`}.
- *
- * **As of 1.7.0, this is no longer the case.**
- *
- * Now such interpolations are marked as requiring `$sce.URL` (for `a[href]`) or `$sce.MEDIA_URL`
- * (for `img[src]`), so that the sanitization happens (via `$sce.getTrusted...`) when the `$interpolate`
- * service evaluates the expressions.
- * </div>
- *
- * There are no CSS or JS context bindings in AngularJS currently, so their corresponding `$sce.trustAs`
- * functions aren't useful yet. This might evolve.
- *
- * ### Format of items in {@link ng.$sceDelegateProvider#trustedResourceUrlList trustedResourceUrlList}/{@link ng.$sceDelegateProvider#bannedResourceUrlList bannedResourceUrlList} <a name="resourceUrlPatternItem"></a>
- *
- *  Each element in these arrays must be one of the following:
- *
- *  - **'self'**
- *    - The special **string**, `'self'`, can be used to match against all URLs of the **same
- *      domain** as the application document using the **same protocol**.
- *  - **String** (except the special value `'self'`)
- *    - The string is matched against the full *normalized / absolute URL* of the resource
- *      being tested (substring matches are not good enough.)
- *    - There are exactly **two wildcard sequences** - `*` and `**`.  All other characters
- *      match themselves.
- *    - `*`: matches zero or more occurrences of any character other than one of the following 6
- *      characters: '`:`', '`/`', '`.`', '`?`', '`&`' and '`;`'.  It's a useful wildcard for use
- *      for matching resource URL lists.
- *    - `**`: matches zero or more occurrences of *any* character.  As such, it's not
- *      appropriate for use in a scheme, domain, etc. as it would match too much.  (e.g.
- *      http://**.example.com/ would match http://evil.com/?ignore=.example.com/ and that might
- *      not have been the intention.)  Its usage at the very end of the path is ok.  (e.g.
- *      http://foo.example.com/templates/**).
- *  - **RegExp** (*see caveat below*)
- *    - *Caveat*:  While regular expressions are powerful and offer great flexibility,  their syntax
- *      (and all the inevitable escaping) makes them *harder to maintain*.  It's easy to
- *      accidentally introduce a bug when one updates a complex expression (imho, all regexes should
- *      have good test coverage).  For instance, the use of `.` in the regex is correct only in a
- *      small number of cases.  A `.` character in the regex used when matching the scheme or a
- *      subdomain could be matched against a `:` or literal `.` that was likely not intended.   It
- *      is highly recommended to use the string patterns and only fall back to regular expressions
- *      as a last resort.
- *    - The regular expression must be an instance of RegExp (i.e. not a string.)  It is
- *      matched against the **entire** *normalized / absolute URL* of the resource being tested
- *      (even when the RegExp did not have the `^` and `$` codes.)  In addition, any flags
- *      present on the RegExp (such as multiline, global, ignoreCase) are ignored.
- *    - If you are generating your JavaScript from some other templating engine (not
- *      recommended, e.g. in issue [#4006](https://github.com/angular/angular.js/issues/4006)),
- *      remember to escape your regular expression (and be aware that you might need more than
- *      one level of escaping depending on your templating engine and the way you interpolated
- *      the value.)  Do make use of your platform's escaping mechanism as it might be good
- *      enough before coding your own.  E.g. Ruby has
- *      [Regexp.escape(str)](http://www.ruby-doc.org/core-2.0.0/Regexp.html#method-c-escape)
- *      and Python has [re.escape](http://docs.python.org/library/re.html#re.escape).
- *      Javascript lacks a similar built in function for escaping.  Take a look at Google
- *      Closure library's [goog.string.regExpEscape(s)](
- *      http://docs.closure-library.googlecode.com/git/closure_goog_string_string.js.source.html#line962).
- *
- * Refer {@link ng.$sceDelegateProvider $sceDelegateProvider} for an example.
- *
- *
- * ## Can I disable SCE completely?
- *
- * Yes, you can.  However, this is strongly discouraged.  SCE gives you a lot of security benefits
- * for little coding overhead.  It will be much harder to take an SCE disabled application and
- * either secure it on your own or enable SCE at a later stage.  It might make sense to disable SCE
- * for cases where you have a lot of existing code that was written before SCE was introduced and
- * you're migrating them a module at a time. Also do note that this is an app-wide setting, so if
- * you are writing a library, you will cause security bugs applications using it.
- *
- * That said, here's how you can completely disable SCE:
- *
- * ```
- * angular.module('myAppWithSceDisabledmyApp', []).config(function($sceProvider) {
- *   // Completely disable SCE.  For demonstration purposes only!
- *   // Do not use in new projects or libraries.
- *   $sceProvider.enabled(false);
- * });
- * ```
- *
- */
 export function $SceProvider(): void;
 export class $SceProvider {
     /**
-     * @ngdoc method
-     * @name $sceProvider#enabled
-     * @kind function
-     *
      * @param {boolean=} value If provided, then enables/disables SCE application-wide.
      * @return {boolean} True if SCE is enabled, false otherwise.
      *

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

@@ -179,11 +179,6 @@ export class 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
@@ -291,11 +286,6 @@ export class Scope {
    */
     $watch(watchExp: string | ((scope: Scope) => any) | import("../parser/parse").CompiledExpression, listener?: WatchListener, 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.
      *
@@ -317,11 +307,6 @@ export class Scope {
      */
     $watchGroup(watchExpressions: Array<string | ((Scope: any) => 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.
@@ -352,11 +337,6 @@ export class Scope {
      */
     $watchCollection(obj: string | ((arg0: Scope) => any), listener: (arg0: any[], arg1: any[], 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}
@@ -408,11 +388,6 @@ export class Scope {
      */
     beginPhase(phase: ScopePhase): void;
     /**
-     * @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
@@ -452,11 +427,7 @@ export class 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,
@@ -478,33 +449,18 @@ export class Scope {
      */
     $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
@@ -523,11 +479,6 @@ export class Scope {
      */
     $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
@@ -568,11 +519,6 @@ export class Scope {
    */
     $apply(expr?: string | ((arg0: Scope) => any)): 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.
      *
@@ -586,11 +532,6 @@ export class Scope {
      */
     $applyAsync(expr?: (string | (() => any)) | undefined): void;
     /**
-     * @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
@@ -641,11 +582,6 @@ export class Scope {
      */
     $on(name: string, listener: (arg0: any) => 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.
@@ -685,11 +621,6 @@ export class Scope {
      */
     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.
      *
@@ -708,11 +639,6 @@ export class Scope {
      */
     $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.
      *

package/types/core/task-tracker-factory.d.ts

@@ -1,6 +1,6 @@
 export function $$TaskTrackerFactoryProvider(): void;
 export class $$TaskTrackerFactoryProvider {
-    $get: (string | ((log: any) => TaskTracker))[];
+    $get: (string | ((log: import("../services/log").LogService) => TaskTracker))[];
 }
 /**
  * ! This is a private undocumented service !
@@ -13,7 +13,7 @@ export class $$TaskTrackerFactoryProvider {
  * parties when all pending tasks (or tasks of a specific type) have been completed.
  * @param {import('../services/log').LogService} log
  */
-export function TaskTracker(log: any): void;
+export function TaskTracker(log: import("../services/log").LogService): void;
 export class TaskTracker {
     /**
      * ! This is a private undocumented service !
@@ -26,7 +26,7 @@ export class TaskTracker {
      * parties when all pending tasks (or tasks of a specific type) have been completed.
      * @param {import('../services/log').LogService} log
      */
-    constructor(log: any);
+    constructor(log: import("../services/log").LogService);
     ALL_TASKS_TYPE: string;
     DEFAULT_TASK_TYPE: string;
     /**

package/types/core/url-utils/url-utils.d.ts

@@ -1,50 +1,4 @@
-/**
- *
- * Implementation Notes for non-IE browsers
- * ----------------------------------------
- * Assigning a URL to the href property of an anchor DOM node, even one attached to the DOM,
- * results both in the normalizing and parsing of the URL.  Normalizing means that a relative
- * URL will be resolved into an absolute URL in the context of the application document.
- * Parsing means that the anchor node's host, hostname, protocol, port, pathname and related
- * properties are all populated to reflect the normalized URL.  This approach has wide
- * compatibility - Safari 1+, Mozilla 1+ etc.  See
- * http://www.aptana.com/reference/html/api/HTMLAnchorElement.html
- *
- * Implementation Notes for IE
- * ---------------------------
- * IE <= 10 normalizes the URL when assigned to the anchor node similar to the other
- * browsers.  However, the parsed components will not be set if the URL assigned did not specify
- * them.  (e.g. if you assign a.href = "foo", then a.protocol, a.host, etc. will be empty.)  We
- * work around that by performing the parsing in a 2nd step by taking a previously normalized
- * URL (e.g. by assigning to a.href) and assigning it a.href again.  This correctly populates the
- * properties such as protocol, hostname, port, etc.
- *
- * References:
- *   http://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement
- *   http://www.aptana.com/reference/html/api/HTMLAnchorElement.html
- *   http://url.spec.whatwg.org/#urlutils
- *   https://github.com/angular/angular.js/pull/2902
- *   http://james.padolsey.com/javascript/parsing-urls-with-the-dom/
- *
- * @kind function
- * @param {string|object} url The URL to be parsed. If `url` is not a string, it will be returned
- *     unchanged.
- * @description Normalizes and parses a URL.
- * @returns {object} Returns the normalized URL as a dictionary.
- *
- *   | member name   | Description                                                            |
- *   |---------------|------------------------------------------------------------------------|
- *   | href          | A normalized version of the provided URL if it was not an absolute URL |
- *   | protocol      | The protocol without the trailing colon                                |
- *   | host          | The host and port (if the port is non-default) of the normalizedUrl    |
- *   | search        | The search params, minus the question mark                             |
- *   | hash          | The hash string, minus the hash symbol                                 |
- *   | hostname      | The hostname                                                           |
- *   | port          | The port, without ":"                                                  |
- *   | pathname      | The pathname, beginning with "/"                                       |
- *
- */
-export function urlResolve(url: string | object): object;
+export function urlResolve(url: any): any;
 /**
  * Parse a request URL and determine whether this is a same-origin request as the application
  * document.