@angular-wave/angular.ts 0.0.35 → 0.0.37

package/types/directive/ref.d.ts

@@ -0,0 +1,11 @@
+export const ngRefDirective: (
+  | string
+  | (($parse: any) => {
+      priority: number;
+      restrict: string;
+      compile(
+        tElement: any,
+        tAttrs: any,
+      ): (scope: any, element: any, attrs: any) => void;
+    })
+)[];

package/types/directive/repeat.d.ts

@@ -0,0 +1,23 @@
+export const ngRepeatDirective: (
+  | string
+  | ((
+      $parse: any,
+      $animate: any,
+    ) => {
+      restrict: string;
+      multiElement: boolean;
+      transclude: string;
+      priority: number;
+      terminal: boolean;
+      compile: (
+        $element: any,
+        $attr: any,
+      ) => (
+        $scope: any,
+        $element: any,
+        $attr: any,
+        ctrl: any,
+        $transclude: any,
+      ) => void;
+    })
+)[];

package/types/directive/script.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @ngdoc directive
+ * @name script
+ * @restrict E
+ *
+ * @description
+ * Load the content of a `<script>` element into {@link ng.$templateCache `$templateCache`}, so that the
+ * template can be used by {@link ng.directive:ngInclude `ngInclude`},
+ * {@link ngRoute.directive:ngView `ngView`}, or {@link guide/directive directives}. The type of the
+ * `<script>` element must be specified as `text/ng-template`, and a cache name for the template must be
+ * assigned through the element's `id`, which can then be used as a directive's `templateUrl`.
+ *
+ * @param {string} type Must be set to `'text/ng-template'`.
+ * @param {string} id Cache name of the template.
+ */
+export const scriptDirective: (
+  | string
+  | (($templateCache: any) => {
+      restrict: string;
+      terminal: boolean;
+      compile(element: any, attr: any): void;
+    })
+)[];

package/types/directive/show-hide.d.ts

@@ -0,0 +1,234 @@
+/**
+ * @ngdoc directive
+ * @name ngShow
+ * @multiElement
+ *
+ * @description
+ * The `ngShow` directive shows or hides the given HTML element based on the expression provided to
+ * the `ngShow` attribute.
+ *
+ * The element is shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.
+ * The `.ng-hide` CSS class is predefined in AngularJS and sets the display style to none (using an
+ * `!important` flag). For CSP mode please add `angular-csp.css` to your HTML file (see
+ * {@link ng.directive:ngCsp ngCsp}).
+ *
+ * ```html
+ * <!-- when $scope.myValue is truthy (element is visible) -->
+ * <div ng-show="myValue"></div>
+ *
+ * <!-- when $scope.myValue is falsy (element is hidden) -->
+ * <div ng-show="myValue" class="ng-hide"></div>
+ * ```
+ *
+ * When the `ngShow` expression evaluates to a falsy value then the `.ng-hide` CSS class is added
+ * to the class attribute on the element causing it to become hidden. When truthy, the `.ng-hide`
+ * CSS class is removed from the element causing the element not to appear hidden.
+ *
+ * ## Why is `!important` used?
+ *
+ * You may be wondering why `!important` is used for the `.ng-hide` CSS class. This is because the
+ * `.ng-hide` selector can be easily overridden by heavier selectors. For example, something as
+ * simple as changing the display style on a HTML list item would make hidden elements appear
+ * visible. This also becomes a bigger issue when dealing with CSS frameworks.
+ *
+ * By using `!important`, the show and hide behavior will work as expected despite any clash between
+ * CSS selector specificity (when `!important` isn't used with any conflicting styles). If a
+ * developer chooses to override the styling to change how to hide an element then it is just a
+ * matter of using `!important` in their own CSS code.
+ *
+ * ### Overriding `.ng-hide`
+ *
+ * By default, the `.ng-hide` class will style the element with `display: none !important`. If you
+ * wish to change the hide behavior with `ngShow`/`ngHide`, you can simply overwrite the styles for
+ * the `.ng-hide` CSS class. Note that the selector that needs to be used is actually
+ * `.ng-hide:not(.ng-hide-animate)` to cope with extra animation classes that can be added.
+ *
+ * ```css
+ * .ng-hide:not(.ng-hide-animate) {
+ *   /&#42; These are just alternative ways of hiding an element &#42;/
+ *   display: block!important;
+ *   position: absolute;
+ *   top: -9999px;
+ *   left: -9999px;
+ * }
+ * ```
+ *
+ * By default you don't need to override anything in CSS and the animations will work around the
+ * display style.
+ *
+ * @animations
+ * | Animation                                           | Occurs                                                                                                        |
+ * |-----------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
+ * | {@link $animate#addClass addClass} `.ng-hide`       | After the `ngShow` expression evaluates to a non truthy value and just before the contents are set to hidden. |
+ * | {@link $animate#removeClass removeClass} `.ng-hide` | After the `ngShow` expression evaluates to a truthy value and just before contents are set to visible.        |
+ *
+ * Animations in `ngShow`/`ngHide` work with the show and hide events that are triggered when the
+ * directive expression is true and false. This system works like the animation system present with
+ * `ngClass` except that you must also include the `!important` flag to override the display
+ * property so that the elements are not actually hidden during the animation.
+ *
+ * ```css
+ * /&#42; A working example can be found at the bottom of this page. &#42;/
+ * .my-element.ng-hide-add, .my-element.ng-hide-remove {
+ *   transition: all 0.5s linear;
+ * }
+ *
+ * .my-element.ng-hide-add { ... }
+ * .my-element.ng-hide-add.ng-hide-add-active { ... }
+ * .my-element.ng-hide-remove { ... }
+ * .my-element.ng-hide-remove.ng-hide-remove-active { ... }
+ * ```
+ *
+ * Keep in mind that, as of AngularJS version 1.3, there is no need to change the display property
+ * to block during animation states - ngAnimate will automatically handle the style toggling for you.
+ *
+ * @element ANY
+ * @param {string} ngShow If the {@link guide/expression expression} is truthy/falsy then the
+ *                            element is shown/hidden respectively.
+ *
+ * @example
+ * A simple example, animating the element's opacity:
+
+* <hr />
+ *
+ * @knownIssue
+ *
+ * ### Flickering when using ngShow to toggle between elements
+ *
+ * When using {@link ngShow} and / or {@link ngHide} to toggle between elements, it can
+ * happen that both the element to show and the element to hide are visible for a very short time.
+ *
+ * This usually happens when the {@link ngAnimate ngAnimate module} is included, but no actual animations
+ * are defined for {@link ngShow} / {@link ngHide}.
+ *
+ * There are several way to mitigate this problem:
+ *
+ * - {@link guide/animations#how-to-selectively-enable-disable-and-skip-animations Disable animations on the affected elements}.
+ * - Use {@link ngIf} or {@link ngSwitch} instead of {@link ngShow} / {@link ngHide}.
+ * - Use the special CSS selector `ng-hide.ng-hide-animate` to set `{display: none}` or similar on the affected elements.
+ * - Use `ng-class="{'ng-hide': expression}` instead of instead of {@link ngShow} / {@link ngHide}.
+ * - Define an animation on the affected elements.
+ */
+export const ngShowDirective: (
+  | string
+  | (($animate: any) => {
+      restrict: string;
+      multiElement: boolean;
+      link(scope: any, element: any, attr: any): void;
+    })
+)[];
+/**
+ * @ngdoc directive
+ * @name ngHide
+ * @multiElement
+ *
+ * @description
+ * The `ngHide` directive shows or hides the given HTML element based on the expression provided to
+ * the `ngHide` attribute.
+ *
+ * The element is shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.
+ * The `.ng-hide` CSS class is predefined in AngularJS and sets the display style to none (using an
+ * `!important` flag). For CSP mode please add `angular-csp.css` to your HTML file (see
+ * {@link ng.directive:ngCsp ngCsp}).
+ *
+ * ```html
+ * <!-- when $scope.myValue is truthy (element is hidden) -->
+ * <div ng-hide="myValue" class="ng-hide"></div>
+ *
+ * <!-- when $scope.myValue is falsy (element is visible) -->
+ * <div ng-hide="myValue"></div>
+ * ```
+ *
+ * When the `ngHide` expression evaluates to a truthy value then the `.ng-hide` CSS class is added
+ * to the class attribute on the element causing it to become hidden. When falsy, the `.ng-hide`
+ * CSS class is removed from the element causing the element not to appear hidden.
+ *
+ * ## Why is `!important` used?
+ *
+ * You may be wondering why `!important` is used for the `.ng-hide` CSS class. This is because the
+ * `.ng-hide` selector can be easily overridden by heavier selectors. For example, something as
+ * simple as changing the display style on a HTML list item would make hidden elements appear
+ * visible. This also becomes a bigger issue when dealing with CSS frameworks.
+ *
+ * By using `!important`, the show and hide behavior will work as expected despite any clash between
+ * CSS selector specificity (when `!important` isn't used with any conflicting styles). If a
+ * developer chooses to override the styling to change how to hide an element then it is just a
+ * matter of using `!important` in their own CSS code.
+ *
+ * ### Overriding `.ng-hide`
+ *
+ * By default, the `.ng-hide` class will style the element with `display: none !important`. If you
+ * wish to change the hide behavior with `ngShow`/`ngHide`, you can simply overwrite the styles for
+ * the `.ng-hide` CSS class. Note that the selector that needs to be used is actually
+ * `.ng-hide:not(.ng-hide-animate)` to cope with extra animation classes that can be added.
+ *
+ * ```css
+ * .ng-hide:not(.ng-hide-animate) {
+ *   /&#42; These are just alternative ways of hiding an element &#42;/
+ *   display: block!important;
+ *   position: absolute;
+ *   top: -9999px;
+ *   left: -9999px;
+ * }
+ * ```
+ *
+ * By default you don't need to override in CSS anything and the animations will work around the
+ * display style.
+ *
+ * @animations
+ * | Animation                                           | Occurs                                                                                                     |
+ * |-----------------------------------------------------|------------------------------------------------------------------------------------------------------------|
+ * | {@link $animate#addClass addClass} `.ng-hide`       | After the `ngHide` expression evaluates to a truthy value and just before the contents are set to hidden.  |
+ * | {@link $animate#removeClass removeClass} `.ng-hide` | After the `ngHide` expression evaluates to a non truthy value and just before contents are set to visible. |
+ *
+ * Animations in `ngShow`/`ngHide` work with the show and hide events that are triggered when the
+ * directive expression is true and false. This system works like the animation system present with
+ * `ngClass` except that you must also include the `!important` flag to override the display
+ * property so that the elements are not actually hidden during the animation.
+ *
+ * ```css
+ * /&#42; A working example can be found at the bottom of this page. &#42;/
+ * .my-element.ng-hide-add, .my-element.ng-hide-remove {
+ *   transition: all 0.5s linear;
+ * }
+ *
+ * .my-element.ng-hide-add { ... }
+ * .my-element.ng-hide-add.ng-hide-add-active { ... }
+ * .my-element.ng-hide-remove { ... }
+ * .my-element.ng-hide-remove.ng-hide-remove-active { ... }
+ * ```
+ *
+ * Keep in mind that, as of AngularJS version 1.3, there is no need to change the display property
+ * to block during animation states - ngAnimate will automatically handle the style toggling for you.
+ *
+ * @element ANY
+ * @param {string} ngHide If the {@link guide/expression expression} is truthy/falsy then the
+ *                            element is hidden/shown respectively.
+ *
+ * @knownIssue
+ *
+ * ### Flickering when using ngHide to toggle between elements
+ *
+ * When using {@link ngShow} and / or {@link ngHide} to toggle between elements, it can
+ * happen that both the element to show and the element to hide are visible for a very short time.
+ *
+ * This usually happens when the {@link ngAnimate ngAnimate module} is included, but no actual animations
+ * are defined for {@link ngShow} / {@link ngHide}. Internet Explorer is affected more often than
+ * other browsers.
+ *
+ * There are several way to mitigate this problem:
+ *
+ * - {@link guide/animations#how-to-selectively-enable-disable-and-skip-animations Disable animations on the affected elements}.
+ * - Use {@link ngIf} or {@link ngSwitch} instead of {@link ngShow} / {@link ngHide}.
+ * - Use the special CSS selector `ng-hide.ng-hide-animate` to set `{display: none}` or similar on the affected elements.
+ * - Use `ng-class="{'ng-hide': expression}` instead of instead of {@link ngShow} / {@link ngHide}.
+ * - Define an animation on the affected elements.
+ */
+export const ngHideDirective: (
+  | string
+  | (($animate: any) => {
+      restrict: string;
+      multiElement: boolean;
+      link(scope: any, element: any, attr: any): void;
+    })
+)[];

package/types/directive/style.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @returns {angular.IDirective}
+ */
+export function ngStyleDirective(): angular.IDirective;

package/types/directive/switch.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @returns {angular.IDirective}
+ */
+export function ngSwitchWhenDirective(): angular.IDirective;
+/**
+ * @returns {angular.IDirective}
+ */
+export function ngSwitchDefaultDirective(): angular.IDirective;
+export const ngSwitchDirective: (
+  | string
+  | (($animate: any) => {
+      require: string;
+      controller: (
+        | string
+        | {
+            new (): {
+              cases: {};
+            };
+          }
+      )[];
+      link(scope: any, _element: any, attr: any, ngSwitchController: any): void;
+    })
+)[];

package/types/directive/transclude.d.ts

@@ -0,0 +1,15 @@
+export const ngTranscludeDirective: (
+  | string
+  | (($compile: any) => {
+      restrict: string;
+      compile: (
+        tElement: any,
+      ) => (
+        $scope: any,
+        $element: any,
+        $attrs: any,
+        controller: any,
+        $transclude: any,
+      ) => void;
+    })
+)[];

package/types/directive/validators.d.ts

@@ -0,0 +1,173 @@
+/**
+ * @ngdoc directive
+ * @name ngRequiredf
+ * @restrict A
+ *
+ * @param {String} ngRequired AngularJS expression. If it evaluates to `true`, it sets the
+ *                                `required` attribute to the element and adds the `required`
+ *                                {@link ngModel.NgModelController#$validators `validator`}.
+ *
+ * @description
+ *
+ * ngRequired adds the required {@link ngModel.NgModelController#$validators `validator`} to {@link ngModel `ngModel`}.
+ * It is most often used for {@link input `input`} and {@link select `select`} controls, but can also be
+ * applied to custom controls.
+ *
+ * The directive sets the `required` attribute on the element if the AngularJS expression inside
+ * `ngRequired` evaluates to true. A special directive for setting `required` is necessary because we
+ * cannot use interpolation inside `required`. See the {@link guide/interpolation interpolation guide}
+ * for more info.
+ *
+ * The validator will set the `required` error key to true if the `required` attribute is set and
+ * calling {@link ngModel.NgModelController#$isEmpty `NgModelController.$isEmpty`} with the
+ * {@link ngModel.NgModelController#$viewValue `ngModel.$viewValue`} returns `true`. For example, the
+ * `$isEmpty()` implementation for `input[text]` checks the length of the `$viewValue`. When developing
+ * custom controls, `$isEmpty()` can be overwritten to account for a $viewValue that is not string-based.
+ *
+ */
+export const requiredDirective: (
+  | string
+  | (($parse: any) => {
+      restrict: string;
+      require: string;
+      link(scope: any, elm: any, attr: any, ctrl: any): void;
+    })
+)[];
+/**
+ * @ngdoc directive
+ * @name ngPattern
+ * @restrict A
+ *
+ * @param {String|RegExp} ngPattern AngularJS expression that must evaluate to a `RegExp` or a `String`
+ *                                      parsable into a `RegExp`, or a `RegExp` literal. See above for
+ *                                      more details.
+ *
+ * @description
+ *
+ * ngPattern adds the pattern {@link ngModel.NgModelController#$validators `validator`} to {@link ngModel `ngModel`}.
+ * It is most often used for text-based {@link input `input`} controls, but can also be applied to custom text-based controls.
+ *
+ * The validator sets the `pattern` error key if the {@link ngModel.NgModelController#$viewValue `ngModel.$viewValue`}
+ * does not match a RegExp which is obtained from the `ngPattern` attribute value:
+ * - the value is an AngularJS expression:
+ *   - If the expression evaluates to a RegExp object, then this is used directly.
+ *   - If the expression evaluates to a string, then it will be converted to a RegExp after wrapping it
+ *     in `^` and `$` characters. For instance, `"abc"` will be converted to `new RegExp('^abc$')`.
+ * - If the value is a RegExp literal, e.g. `ngPattern="/^\d+$/"`, it is used directly.
+ *
+ * <div class="alert alert-info">
+ * **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
+ * start at the index of the last search's match, thus not taking the whole input value into
+ * account.
+ * </div>
+ *
+ * <div class="alert alert-info">
+ * **Note:** This directive is also added when the plain `pattern` attribute is used, with two
+ * differences:
+ * <ol>
+ *   <li>
+ *     `ngPattern` does not set the `pattern` attribute and therefore HTML5 constraint validation is
+ *     not available.
+ *   </li>
+ *   <li>
+ *     The `ngPattern` attribute must be an expression, while the `pattern` value must be
+ *     interpolated.
+ *   </li>
+ * </ol>
+ * </div>
+ */
+export const patternDirective: (
+  | string
+  | (($parse: any) => {
+      restrict: string;
+      require: string;
+      compile: (
+        tElm: any,
+        tAttr: any,
+      ) => (scope: any, elm: any, attr: any, ctrl: any) => void;
+    })
+)[];
+/**
+ * @ngdoc directive
+ * @name ngMaxlength
+ * @restrict A
+ *
+ * @param {String} ngMaxlength AngularJS expression that must evaluate to a `Number` or `String`
+ *                                 parsable into a `Number`. Used as value for the `maxlength`
+ *                                 {@link ngModel.NgModelController#$validators validator}.
+ *
+ * @description
+ *
+ * ngMaxlength adds the maxlength {@link ngModel.NgModelController#$validators `validator`} to {@link ngModel `ngModel`}.
+ * It is most often used for text-based {@link input `input`} controls, but can also be applied to custom text-based controls.
+ *
+ * The validator sets the `maxlength` error key if the {@link ngModel.NgModelController#$viewValue `ngModel.$viewValue`}
+ * is longer than the integer obtained by evaluating the AngularJS expression given in the
+ * `ngMaxlength` attribute value.
+ *
+ * <div class="alert alert-info">
+ * **Note:** This directive is also added when the plain `maxlength` attribute is used, with two
+ * differences:
+ * <ol>
+ *   <li>
+ *     `ngMaxlength` does not set the `maxlength` attribute and therefore HTML5 constraint
+ *     validation is not available.
+ *   </li>
+ *   <li>
+ *     The `ngMaxlength` attribute must be an expression, while the `maxlength` value must be
+ *     interpolated.
+ *   </li>
+ * </ol>
+ * </div>
+ *
+ */
+export const maxlengthDirective: (
+  | string
+  | (($parse: any) => {
+      restrict: string;
+      require: string;
+      link(scope: any, elm: any, attr: any, ctrl: any): void;
+    })
+)[];
+/**
+ * @ngdoc directive
+ * @name ngMinlength
+ * @restrict A
+ *
+ * @param {string} ngMinlength AngularJS expression that must evaluate to a `Number` or `String`
+ *                                 parsable into a `Number`. Used as value for the `minlength`
+ *                                 {@link ngModel.NgModelController#$validators validator}.
+ *
+ * @description
+ *
+ * ngMinlength adds the minlength {@link ngModel.NgModelController#$validators `validator`} to {@link ngModel `ngModel`}.
+ * It is most often used for text-based {@link input `input`} controls, but can also be applied to custom text-based controls.
+ *
+ * The validator sets the `minlength` error key if the {@link ngModel.NgModelController#$viewValue `ngModel.$viewValue`}
+ * is shorter than the integer obtained by evaluating the AngularJS expression given in the
+ * `ngMinlength` attribute value.
+ *
+ * <div class="alert alert-info">
+ * **Note:** This directive is also added when the plain `minlength` attribute is used, with two
+ * differences:
+ * <ol>
+ *   <li>
+ *     `ngMinlength` does not set the `minlength` attribute and therefore HTML5 constraint
+ *     validation is not available.
+ *   </li>
+ *   <li>
+ *     The `ngMinlength` value must be an expression, while the `minlength` value must be
+ *     interpolated.
+ *   </li>
+ * </ol>
+ * </div>
+ *
+ */
+export const minlengthDirective: (
+  | string
+  | (($parse: any) => {
+      restrict: string;
+      require: string;
+      link(scope: any, elm: any, attr: any, ctrl: any): void;
+    })
+)[];

package/types/exts/aria.d.ts

@@ -0,0 +1 @@
+export function initAriaModule(): void;

package/types/exts/messages.d.ts

@@ -0,0 +1 @@
+export function initMessageModule(): void;

package/types/filters/filter.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @returns {angular.IFilterFilter}
+ */
+export function filterFilter(): angular.IFilterFilter;

package/types/filters/filters.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Format a number into a string
+ * @param  {number} number       The number to format
+ * @param  {{
+ *           minFrac, // the minimum number of digits required in the fraction part of the number
+ *           maxFrac, // the maximum number of digits required in the fraction part of the number
+ *           gSize,   // number of digits in each group of separated digits
+ *           lgSize,  // number of digits in the last group of digits before the decimal separator
+ *           negPre,  // the string to go in front of a negative number (e.g. `-` or `(`))
+ *           posPre,  // the string to go in front of a positive number
+ *           negSuf,  // the string to go after a negative number (e.g. `)`)
+ *           posSuf   // the string to go after a positive number
+ *         }} pattern
+ * @param  {string} groupSep     The string to separate groups of number (e.g. `,`)
+ * @param  {string} decimalSep   The string to act as the decimal separator (e.g. `.`)
+ * @param  {[type]} fractionSize The size of the fractional part of the number
+ * @return {string}              The number formatted as a string
+ */
+export function formatNumber(
+  number: number,
+  pattern: {
+    minFrac;
+    maxFrac;
+    gSize;
+    lgSize;
+    negPre;
+    posPre;
+    negSuf;
+    posSuf;
+  },
+  groupSep: string,
+  decimalSep: string,
+  fractionSize: [type],
+): string;
+/**
+ * @returns {angular.IFilterJson}
+ */
+export function jsonFilter(): angular.IFilterJson;

package/types/filters/limit-to.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @returns {angular.IFilterLimitTo}
+ */
+export function limitToFilter(): angular.IFilterLimitTo;

package/types/filters/order-by.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {angular.IParseService} $parse
+ * @returns
+ */
+export function orderByFilter(
+  $parse: angular.IParseService,
+): (array: any, sortPredicate: any, reverseOrder: any, compareFn: any) => any;
+export namespace orderByFilter {
+  let $inject: string[];
+}

package/types/jqLite.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Converts kebab-case to camelCase.
+ * @param {string} name Name to normalize
+ * @returns {string}
+ */
+export function kebabToCamel(name: string): string;
+/**
+ * Converts sname to camelCase.
+ * @param {string} name
+ * @returns {string}
+ */
+export function snakeToCamel(name: string): string;
+/**
+ * Checks if the string contains HTML tags or entities.
+ * @param {string} html
+ * @returns {boolean}
+ */
+export function isTextNode(html: string): boolean;
+export function jqLiteBuildFragment(html: any, context: any): any;
+export function JQLite(element: any): any;
+export class JQLite {
+  constructor(element: any);
+  ready: typeof jqLiteReady;
+  toString(): string;
+  eq(index: any): any;
+  length: number;
+  push: (...items: undefined[]) => number;
+  sort: (compareFn?: (a: undefined, b: undefined) => number) => undefined[];
+  splice: {
+    (start: number, deleteCount?: number): undefined[];
+    (start: number, deleteCount: number, ...items: undefined[]): undefined[];
+  };
+}
+/**
+ * @param {Element} element
+ * @param {boolean} [onlyDescendants]
+ * @returns {void}
+ */
+export function dealoc(element: Element, onlyDescendants?: boolean): void;
+export function jqLiteRemove(element: any, keepData: any): void;
+export function getBooleanAttrName(element: any, name: any): any;
+export function jqLiteCleanData(nodes: any): void;
+/**
+ * @param {string} elementStr
+ * @returns {string} Returns the string representation of the element.
+ */
+export function startingTag(elementStr: string): string;
+/**
+ * Return the DOM siblings between the first and last node in the given array.
+ * @param {Array} nodes An array-like object
+ * @returns {Array} the inputted object or a jqLite collection containing the nodes
+ */
+export function getBlockNodes(nodes: any[]): any[];
+export const jqLite: typeof JQLite;
+export const BOOLEAN_ATTR: {};
+declare function jqLiteReady(fn: any): void;
+export {};

package/types/router/common/coreservices.d.ts

@@ -0,0 +1,4 @@
+export namespace services {
+  let $q: any;
+  let $injector: any;
+}