@angular-wave/angular.ts 0.0.70 → 0.0.72

package/src/public.js

@@ -53,16 +53,12 @@ import { ngModelOptionsDirective } from "./directive/model-options/model-options
 import { ngAttributeAliasDirectives } from "./directive/attrs/attrs";
 import { ngEventDirectives } from "./directive/events/events";
 import { AnchorScrollProvider } from "./services/anchor-scroll";
-import {
-  AnimateProvider,
-  CoreAnimateQueueProvider,
-} from "./core/animate/animate";
+import { AnimateProvider } from "./animations/animate";
 import { BrowserProvider } from "./services/browser";
-import { CoreAnimateCssProvider } from "./core/animate/animate-css";
 import {
   AnimateAsyncRunFactoryProvider,
   AnimateRunnerFactoryProvider,
-} from "./core/animate/animate-runner";
+} from "./animations/animate-runner";
 import {
   CacheFactoryProvider,
   TemplateCacheProvider,
@@ -89,7 +85,6 @@ import { $$TaskTrackerFactoryProvider } from "./core/task-tracker-factory";
 import { TemplateRequestProvider } from "./services/template-request";
 import { $TimeoutProvider } from "./core/timeout/timeout";
 import { SanitizeUriProvider } from "./core/sanitize/sanitize-uri";
-import { initAnimateModule } from "./animations/module";
 import {
   ngMessageDefaultDirective,
   ngMessageDirective,
@@ -112,6 +107,16 @@ import {
   ngShowAriaDirective,
   ngValueAriaDirective,
 } from "./directive/aria/aria";
+import { $AnimateCssProvider } from "./animations/animate-css";
+import { $$AnimateQueueProvider } from "./animations/animate-queue";
+import { $$AnimateJsProvider } from "./animations/animate-js";
+import { $$AnimationProvider } from "./animations/animation";
+import { RafSchedulerProvider } from "./animations/raf-scheduler";
+import { $$AnimateCacheProvider } from "./animations/animate-cache";
+import { $$AnimateCssDriverProvider } from "./animations/animate-css-driver";
+import { $$AnimateJsDriverProvider } from "./animations/animate-js-driver";
+import { ngAnimateSwapDirective } from "./animations/animate-swap";
+import { $$AnimateChildrenDirective } from "./animations/animate-children-directive";
 
 /**
  * @type {string} `version` from `package.json`, injected by Rollup plugin
@@ -190,6 +195,8 @@ export function publishExternalAPI(angular) {
             })
             .directive({
               input: hiddenInputBrowserCacheDirective,
+              ngAnimateSwap: ngAnimateSwapDirective,
+              ngAnimateChildren: $$AnimateChildrenDirective,
               ngChecked: ngCheckedAriaDirective,
               ngClick: ngClickAriaDirective,
               ngDblclick: ngDblclickAriaDirective,
@@ -208,8 +215,13 @@ export function publishExternalAPI(angular) {
             $aria: AriaProvider,
             $anchorScroll: AnchorScrollProvider,
             $animate: AnimateProvider,
-            $animateCss: CoreAnimateCssProvider,
-            $$animateQueue: CoreAnimateQueueProvider,
+            $$animation: $$AnimationProvider,
+            $animateCss: $AnimateCssProvider,
+            $$animateCssDriver: $$AnimateCssDriverProvider,
+            $$animateJs: $$AnimateJsProvider,
+            $$animateJsDriver: $$AnimateJsDriverProvider,
+            $$animateCache: $$AnimateCacheProvider,
+            $$animateQueue: $$AnimateQueueProvider,
             $$AnimateRunner: AnimateRunnerFactoryProvider,
             $$animateAsyncRun: AnimateAsyncRunFactoryProvider,
             $browser: BrowserProvider,
@@ -227,6 +239,7 @@ export function publishExternalAPI(angular) {
             $location: $LocationProvider,
             $log: $LogProvider,
             $parse: $ParseProvider,
+            $$rAFScheduler: RafSchedulerProvider,
             $rootScope: $RootScopeProvider,
             $q: $QProvider,
             $$q: $$QProvider,
@@ -242,7 +255,6 @@ export function publishExternalAPI(angular) {
     )
     .info({ version: VERSION });
 
-  initAnimateModule(angular);
   initRouter(angular);
   return ng;
 }

package/src/router/state/state-object.js

@@ -22,12 +22,10 @@ export class StateObject {
    * @returns {StateObject} an internal State object
    */
   static create(stateDecl) {
-    const state = StateObject.isStateClass(stateDecl)
-      ? new stateDecl()
-      : Object.setPrototypeOf(
-          Object.assign({}, stateDecl),
-          StateObject.prototype,
-        );
+    const state = Object.setPrototypeOf(
+      Object.assign({}, stateDecl),
+      StateObject.prototype,
+    );
     stateDecl.$$state = () => state;
     state.self = stateDecl;
     state.__stateObjectCache = {
@@ -110,9 +108,6 @@ export class StateObject {
     return this.fqn();
   }
 }
-/** Predicate which returns true if the object is an class with @State() decorator */
-StateObject.isStateClass = (stateDecl) =>
-  isFunction(stateDecl) && stateDecl["__uiRouterState"] === true;
 /** Predicate which returns true if the object is a [[StateDeclaration]] object */
 StateObject.isStateDeclaration = (obj) => isFunction(obj["$$state"]);
 /** Predicate which returns true if the object is an internal [[StateObject]] object */

package/src/router/url/url-matcher.js

@@ -406,7 +406,7 @@ export class UrlMatcher {
    *
    * @param id
    * @param opts
-   * @returns {T|Param|any|boolean|UrlMatcher|null}
+   * @returns {Param|any|boolean|UrlMatcher|null}
    */
   parameter(id, opts = {}) {
     const findParam = () => {

package/src/router/url/url-rule.js

@@ -203,7 +203,11 @@ export class BaseUrlRule {
     this.match = match;
     this.type = "RAW";
     this.$id = -1;
-    this.matchPriority = () => 0 - this.$id;
+    this._group = undefined;
     this.handler = handler || ((x) => x);
   }
+
+  matchPriority() {
+    return 0 - this.$id;
+  }
 }

package/src/router/url/url-service.js

@@ -356,7 +356,7 @@ export class UrlService {
       return;
     }
     if (this.url() === this.location) return;
-    this.url(this.location, true);
+    this.url(/** @type {string} */ (this.location), true);
   }
 
   /**

package/src/services/anchor-scroll.html

@@ -9,7 +9,7 @@
     <!--     
     <script src="https://cdn.jsdelivr.net/npm/angular@1.8.3/angular.js"></script>
     <script src="https://cdn.jsdelivr.net/npm/angular-animate@1.8.3/angular-animate.js"></script>
-    <script>window.angular.module("test", ["ngAnimate"])</script> -->
+    <script>window.angular.module("test", [])</script> -->
 
     <script type="module" src="/src/index.js"></script>
     <script>

package/src/shared/jqlite/jqlite.js

@@ -62,7 +62,7 @@ const BOOLEAN_ELEMENTS = {};
  * JQLite both a function and an array-like data structure for manipulation of DOM, linking elements to expando cache,
  * and execution of chain functions.
  *
- * @param {string|Node|JQLite|ArrayLike<Element>|(() => void)|Window} element
+ * @param {string|Node|Node[]|NodeList|JQLite|ArrayLike<Element>|(() => void)|Window} element
  * @returns {JQLite}
  */
 export function JQLite(element) {
@@ -116,6 +116,18 @@ JQLite.prototype = {
   length: 0,
 };
 
+/**
+ * @returns {Element[]}
+ */
+JQLite.prototype.elements = function () {
+  /** @type {Element[]} */
+  let elements = [];
+  for (let index = 0; index < this.length; index++) {
+    elements.push(this[index]);
+  }
+  return elements;
+};
+
 /**
  * Remove all child nodes of the set of matched elements from the DOM and clears CACHE data, associated with the node.
  * @returns {JQLite} The current instance of JQLite.
@@ -233,7 +245,7 @@ JQLite.prototype.on = function (type, fn) {
  * Removes an event listener to each element in JQLite collection.
  *
  * @param {string} type - The event type(s) to remove listener from
- * @param {Function} fn - The function to remove from event type.
+ * @param {Function} [fn] - The function to remove from event type.
  * @returns {JQLite}
  */
 JQLite.prototype.off = function (type, fn) {

package/src/types.js

@@ -217,7 +217,7 @@
 /**
 
  *
- * @typedef {function(TScope, CloneAttachFunction, import('./shared/jqlite/jqlite').JQLite=, string=): import('./shared/jqlite/jqlite').JQLite} TranscludeFunction
+ * @typedef {function(TScope|Function, CloneAttachFunction=, import('./shared/jqlite/jqlite').JQLite=, string=): import('./shared/jqlite/jqlite').JQLite} TranscludeFunction
  */
 
 /**

package/types/animations/animate-css-driver.d.ts

@@ -4,7 +4,7 @@ export class $$AnimateCssDriverProvider {
     /**
      * @returns {Function}
      */
-    $get: (string | (($animateCss: any, $$AnimateRunner: typeof import("../core/animate/animate-runner").AnimateRunner, $rootElement: JQLite) => (animationDetails: any) => any))[];
+    $get: (string | (($animateCss: any, $$AnimateRunner: typeof import("./animate-runner").AnimateRunner, $rootElement: JQLite) => (animationDetails: any) => any))[];
 }
 export namespace $$AnimateCssDriverProvider {
     let $inject: string[];

package/types/animations/animate-queue.d.ts

@@ -6,7 +6,7 @@ export class $$AnimateQueueProvider {
         cancel: any[];
         join: any[];
     };
-    $get: (string | (($rootScope: any, $rootElement: JQLite, $$animation: any, $$AnimateRunner: any, $templateRequest: any) => {
+    $get: (string | (($rootScope: any, $injector: any, $$animation: any, $$AnimateRunner: any, $templateRequest: any) => {
         on(event: any, container: any, callback: any): void;
         off(event: any, container: any, callback: any, ...args: any[]): void;
         pin(element: any, parentElement: any): void;
@@ -17,4 +17,3 @@ export class $$AnimateQueueProvider {
 export namespace $$AnimateQueueProvider {
     let $inject: string[];
 }
-import { JQLite } from "../shared/jqlite/jqlite";

package/types/{core/animate → animations}/animate.d.ts

@@ -1,13 +1,3 @@
-export function CoreAnimateQueueProvider(): void;
-export class CoreAnimateQueueProvider {
-    $get: (string | (($$AnimateRunner: any, $rootScope: any) => {
-        enabled: () => void;
-        on: () => void;
-        off: () => void;
-        pin: () => void;
-        push(element: any, event: any, options: any, domOperation: any): any;
-    }))[];
-}
 export function domInsert(element: any, parentElement: any, afterElement: any): void;
 export function AnimateProvider($provide: any): void;
 export class AnimateProvider {
@@ -241,7 +231,7 @@ export class AnimateProvider {
        * @example
         <example module="animationExample" deps="angular-animate.js" animations="true" name="animate-cancel">
           <file name="app.js">
-            angular.module('animationExample', ['ngAnimate']).component('cancelExample', {
+            angular.module('animationExample', []).component('cancelExample', {
               templateUrl: 'template.html',
               controller: function($element, $animate) {
                 this.runner = null;
@@ -427,4 +417,4 @@ export type AnimationOptions = {
      */
     to: string;
 };
-import { JQLite } from "../../shared/jqlite/jqlite";
+import { JQLite } from "../shared/jqlite/jqlite";

package/types/animations/raf-scheduler.d.ts

@@ -6,9 +6,14 @@
  */
 /**
  * Creates a requestAnimationFrame scheduler.
- * @returns {RafScheduler} The scheduler object.
  */
-export function $$rAFSchedulerFactory(): RafScheduler;
+export function RafSchedulerProvider(): void;
+export class RafSchedulerProvider {
+    /**
+     * @returns {RafScheduler} The scheduler object.
+     */
+    $get: () => RafScheduler;
+}
 export type RafSchedulerFunction = Function;
 export type RafSchedulerObject = {
     /**

package/types/animations/shared.d.ts

@@ -6,12 +6,17 @@ export function packageStyles(options: any): {
 };
 export function pendClasses(classes: any, fix: any, isPrefix: any): string;
 export function removeFromArray(arr: any, val: any): void;
-export function stripCommentsFromElement(element: any): JQLite | {
-    toString(): string;
-    eq(index: any): JQLite;
-    length: number;
-};
-export function extractElementNode(element: any): any;
+/**
+ *
+ * @param {JQLite|Node} element
+ * @returns {JQLite}
+ */
+export function stripCommentsFromElement(element: JQLite | Node): JQLite;
+/**
+ * @param {JQLite|Node} element
+ * @returns {Node}
+ */
+export function extractElementNode(element: JQLite | Node): Node;
 export function applyAnimationClassesFactory(): (element: any, options: any) => void;
 export function prepareAnimationOptions(options: any): any;
 export function applyAnimationStyles(element: any, options: any): void;

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

@@ -0,0 +1,101 @@
+export class Attributes {
+    /**
+     *
+     * @param {import('../scope/scope').Scope} $rootScope
+     * @param {*} $animate
+     * @param {import("../exception-handler").ExceptionHandlerProvider} $exceptionHandler
+     * @param {*} $sce
+     * @param {import('../../shared/jqlite/jqlite').JQLite} [element]
+     * @param {*} [attributesToCopy]
+     */
+    constructor($rootScope: import("../scope/scope").Scope, $animate: any, $exceptionHandler: import("../exception-handler").ExceptionHandlerProvider, $sce: any, element?: import("../../shared/jqlite/jqlite").JQLite, attributesToCopy?: any);
+    $rootScope: import("../scope/scope").Scope;
+    $animate: any;
+    $exceptionHandler: any;
+    $sce: any;
+    $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.
+     *
+     * Also there is special case for Moz prefix starting with upper case letter.
+     *
+     * For further information check out the guide on {@link guide/directive#matching-directives Matching Directives}
+     *
+     * @param {string} name Name to normalize
+     */
+    $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.
+     *
+     * @param {string} classVal The className value that will be added to the element
+     */
+    $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.
+     *
+     * @param {string} classVal The className value that will be removed from the element
+     */
+    $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).
+     *
+     * @param {string} newClasses The current CSS className value
+     * @param {string} oldClasses The former CSS className value
+     */
+    $updateClass(newClasses: string, oldClasses: string): void;
+    /**
+     * Set a normalized attribute on the element in a way such that all directives
+     * can share the attribute. This function properly handles boolean attributes.
+     * @param {string} key Normalized key. (ie ngAttribute)
+     * @param {string|boolean} value The value to set. If `null` attribute will be deleted.
+     * @param {boolean=} writeAttr If false, does not write the value to DOM element attribute.
+     *     Defaults to true.
+     * @param {string=} attrName Optional none normalized name. Defaults to key.
+     */
+    $set(key: string, value: string | boolean, writeAttr?: boolean | undefined, attrName?: string | undefined): void;
+    /**
+   * Observes an interpolated attribute.
+   *
+   * The observer function will be invoked once during the next `$digest` following
+   * compilation. The observer is then invoked whenever the interpolated value
+   * changes.
+   *
+   * @param {string} key Normalized key. (ie ngAttribute) .
+   * @param {any} fn Function that will be called whenever
+            the interpolated value of the attribute changes.
+   *        See the {@link guide/interpolation#how-text-and-attribute-bindings-work Interpolation
+   *        guide} for more info.
+   * @returns {function()} Returns a deregistration function for this observer.
+   */
+    $observe(key: string, fn: any): () => any;
+    $$observers: any;
+    setSpecialAttr(element: any, attrName: any, value: any): void;
+    sanitizeSrcset(value: any, invokeType: any): any;
+    srcset: any;
+}
+import { directiveNormalize } from "../../shared/utils";

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

@@ -2,11 +2,6 @@ export function $CompileProvider($provide: any, $$sanitizeUriProvider: any): voi
 export class $CompileProvider {
     constructor($provide: any, $$sanitizeUriProvider: any);
     /**
-     * @ngdoc method
-     * @name $compileProvider#directive
-     * @kind function
-     *
-     * @description
      * Register a new directive with the compiler.
      *
      * @param {string|Object} name Name of the directive in camel-case (i.e. `ngBind` which will match
@@ -18,18 +13,14 @@ export class $CompileProvider {
      */
     directive: (name: string | any, directiveFactory: Function | any[]) => $CompileProvider;
     /**
-     * @ngdoc method
-     * @name $compileProvider#component
-     * @module ng
      * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
      *    or an object map of components where the keys are the names and the values are the component definition objects.
      * @param {Object} options Component definition object (a simplified
-     *    {@link ng.$compile#directive-definition-object directive definition object}),
+     *    {directive definition object}),
      *    with the following properties (all optional):
      *
      *    - `controller` – `{(string|function()=}` – controller constructor function that should be
-     *      associated with newly created scope or the name of a {@link ng.$compile#-controller-
-     *      registered controller} if passed as a string. An empty `noop` function by default.
+     *      associated with newly created scope or the name of a {controller} if passed as a string. An empty `noop` function by default.
      *    - `controllerAs` – `{string=}` – identifier name for to reference the controller in the component's scope.
      *      If present, the controller will be published to scope under the `controllerAs` name.
      *      If not present, this will default to be `$ctrl`.
@@ -37,7 +28,7 @@ export class $CompileProvider {
      *      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 {@link auto.$injector#invoke injected} with
+     *      If `template` is a function, then it is {injected} with
      *      the following locals:
      *
      *      - `$element` - Current element
@@ -46,7 +37,7 @@ export class $CompileProvider {
      *    - `templateUrl` – `{string=|function()=}` – 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 {@link auto.$injector#invoke injected} with
+     *      If `templateUrl` is a function, then it is {injected} with
      *      the following locals:
      *
      *      - `$element` - Current element
@@ -54,57 +45,18 @@ export class $CompileProvider {
      *
      *    - `bindings` – `{object=}` – defines bindings between DOM attributes and component properties.
      *      Component properties are always bound to the component controller and not to the scope.
-     *      See {@link ng.$compile#-bindtocontroller- `bindToController`}.
-     *    - `transclude` – `{boolean=}` – whether {@link $compile#transclusion content transclusion} is enabled.
+     *      See {`bindToController`}.
+     *    - `transclude` – `{boolean=}` – whether {content transclusion} is enabled.
      *      Disabled by default.
      *    - `require` - `{Object<string, string>=}` - 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. See {@link ng.$compile#-require- `require`}.
+     *      controllers (object values) will be bound. See {`require`}.
      *    - `$...` – additional properties to attach to the directive factory function and the controller
      *      constructor function. (This is used by the component router to annotate)
      *
-     * @returns {ng.$compileProvider} the compile provider itself, for chaining of function calls.
-     * @description
-     * Register a **component definition** with the compiler. This is a shorthand for registering a special
-     * type of directive, which represents a self-contained UI component in your application. Such components
-     * are always isolated (i.e. `scope: {}`) and are always restricted to elements (i.e. `restrict: 'E'`).
-     *
-     * Component definitions are very simple and do not require as much configuration as defining general
-     * directives. Component definitions usually consist only of a template and a controller backing it.
-     *
-     * In order to make the definition easier, components enforce best practices like use of `controllerAs`,
-     * `bindToController`. They always have **isolate scope** and are restricted to elements.
-     *
-     * Here are a few examples of how you would usually define components:
-     *
-     * ```js
-     *   let myMod = angular.module(...);
-     *   myMod.component('myComp', {
-     *     template: '<div>My name is {{$ctrl.name}}</div>',
-     *     controller: function() {
-     *       this.name = 'shahar';
-     *     }
-     *   });
-     *
-     *   myMod.component('myComp', {
-     *     template: '<div>My name is {{$ctrl.name}}</div>',
-     *     bindings: {name: '@'}
-     *   });
-     *
-     *   myMod.component('myComp', {
-     *     templateUrl: 'views/my-comp.html',
-     *     controller: 'MyCtrl',
-     *     controllerAs: 'ctrl',
-     *     bindings: {name: '@'}
-     *   });
-     *
-     * ```
-     * For more examples, and an in-depth guide, see the {@link guide/component component guide}.
-     *
-     * <br />
-     * See also {@link ng.$compileProvider#directive $compileProvider.directive()}.
+     * @returns {$CompileProvider} the compile provider itself, for chaining of function calls.
      */
-    component: (name: string | any, options: any) => ng.$compileProvider;
+    component: (name: string | any, options: any) => $CompileProvider;
     /**
      * @ngdoc method
      * @name $compileProvider#aHrefSanitizationTrustedUrlList
@@ -127,11 +79,6 @@ export class $CompileProvider {
      */
     aHrefSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | $CompileProvider;
     /**
-     * @ngdoc method
-     * @name $compileProvider#imgSrcSanitizationTrustedUrlList
-     * @kind function
-     *
-     * @description
      * Retrieves or overrides the default regular expression that is used for determining trusted safe
      * urls during img[src] sanitization.
      *
@@ -149,10 +96,6 @@ export class $CompileProvider {
     imgSrcSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | $CompileProvider;
     strictComponentBindingsEnabled: (enabled: any) => boolean | this;
     /**
-     * @ngdoc method
-     * @name $compileProvider#addPropertySecurityContext
-     * @description
-     *
      * Defines the security context for DOM properties bound by ng-prop-*.
      *
      * @param {string} elementName The element name or '*' to match any element.
@@ -161,7 +104,7 @@ export class $CompileProvider {
      * @returns {object} `this` for chaining
      */
     addPropertySecurityContext: (elementName: string, propertyName: string, ctx: string) => object;
-    $get: (string | (($injector: import("../../core/di/internal-injector").InjectorService, $interpolate: any, $exceptionHandler: any, $templateRequest: any, $parse: any, $controller: any, $rootScope: any, $sce: any, $animate: any) => ($compileNodes: string | NodeList, transcludeFn: any, maxPriority: any, ignoreDirective: any, previousCompileContext: any) => (scope: any, cloneConnectFn: any, options: any) => string | NodeList | JQLite))[];
+    $get: (string | (($injector: import("../../core/di/internal-injector").InjectorService, $interpolate: any, $exceptionHandler: import("../exception-handler").ExceptionHandlerProvider, $templateRequest: any, $parse: import("../parser/parse").ParseService, $controller: any, $rootScope: import("../scope/scope").Scope, $sce: any, $animate: any) => ($compileNodes: string | NodeList, transcludeFn: any, maxPriority: any, ignoreDirective: any, previousCompileContext: any) => (scope: any, cloneConnectFn: any, options: any) => JQLite))[];
 }
 export namespace $CompileProvider {
     let $inject: string[];

package/types/core/di/ng-module.d.ts

@@ -16,7 +16,6 @@ export const CONTROLLER_LITERAL: "$controllerProvider";
  */
 export class NgModule {
     /**
-     *
      * @param {String} name - Name of the module
      * @param {Array<String>} requires - List of modules which the injector will load before the current module
      * @param {Function} [configFn]
@@ -49,13 +48,13 @@ export class NgModule {
      */
     info(value: any): any;
     /**
-     * @param {String} name
+     * @param {string} name
      * @param {any} object
      * @returns {NgModule}
      */
     value(name: string, object: any): NgModule;
     /**
-     * @param {String} name
+     * @param {string} name
      * @param {any} object
      * @returns {NgModule}
      */
@@ -66,14 +65,58 @@ export class NgModule {
      * @returns {NgModule}
      */
     config(configFn: Function): NgModule;
-    run(block: any): this;
-    component(name: any, options: any): this;
-    factory(name: any, providerFunction: any): this;
-    service(name: any, serviceFunction: any): this;
-    provider(name: any, providerType: any): this;
-    decorator(name: any, decorFn: any): this;
-    directive(name: any, directiveFactory: any): this;
-    animation(name: any, animationFactory: any): this;
+    /**
+     * @param {Function} block
+     * @returns {NgModule}
+     */
+    run(block: Function): NgModule;
+    /**
+     * @param {string} name
+     * @param {*} options
+     * @returns {NgModule}
+     */
+    component(name: string, options: any): NgModule;
+    /**
+     * @param {string} name
+     * @param {*} providerFunction
+     * @returns {NgModule}
+     */
+    factory(name: string, providerFunction: any): NgModule;
+    /**
+     * @param {string} name
+     * @param {*} serviceFunction
+     * @returns {NgModule}
+     */
+    service(name: string, serviceFunction: any): NgModule;
+    /**
+     * @param {string} name
+     * @param {*} providerType
+     * @returns {NgModule}
+     */
+    provider(name: string, providerType: any): NgModule;
+    /**
+     * @param {string} name
+     * @param {*} decorFn
+     * @returns {NgModule}
+     */
+    decorator(name: string, decorFn: any): NgModule;
+    /**
+     * @param {string} name
+     * @param {*} directiveFactory
+     * @returns {NgModule}
+     */
+    directive(name: string, directiveFactory: any): NgModule;
+    /**
+     * @param {string} name
+     * @param {*} animationFactory
+     * @returns {NgModule}
+     */
+    animation(name: string, animationFactory: any): NgModule;
     filter(name: any, filterFn: any): this;
-    controller(name: any, ctlFn: any): this;
+    /**
+     * @param {string} name
+     * @param {*} ctlFn
+     * @returns {NgModule}
+     */
+    controller(name: string, ctlFn: any): NgModule;
 }