@angular-wave/angular.ts 0.0.66 → 0.0.68

package/src/types.js

@@ -11,12 +11,10 @@
  */
 
 /**
- *
  * @typedef {Object} Annotated
  * @property {Array<String>} $inject
- *  *
- * @typedef {Function & Annotated & Array<any>} AnnotatedFunction
  *
+ * @typedef {Function & Annotated & Array<any>} AnnotatedFunction
  */
 
 /**
@@ -316,7 +314,7 @@
 
 /**
  * Interface for a service provider.
- * @typedef {Object} ServiceProvider
+ * @typedef {Object|Function} ServiceProvider
  * @property {*} $get - The $get property that represents a service instance or a factory function.
  */
 

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

@@ -1,10 +1,7 @@
-export function ngAnimateSwapDirective($animate: any): {
-    restrict: string;
-    transclude: string;
-    terminal: boolean;
-    priority: number;
-    link(scope: any, $element: any, attrs: any, ctrl: any, $transclude: any): void;
-};
+/**
+ * @returns {import('../types').Directive}
+ */
+export function ngAnimateSwapDirective($animate: any): import("../types").Directive;
 export namespace ngAnimateSwapDirective {
     let $inject: string[];
 }

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

@@ -14,9 +14,9 @@ export class $CompileProvider {
      *    are the factories.
      * @param {Function|Array} directiveFactory An injectable directive factory function. See the
      *    {@link guide/directive directive guide} and the {@link $compile compile API} for more info.
-     * @returns {ng.ICompileProvider} Self for chaining.
+     * @returns {$CompileProvider} Self for chaining.
      */
-    directive: (name: string | any, directiveFactory: Function | any[]) => ng.ICompileProvider;
+    directive: (name: string | any, directiveFactory: Function | any[]) => $CompileProvider;
     /**
      * @ngdoc method
      * @name $compileProvider#component
@@ -122,10 +122,10 @@ export class $CompileProvider {
      * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
      *
      * @param {RegExp=} regexp New regexp to trust urls with.
-     * @returns {RegExp|ng.ICompileProvider} Current RegExp if called without value or self for
+     * @returns {RegExp|$CompileProvider} Current RegExp if called without value or self for
      *    chaining otherwise.
      */
-    aHrefSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | ng.ICompileProvider;
+    aHrefSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | $CompileProvider;
     /**
      * @ngdoc method
      * @name $compileProvider#imgSrcSanitizationTrustedUrlList
@@ -143,10 +143,10 @@ export class $CompileProvider {
      * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
      *
      * @param {RegExp=} regexp New regexp to trust urls with.
-     * @returns {RegExp|ng.ICompileProvider} Current RegExp if called without value or self for
+     * @returns {RegExp|$CompileProvider} Current RegExp if called without value or self for
      *    chaining otherwise.
      */
-    imgSrcSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | ng.ICompileProvider;
+    imgSrcSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | $CompileProvider;
     strictComponentBindingsEnabled: (enabled: any) => boolean | this;
     /**
      * @ngdoc method

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

@@ -1,10 +1,5 @@
 export function identifierForController(controller: any, ident: any): any;
 /**
- * @ngdoc provider
- * @name $controllerProvider
- *
- *
- * @description
  * The {@link ng.$controller $controller service} is used by AngularJS to create new
  * controllers.
  *

package/types/core/di/internal-injector.d.ts

@@ -1,36 +1,91 @@
-export class ProviderInjector {
+/**
+ * Injector for providers
+ * @extends AbstractInjector
+ */
+export class ProviderInjector extends AbstractInjector {
     /**
-     *
      * @param {Object} cache
-     * @param {boolean} strictDi
+     * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
      */
     constructor(cache: any, strictDi: boolean);
+}
+/**
+ * Injector for factories and services
+ * @extends AbstractInjector
+ */
+export class InjectorService extends AbstractInjector {
+    /**
+     *
+     * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
+     * @param {ProviderInjector} providerInjector
+     */
+    constructor(strictDi: boolean, providerInjector: ProviderInjector);
+    providerInjector: ProviderInjector;
+    factory(serviceName: any): any;
+    /**
+     *
+     * @param {String} name
+     * @returns {boolean}
+     */
+    has(name: string): boolean;
+}
+declare class AbstractInjector {
+    /**
+     * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
+     */
+    constructor(strictDi: boolean);
+    /**
+     * @type {Object<String, Function>}
+     */
     cache: any;
+    /** @type {boolean} */
     strictDi: boolean;
     path: any[];
-    providerCache: any;
-    modules: any;
-    factory(caller: any): void;
+    /** @type {Object.<string, import("../../types").Module>} */
+    modules: {
+        [x: string]: import("../../types").Module;
+    };
     /**
+     * Get a service by name.
      *
      * @param {String} serviceName
      * @returns {any}
      */
     get(serviceName: string): any;
-    injectionArgs(fn: any, locals: any, serviceName: any): any[];
-    invoke(fn: any, self: any, locals: any, serviceName: any): any;
-    instantiate(Type: any, locals: any, serviceName: any): any;
     /**
+     * Get the injection arguments for a function.
      *
-     * @param {String} name
-     * @returns {boolean}
+     * @param {Function|Array} fn
+     * @param {Object} locals
+     * @param {String} serviceName
+     * @returns
+     */
+    injectionArgs(fn: Function | any[], locals: any, serviceName: string): any[];
+    /**
+     * Invoke a function with optional context and locals.
+     *
+     * @param {Function|String|Array<any>} fn
+     * @param {*} [self]
+     * @param {Object} [locals]
+     * @param {String} [serviceName]
+     * @returns
+     */
+    invoke(fn: Function | string | Array<any>, self?: any, locals?: any, serviceName?: string): any;
+    /**
+     * Instantiate a type constructor with optional locals.
+     * @param {Function|Array} type
+     * @param {*} [locals]
+     * @param {String} [serviceName]
+     */
+    instantiate(type: Function | any[], locals?: any, serviceName?: string): any;
+    /**
+     * @abstract
      */
-    has(name: string): boolean;
-}
-export class InjectorService extends ProviderInjector {
-    constructor(cache: any, strictDi: any, providerInjector: any);
-    strictDi: any;
-    providerInjector: any;
-    factory(serviceName: any, caller: any): any;
     loadNewModules(): void;
+    /**
+     * @abstract
+     * @param {String} _serviceName
+     */
+    factory(_serviceName: string): void;
 }
+export {};

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

@@ -2,7 +2,7 @@
  * @constructor
  * @this {ExceptionHandlerProvider}
  */
-export function $ExceptionHandlerProvider(this: import("../types").ServiceProvider): void;
+export function $ExceptionHandlerProvider(this: any): void;
 export class $ExceptionHandlerProvider {
     $get: (string | (($log: any) => ErrorHandler))[];
 }

package/types/core/interval/interval-factory.d.ts

@@ -1,4 +1,4 @@
 export function $$IntervalFactoryProvider(): void;
 export class $$IntervalFactoryProvider {
-    $get: (string | (($browser: any, $q: any, $$q: any, $rootScope: any) => (setIntervalFn: any, clearIntervalFn: any) => (fn: any, delay: any, count: any, invokeApply: any, ...args: any[]) => any))[];
+    $get: (string | (($browser: import("../../services/browser").Browser, $q: any, $$q: any, $rootScope: import("../scope/scope").Scope) => (setIntervalFn: any, clearIntervalFn: any) => (fn: any, delay: any, count: any, invokeApply: any, ...args: any[]) => any))[];
 }

package/types/core/interval/interval.d.ts

@@ -2,3 +2,7 @@ export function $IntervalProvider(): void;
 export class $IntervalProvider {
     $get: (string | (($$intervalFactory: any) => any))[];
 }
+/**
+ * Interval ID which uniquely identifies the interval and can be used to cancel it
+ */
+export type IntervalId = number;

package/types/core/location/location.d.ts

@@ -1,3 +1,34 @@
+export function $LocationProvider(): void;
+export class $LocationProvider {
+    /**
+     * The default value for the prefix is `'!'`.
+     * @param {string=} prefix Prefix for hash part (containing path and search)
+     * @returns {*} current value if used as getter or itself (chaining) if used as setter
+     */
+    hashPrefix: (prefix?: string | undefined) => any;
+    /**
+     * @param {(boolean|Object)=} mode If boolean, sets `html5Mode.enabled` to value.
+     *   If object, sets `enabled`, `requireBase` and `rewriteLinks` to respective values. Supported
+     *   properties:
+     *   - **enabled** – `{boolean}` – (default: false) If true, will rely on `history.pushState` to
+     *     change urls where supported. Will fall back to hash-prefixed paths in browsers that do not
+     *     support `pushState`.
+     *   - **requireBase** - `{boolean}` - (default: `true`) When html5Mode is enabled, specifies
+     *     whether or not a <base> tag is required to be present. If `enabled` and `requireBase` are
+     *     true, and a base tag is not present, an error will be thrown when `$location` is injected.
+     *     See the {@link guide/$location $location guide for more information}
+     *   - **rewriteLinks** - `{boolean|string}` - (default: `true`) When html5Mode is enabled,
+     *     enables/disables URL rewriting for relative links. If set to a string, URL rewriting will
+     *     only happen on links with an attribute that matches the given string. For example, if set
+     *     to `'internal-link'`, then the URL will only be rewritten for `<a internal-link>` links.
+     *     Note that [attribute name normalization](guide/directive#normalization) does not apply
+     *     here, so `'internalLink'` will **not** match `'internal-link'`.
+     *
+     * @returns {Object} html5Mode object if used as getter or itself (chaining) if used as setter
+     */
+    html5Mode: (mode?: (boolean | any) | undefined) => any;
+    $get: (string | (($rootScope: import("../scope/scope").Scope, $browser: import("../../services/browser").Browser, $rootElement: JQLite) => Location))[];
+}
 /**
  *
  * @param {string} base
@@ -10,201 +41,239 @@ export function stripHash(url: any): any;
 export function stripFile(url: any): any;
 export function serverBase(url: any): any;
 /**
- * LocationHtml5Url represents a URL
- * This object is exposed as $location service when HTML5 mode is enabled and supported
- *
- * @constructor
- * @param {string} appBase application base URL
- * @param {string} appBaseNoFile application base URL stripped of any filename
- * @param {string} basePrefix URL path prefix
+ * @abstract
  */
-export function LocationHtml5Url(appBase: string, appBaseNoFile: string, basePrefix: string): void;
-export class LocationHtml5Url {
+export class Location {
     /**
-     * LocationHtml5Url represents a URL
-     * This object is exposed as $location service when HTML5 mode is enabled and supported
-     *
-     * @constructor
      * @param {string} appBase application base URL
      * @param {string} appBaseNoFile application base URL stripped of any filename
-     * @param {string} basePrefix URL path prefix
      */
-    constructor(appBase: string, appBaseNoFile: string, basePrefix: string);
+    constructor(appBase: string, appBaseNoFile: string);
+    /** @type {string} */
+    appBase: string;
+    /** @type {string} */
+    appBaseNoFile: string;
+    /**
+     * An absolute URL is the full URL, including protocol (http/https ), the optional subdomain (e.g. www ), domain (example.com), and path (which includes the directory and slug).
+     * @type {string}
+     */
+    $$absUrl: string;
+    /**
+     * If html5 mode is enabled
+     * @type {boolean}
+     */
     $$html5: boolean;
     /**
-     * Parse given HTML5 (regular) URL string into properties
-     * @param {string} url HTML5 URL
-     * @private
+     * Has any change been replacing?
+     * @type {boolean}
      */
-    private $$parse;
-    $$normalizeUrl: (url: any) => string;
-    $$parseLinkUrl: (url: any, relHref: any) => boolean;
-}
-/**
- * LocationHashbangUrl represents URL
- * This object is exposed as $location service when developer doesn't opt into html5 mode.
- * It also serves as the base class for html5 mode fallback on legacy browsers.
- *
- * @constructor
- * @param {string} appBase application base URL
- * @param {string} appBaseNoFile application base URL stripped of any filename
- * @param {string} hashPrefix hashbang prefix
- */
-export function LocationHashbangUrl(appBase: string, appBaseNoFile: string, hashPrefix: string): void;
-export class LocationHashbangUrl {
+    $$replace: boolean;
+    /** @type {import('../url-utils/url-utils').HttpProtocol} */
+    $$protocol: import("../url-utils/url-utils").HttpProtocol;
+    /** @type {string} */
+    $$host: string;
     /**
-     * LocationHashbangUrl represents URL
-     * This object is exposed as $location service when developer doesn't opt into html5 mode.
-     * It also serves as the base class for html5 mode fallback on legacy browsers.
+     * The port, without ":"
+     * @type {number}
+     */
+    $$port: number;
+    /**
+     * The pathname, beginning with "/"
+     * @type {string}
+     */
+    $$path: string;
+    /**
+     * The hash string, minus the hash symbol
+     * @type {string}
+     */
+    $$hash: string;
+    /**
+     * Helper property for scope watch changes
+     * @type {boolean}
+     */
+    $$urlUpdatedByLocation: boolean;
+    /**
+     * Return full URL representation with all segments encoded according to rules specified in
+     * [RFC 3986](http://www.ietf.org/rfc/rfc3986.txt).
      *
-     * @constructor
-     * @param {string} appBase application base URL
-     * @param {string} appBaseNoFile application base URL stripped of any filename
-     * @param {string} hashPrefix hashbang prefix
+     * @return {string} full URL
      */
-    constructor(appBase: string, appBaseNoFile: string, hashPrefix: string);
+    absUrl(): string;
     /**
-     * Parse given hashbang URL into properties
-     * @param {string} url Hashbang URL
-     * @private
+     * This method is getter / setter.
+     *
+     * Return URL (e.g. `/path?a=b#hash`) when called without any parameter.
+     * Change path, search and hash, when called with parameter and return `$location`.
+     *
+     * @param {string=} url New URL without base prefix (e.g. `/path?a=b#hash`)
+     * @return {Location|string} url
      */
-    private $$parse;
-    $$normalizeUrl: (url: any) => string;
-    $$parseLinkUrl: (url: any) => boolean;
-}
-/**
- * LocationHashbangUrl represents URL
- * This object is exposed as $location service when html5 history api is enabled but the browser
- * does not support it.
- *
- * @constructor
- * @param {string} appBase application base URL
- * @param {string} appBaseNoFile application base URL stripped of any filename
- * @param {string} hashPrefix hashbang prefix
- */
-export function LocationHashbangInHtml5Url(appBase: string, appBaseNoFile: string, hashPrefix: string, ...args: any[]): void;
-export class LocationHashbangInHtml5Url {
+    url(url?: string | undefined): Location | string;
     /**
-     * LocationHashbangUrl represents URL
-     * This object is exposed as $location service when html5 history api is enabled but the browser
-     * does not support it.
      *
-     * @constructor
-     * @param {string} appBase application base URL
-     * @param {string} appBaseNoFile application base URL stripped of any filename
-     * @param {string} hashPrefix hashbang prefix
+     * Return protocol of current URL.
+     * @return {import("../url-utils/url-utils").HttpProtocol} protocol of current URL
      */
-    constructor(appBase: string, appBaseNoFile: string, hashPrefix: string, ...args: any[]);
-    $$html5: boolean;
-    $$parseLinkUrl: (url: any, relHref: any) => boolean;
-    $$normalizeUrl: (url: any) => string;
-}
-/**
- * @ngdoc service
- * @name $location
- *
- * @requires $rootElement
- *
- * @description
- * The $location service parses the URL in the browser address bar (based on the
- * [window.location](https://developer.mozilla.org/en/window.location)) and makes the URL
- * available to your application. Changes to the URL in the address bar are reflected into
- * $location service and changes to $location are reflected into the browser address bar.
- *
- * **The $location service:**
- *
- * - Exposes the current URL in the browser address bar, so you can
- *   - Watch and observe the URL.
- *   - Change the URL.
- * - Synchronizes the URL with the browser when the user
- *   - Changes the address bar.
- *   - Clicks the back or forward button (or clicks a History link).
- *   - Clicks on a link.
- * - Represents the URL object as a set of methods (protocol, host, port, path, search, hash).
- *
- * For more information see {@link guide/$location Developer Guide: Using $location}
- */
-/**
- * @ngdoc provider
- * @name $locationProvider
- *
- *
- * @description
- * Use the `$locationProvider` to configure how the application deep linking paths are stored.
- */
-export function $LocationProvider(): void;
-export class $LocationProvider {
+    protocol(): import("../url-utils/url-utils").HttpProtocol;
     /**
-     * @ngdoc method
-     * @name $locationProvider#hashPrefix
-     * @description
-     * The default value for the prefix is `'!'`.
-     * @param {string=} prefix Prefix for hash part (containing path and search)
-     * @returns {*} current value if used as getter or itself (chaining) if used as setter
+     * This method is getter only.
+     *
+     * Return host of current URL.
+     *
+     * Note: compared to the non-AngularJS version `location.host` which returns `hostname:port`, this returns the `hostname` portion only.
+     *
+     *
+     * @return {string} host of current URL.
      */
-    hashPrefix: (prefix?: string | undefined) => any;
+    host(): string;
     /**
-     * @ngdoc method
-     * @name $locationProvider#html5Mode
-     * @description
-     * @param {(boolean|Object)=} mode If boolean, sets `html5Mode.enabled` to value.
-     *   If object, sets `enabled`, `requireBase` and `rewriteLinks` to respective values. Supported
-     *   properties:
-     *   - **enabled** – `{boolean}` – (default: false) If true, will rely on `history.pushState` to
-     *     change urls where supported. Will fall back to hash-prefixed paths in browsers that do not
-     *     support `pushState`.
-     *   - **requireBase** - `{boolean}` - (default: `true`) When html5Mode is enabled, specifies
-     *     whether or not a <base> tag is required to be present. If `enabled` and `requireBase` are
-     *     true, and a base tag is not present, an error will be thrown when `$location` is injected.
-     *     See the {@link guide/$location $location guide for more information}
-     *   - **rewriteLinks** - `{boolean|string}` - (default: `true`) When html5Mode is enabled,
-     *     enables/disables URL rewriting for relative links. If set to a string, URL rewriting will
-     *     only happen on links with an attribute that matches the given string. For example, if set
-     *     to `'internal-link'`, then the URL will only be rewritten for `<a internal-link>` links.
-     *     Note that [attribute name normalization](guide/directive#normalization) does not apply
-     *     here, so `'internalLink'` will **not** match `'internal-link'`.
+     * This method is getter only.
      *
-     * @returns {Object} html5Mode object if used as getter or itself (chaining) if used as setter
+     * Return port of current URL.
+     *
+     *
+     * ```js
+     * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
+     * let port = $location.port();
+     * // => 80
+     * ```
+     *
+     * @return {number} port
      */
-    html5Mode: (mode?: (boolean | any) | undefined) => any;
+    port(): number;
+    /**
+     * This method is getter / setter.
+     *
+     * Return path of current URL when called without any parameter.
+     *
+     * Change path when called with parameter and return `$location`.
+     *
+     * Note: Path should always begin with forward slash (/), this method will add the forward slash
+     * if it is missing.
+     *
+     *
+     * ```js
+     * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
+     * let path = $location.path();
+     * // => "/some/path"
+     * ```
+     *
+     * @param {(string|number)=} path New path
+     * @return {(string|object)} path if called with no parameters, or `$location` if called with a parameter
+     */
+    path(path?: (string | number) | undefined): (string | object);
     /**
-     * @ngdoc event
-     * @name $location#$locationChangeStart
-     * @eventType broadcast on root scope
-     * @description
-     * Broadcasted before a URL will change.
+     * This method is getter / setter.
+     *
+     * Returns the hash fragment when called without any parameters.
+     *
+     * Changes the hash fragment when called with a parameter and returns `$location`.
      *
-     * This change can be prevented by calling
-     * `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on} for more
-     * details about event object. Upon successful change
-     * {@link ng.$location#$locationChangeSuccess $locationChangeSuccess} is fired.
      *
-     * The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
-     * the browser supports the HTML5 History API.
+     * ```js
+     * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo#hashValue
+     * let hash = $location.hash();
+     * // => "hashValue"
+     * ```
      *
-     * @param {Object} angularEvent Synthetic event object.
-     * @param {string} newUrl New URL
-     * @param {string=} oldUrl URL that was before it was changed.
-     * @param {string=} newState New history state object
-     * @param {string=} oldState History state object that was before it was changed.
+     * @param {(string|number)=} hash New hash fragment
+     * @return {string|Location} hash
+     */
+    hash(hash?: (string | number) | undefined): string | Location;
+    /**
+     * If called, all changes to $location during the current `$digest` will replace the current history
+     * record, instead of adding a new one.
+     */
+    replace(): this;
+    /**
+     * Returns or sets the search part (as object) of current URL when called without any parameter
+     *
+     * @param {string|Object=} search New search params - string or hash object.
+     * @param {(string|number|Array<string>|boolean)=} paramValue If search is a string or number, then paramValue will override only a single search property.
+     * @returns {Object|Location} Search object or Location object
+     */
+    search(search?: (string | any) | undefined, paramValue?: (string | number | Array<string> | boolean) | undefined, ...args: any[]): any | Location;
+    $$search: any;
+    /**
+     * Compose url and update `url` and `absUrl` property
+     * @returns {void}
+     */
+    $$compose(): void;
+    $$url: string;
+    /**
+     * @param {string} _url
+     * @returns {string}
      */
+    $$normalizeUrl(_url: string): string;
     /**
-     * @ngdoc event
-     * @name $location#$locationChangeSuccess
-     * @eventType broadcast on root scope
-     * @description
-     * Broadcasted after a URL was changed.
+     * This method is getter / setter.
+     *
+     * Return the history state object when called without any parameter.
+     *
+     * Change the history state object when called with one parameter and return `$location`.
+     * The state object is later passed to `pushState` or `replaceState`.
+     * See {@link https://developer.mozilla.org/en-US/docs/Web/API/History/pushState#state|History.state}
      *
-     * The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
-     * the browser supports the HTML5 History API.
+     * NOTE: This method is supported only in HTML5 mode and only in browsers supporting
+     * the HTML5 History API (i.e. methods `pushState` and `replaceState`). If you need to support
+     * older browsers (like IE9 or Android < 4.0), don't use this method.
      *
-     * @param {Object} angularEvent Synthetic event object.
-     * @param {string} newUrl New URL
-     * @param {string=} oldUrl URL that was before it was changed.
-     * @param {string=} newState New history state object
-     * @param {string=} oldState History state object that was before it was changed.
+     * @param {any} state State object for pushState or replaceState
+     * @return {any} state
+     */
+    state(state: any, ...args: any[]): any;
+    $$state: any;
+}
+/**
+ * This object is exposed as $location service when HTML5 mode is enabled and supported
+ */
+export class LocationHtml5Url extends Location {
+    /**
+     * @param {string} appBase application base URL
+     * @param {string} appBaseNoFile application base URL stripped of any filename
+     * @param {string} basePrefix URL path prefix
+     */
+    constructor(appBase: string, appBaseNoFile: string, basePrefix: string);
+    basePrefix: string;
+    /**
+     * Parse given HTML5 (regular) URL string into properties
+     * @param {string} url HTML5 URL
+     */
+    $$parse(url: string): void;
+    $$normalizeUrl(url: any): string;
+    $$parseLinkUrl: (url: any, relHref: any) => boolean;
+}
+/**
+ * LocationHashbangUrl represents URL
+ * This object is exposed as $location service when developer doesn't opt into html5 mode.
+ * It also serves as the base class for html5 mode fallback on legacy browsers.
+ *
+ * @constructor
+ * @param {string} appBase application base URL
+ * @param {string} appBaseNoFile application base URL stripped of any filename
+ * @param {string} hashPrefix hashbang prefix
+ */
+export class LocationHashbangUrl extends Location {
+    constructor(appBase: any, appBaseNoFile: any, hashPrefix: any);
+    appBase: any;
+    appBaseNoFile: any;
+    hashPrefix: any;
+    /**
+     * Parse given hashbang URL into properties
+     * @param {string} url Hashbang URL
      */
-    $get: (string | (($rootScope: any, $browser: any, $rootElement: JQLite) => LocationHtml5Url | LocationHashbangUrl))[];
+    $$parse(url: string): void;
+    $$normalizeUrl(url: any): any;
+    $$parseLinkUrl(url: any): boolean;
 }
-export const PATH_MATCH: RegExp;
+export type DefaultPorts = {
+    http: number;
+    https: number;
+    ftp: number;
+};
+export type Html5Mode = {
+    enabled: boolean;
+    requireBase: boolean;
+    rewriteLinks: boolean | string;
+};
 import { JQLite } from "../../shared/jqlite/jqlite";