@angular-wave/angular.ts 0.0.16 → 0.0.18

package/types/router/interface.d.ts

@@ -0,0 +1,491 @@
+/** @publicapi @module ng1 */ /** */
+import { StateDeclaration, _ViewDeclaration, IInjectable, Transition, HookResult } from './core';
+/**
+ * The signature for Angular 1 State Transition Hooks.
+ *
+ * State hooks are registered as onEnter/onRetain/onExit in state declarations.
+ * State hooks can additionally be injected with $transition$ and $state$ for
+ * the current [[Transition]] and [[StateObject]] in the transition.
+ *
+ * Transition State Hooks are callback functions that hook into the lifecycle events of specific states during a transition.
+ * As a transition runs, it may exit some states, retain (keep) states, and enter states.
+ * As each lifecycle event occurs, the hooks which are registered for the event and that state are called (in priority order).
+ *
+ * #### See also:
+ *
+ * - [[IHookRegistry.onExit]]
+ * - [[IHookRegistry.onRetain]]
+ * - [[IHookRegistry.onEnter]]
+ *
+ * #### Example:
+ * ```js
+ * onEnter: function() { console.log('Entering'); }
+ * ```
+ *
+ * Not minification-safe
+ * ```js
+ * onRetain: function($state$) { console.log('Retained ' + $state$.name); }
+ * ```
+ *
+ * Annotated for minification-safety
+ * ```js
+ * onExit: [ '$transition$', '$state', function($transition$, $state) {
+ *   // always redirect to 'foo' state when being exited
+ *   if ($transition$.to().name !== 'foo') {
+ *     return $state.target('foo');
+ *   }
+ * } ]
+ * ```
+ *
+ * @returns an optional [[HookResult]] which may alter the transition
+ */
+export interface Ng1StateTransitionHook {
+    (...injectables: any[]): HookResult;
+}
+/**
+ * @internalapi
+ * an intermediate interface.
+ *
+ * Used to reset [[StateDeclaration]] typings to `any` so the [[Ng1StateDeclaration]] interface can then narrow them */
+export interface _Ng1StateDeclaration extends StateDeclaration {
+    onExit?: any;
+    onRetain?: any;
+    onEnter?: any;
+    views?: any;
+}
+/**
+ * The StateDeclaration object is used to define a state or nested state.
+ * It should be registered with the [[StateRegistry]].
+ *
+ * #### Example:
+ * ```js
+ * // StateDeclaration object
+ * var foldersState = {
+ *   name: 'folders',
+ *   url: '/folders',
+ *   resolve: {
+ *     allfolders: function(FolderService) {
+ *       return FolderService.list();
+ *     }
+ *   },
+ *   template: "<ul><li ng-repeat='folder in allfolders'>{{folder.name}}</li></ul>",
+ *   controller: function(allfolders, $scope) {
+ *     $scope.allfolders = allfolders;
+ *   }
+ * }
+ * ```
+ *
+ * Since this interface extends [[Ng1ViewDeclaration]], any view declaration properties can be set directly
+ * on the state declaration and they will be applied to the view with the name `$default`.  For example:
+ *
+ * ```js
+ * var state = {
+ *   name: 'foo',
+ *   url: '/foo',
+ *   template: '<h1>foo</h1>',
+ *   controller: 'FooController'
+ * }
+ * ```
+ *
+ * is simply syntactic sugar for:
+ *
+ * ```js
+ * var state = {
+ *   name: 'foo',
+ *   url: '/foo',
+ *   views: {
+ *     $default: {
+ *       template: '<h1>foo</h1>',
+ *       controller: 'FooController'
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * If a state definition contains a `views:` object, any view properties set directly on the state are ignored.
+ * Thus, this is an invalid state defintion:
+ *
+ * ```js
+ * var state = {
+ *   name: 'foo',
+ *   url: '/foo',
+ *   controller: 'FooController', // invalid because views: exists
+ *   views: {
+ *     header: {
+ *       template: '<h1>header</h1>'
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export interface Ng1StateDeclaration extends _Ng1StateDeclaration, Ng1ViewDeclaration {
+    
+}
+export interface Ng1ViewDeclaration extends _ViewDeclaration {
+    /**
+     * The name of the component to use for this view.
+     *
+     * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
+     *
+     * The name of an [angular 1.5+ `.component()`](https://docs.angularjs.org/guide/component) (or directive with
+     * bindToController and/or scope declaration) which will be used for this view.
+     *
+     * Resolve data can be provided to the component via the component's `bindings` object (for 1.3+ directives, the
+     * `bindToController` is used; for other directives, the `scope` declaration is used).  For each binding declared
+     * on the component, any resolve with the same name is set on the component's controller instance.  The binding
+     * is provided to the component as a one-time-binding.  In general, components should likewise declare their
+     * input bindings as [one-way ("&lt;")](https://docs.angularjs.org/api/ng/service/$compile#-scope-).
+     *
+     * Note: inside a "views:" block, a bare string `"foo"` is shorthand for `{ component: "foo" }`
+     *
+     * Note: Mapping from resolve names to component inputs may be specified using [[bindings]].
+     *
+     * #### Example:
+     * ```js
+     * .state('profile', {
+     *   // Use the <my-profile></my-profile> component for the Unnamed view
+     *   component: 'MyProfile',
+     * }
+     *
+     * .state('messages', {
+     *   // use the <nav-bar></nav-bar> component for the view named 'header'
+     *   // use the <message-list></message-list> component for the view named 'content'
+     *   views: {
+     *     header: { component: 'NavBar' },
+     *     content: { component: 'MessageList' }
+     *   }
+     * }
+     *
+     * .state('contacts', {
+     *   // Inside a "views:" block, a bare string "NavBar" is shorthand for { component: "NavBar" }
+     *   // use the <nav-bar></nav-bar> component for the view named 'header'
+     *   // use the <contact-list></contact-list> component for the view named 'content'
+     *   views: {
+     *     header: 'NavBar',
+     *     content: 'ContactList'
+     *   }
+     * }
+     * ```
+     *
+     *
+     * Note: When using `component` to define a view, you may _not_ use any of: `template`, `templateUrl`,
+     * `templateProvider`, `controller`, `controllerProvider`, `controllerAs`.
+     *
+     *
+     * See also: Todd Motto's angular 1.3 and 1.4 [backport of .component()](https://github.com/toddmotto/angular-component)
+     */
+    component?: string;
+    /**
+     * An object which maps `resolve`s to [[component]] `bindings`.
+     *
+     * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
+     *
+     * When using a [[component]] declaration (`component: 'myComponent'`), each input binding for the component is supplied
+     * data from a resolve of the same name, by default.  You may supply data from a different resolve name by mapping it here.
+     *
+     * Each key in this object is the name of one of the component's input bindings.
+     * Each value is the name of the resolve that should be provided to that binding.
+     *
+     * Any component bindings that are omitted from this map get the default behavior of mapping to a resolve of the
+     * same name.
+     *
+     * #### Example:
+     * ```js
+     * $stateProvider.state('foo', {
+     *   resolve: {
+     *     foo: function(FooService) { return FooService.get(); },
+     *     bar: function(BarService) { return BarService.get(); }
+     *   },
+     *   component: 'Baz',
+     *   // The component's `baz` binding gets data from the `bar` resolve
+     *   // The component's `foo` binding gets data from the `foo` resolve (default behavior)
+     *   bindings: {
+     *     baz: 'bar'
+     *   }
+     * });
+     *
+     * app.component('Baz', {
+     *   templateUrl: 'baz.html',
+     *   controller: 'BazController',
+     *   bindings: {
+     *     foo: '<', // foo binding
+     *     baz: '<'  // baz binding
+     *   }
+     * });
+     * ```
+     *
+     */
+    bindings?: {
+        [key: string]: string;
+    };
+    /**
+     * Dynamic component provider function.
+     *
+     * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
+     *
+     * This is an injectable provider function which returns the name of the component to use.
+     * The provider will invoked during a Transition in which the view's state is entered.
+     * The provider is called after the resolve data is fetched.
+     *
+     * #### Example:
+     * ```js
+     * componentProvider: function(MyResolveData, $transition$) {
+     *   if (MyResolveData.foo) {
+     *     return "fooComponent"
+     *   } else if ($transition$.to().name === 'bar') {
+     *     return "barComponent";
+     *   }
+     * }
+     * ```
+     */
+    componentProvider?: IInjectable;
+    /**
+     * The view's controller function or name
+     *
+     * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
+     *
+     * The controller function, or the name of a registered controller.  The controller function will be used
+     * to control the contents of the [[directives.uiView]] directive.
+     *
+     * If specified as a string, controllerAs can be declared here, i.e., "FooController as foo" instead of in
+     * a separate [[controllerAs]] property.
+     *
+     * See: [[Ng1Controller]] for information about component-level router hooks.
+     */
+    controller?: IInjectable | string;
+    /**
+     * A controller alias name.
+     *
+     * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
+     *
+     * If present, the controller will be published to scope under the `controllerAs` name.
+     * See: https://docs.angularjs.org/api/ng/directive/ngController
+     */
+    controllerAs?: string;
+    /**
+     * Dynamic controller provider function.
+     *
+     * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
+     *
+     * This is an injectable provider function which returns the actual controller function, or the name
+     * of a registered controller.  The provider will invoked during a Transition in which the view's state is
+     * entered.  The provider is called after the resolve data is fetched.
+     *
+     * #### Example:
+     * ```js
+     * controllerProvider: function(MyResolveData, $transition$) {
+     *   if (MyResolveData.foo) {
+     *     return "FooCtrl"
+     *   } else if ($transition$.to().name === 'bar') {
+     *     return "BarCtrl";
+     *   } else {
+     *     return function($scope) {
+     *       $scope.baz = "Qux";
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    controllerProvider?: IInjectable;
+    /**
+     * The scope variable name to use for resolve data.
+     *
+     * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
+     *
+     * When a view is activated, the resolved data for the state which the view belongs to is put on the scope.
+     * This property sets the name of the scope variable to use for the resolved data.
+     *
+     * Defaults to `$resolve`.
+     */
+    resolveAs?: string;
+    /**
+     * The HTML template for the view.
+     *
+     * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
+     *
+     * HTML template as a string, or a function which returns an html template as a string.
+     * This template will be used to render the corresponding [[directives.uiView]] directive.
+     *
+     * This property takes precedence over templateUrl.
+     *
+     * If `template` is a function, it will be called with the Transition parameters as the first argument.
+     *
+     * #### Example:
+     * ```js
+     * template: "<h1>inline template definition</h1><div ui-view></div>"
+     * ```
+     *
+     * #### Example:
+     * ```js
+     * template: function(params) {
+     *   return "<h1>generated template</h1>";
+     * }
+     * ```
+     */
+    template?: Function | string;
+    /**
+     * The URL for the HTML template for the view.
+     *
+     * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
+     *
+     * A path or a function that returns a path to an html template.
+     * The template will be fetched and used to render the corresponding [[directives.uiView]] directive.
+     *
+     * If `templateUrl` is a function, it will be called with the Transition parameters as the first argument.
+     *
+     * #### Example:
+     * ```js
+     * templateUrl: "/templates/home.html"
+     * ```
+     *
+     * #### Example:
+     * ```js
+     * templateUrl: function(params) {
+     *   return myTemplates[params.pageId];
+     * }
+     * ```
+     */
+    templateUrl?: string | Function;
+    /**
+     * Injected function which returns the HTML template.
+     *
+     * A property of [[Ng1StateDeclaration]] or [[Ng1ViewDeclaration]]:
+     *
+     * Injected function which returns the HTML template.
+     * The template will be used to render the corresponding [[directives.uiView]] directive.
+     *
+     * #### Example:
+     * ```js
+     * templateProvider: function(MyTemplateService, $transition$) {
+     *   return MyTemplateService.getTemplate($transition$.params().pageId);
+     * }
+     * ```
+     */
+    templateProvider?: IInjectable;
+}
+/**
+ * The shape of a controller for a view (and/or component), defining the controller callbacks.
+ *
+ * A view in UI-Router is comprised of either a `component` ([[Ng1ViewDeclaration.component]]) or a combination of a
+ * `template` (or `templateProvider`) and a `controller` (or `controllerProvider`).
+ *
+ * The `controller` object (or the `component`'s controller object) can define component-level controller callbacks,
+ * which UI-Router will call at the appropriate times.  These callbacks are similar to Transition Hooks
+ * ([[IHookRegistry]]), but are only called if the view is currently active.
+ *
+ * This interface defines the UI-Router component callbacks.
+ *
+ */
+export interface Ng1Controller {
+    /** @hidden */
+    $onInit(): void;
+    /**
+     * This callback is called when parameter values have changed.
+     *
+     * This callback can be used to respond to changing parameter values in the current state, or in parent/child states.
+     * This callback is especially handy when using dynamic parameters ([[ParamDeclaration.dynamic]])
+     *
+     * Called when:
+     * - The view is still active
+     * - A new transition has completed successfully
+     * - The state for the view (controller) was not reloaded
+     * - At least one parameter value was changed
+     *
+     * Called with:
+     * @param newValues an object containing the changed parameter values
+     * @param $transition$ the new Transition which triggered this callback
+     *
+     * #### Example:
+     * ```js
+     * angular.module('foo').controller('FancyCtrl', function() {
+     *   this.uiOnParamsChanged = function(newParams) {
+     *     console.log("new params: ", newParams);
+     *   }
+     * });
+     * ```
+     */
+    uiOnParamsChanged(newValues: any, $transition$: Transition): void;
+    /**
+     * This callback is called when the view's state is about to be exited.
+     *
+     * This callback is used to inform a view that it is about to be exited, due to a new [[Transition]].
+     * The callback can ask for user confirmation, and cancel or alter the new Transition.  The callback should
+     * return a value, or a promise for a value.  If a promise is returned, the new Transition waits until the
+     * promise settles.
+     *
+     *
+     * Called when:
+     * - The view is still active
+     * - A new Transition is about to run
+     * - The new Transition will exit the view's state
+     *
+     * Called with:
+     * - The new Transition
+     *
+     * Relevant return Values:
+     * - `false`: The transition is cancelled.
+     * - A rejected promise: The transition is cancelled.
+     * - [[TargetState]]: The transition is redirected to the new target state.
+     * - Anything else: the transition will continue normally (the state and view will be deactivated)
+     *
+     * #### Example:
+     * ```js
+     * app.component('myComponent', {
+     *   template: '<input ng-model="$ctrl.data" type="text">',
+     *   bindings: { 'data': '<' },
+     *   controller: function() {
+     *
+     *     this.originalData = angular.copy(this.data);
+     *
+     *     this.uiCanExit = function() {
+     *       if (!angular.equals(this.data, this.originalData)) {
+     *         // Note: This could also return a Promise and request async
+     *         // confirmation using something like ui-bootstrap $modal
+     *         return window.confirm("Data has changed.  Exit anyway and lose changes?");
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * @param transition the new Transition that is about to exit the component's state
+     * @return a HookResult, or a promise for a HookResult
+     */
+    uiCanExit(transition: Transition): HookResult;
+}
+/**
+ * Manages which template-loading mechanism to use.
+ *
+ * Defaults to `$templateRequest` on Angular versions starting from 1.3, `$http` otherwise.
+ */
+export interface TemplateFactoryProvider {
+    /**
+     * Forces $templateFactory to use $http instead of $templateRequest.
+     *
+     * UI-Router uses `$templateRequest` by default on angular 1.3+.
+     * Use this method to choose to use `$http` instead.
+     *
+     * ---
+     *
+     * ## Security warning
+     *
+     * This might cause XSS, as $http doesn't enforce the regular security checks for
+     * templates that have been introduced in Angular 1.3.
+     *
+     * See the $sce documentation, section
+     * <a href="https://docs.angularjs.org/api/ng/service/$sce#impact-on-loading-templates">
+     * Impact on loading templates</a> for more details about this mechanism.
+     *
+     * *Note: forcing this to `false` on Angular 1.2.x will crash, because `$templateRequest` is not implemented.*
+     *
+     * @param useUnsafeHttpService `true` to use `$http` to fetch templates
+     */
+    useHttpService(useUnsafeHttpService: boolean): any;
+}
+declare module '@uirouter/core/lib/state/stateRegistry' {
+    interface StateRegistry {
+        register(state: Ng1StateDeclaration | {
+            new (): Ng1StateDeclaration;
+        }): any;
+    }
+}

package/types/router/legacy/resolveService.d.ts

@@ -0,0 +1,44 @@
+/** @publicapi @module ng1 */ /** */
+import { Obj } from './core';
+/** @hidden */
+export declare const resolveFactory: () => {
+    /**
+     * Asynchronously injects a resolve block.
+     *
+     * This emulates most of the behavior of the ui-router 0.2.x $resolve.resolve() service API.
+     *
+     * ### Not bundled by default
+     *
+     * This API is no longer not part of the standard `@uirouter/angularjs` bundle.
+     * For users of the prebuilt bundles, add the `release/resolveService.min.js` UMD bundle.
+     * For bundlers (webpack, browserify, etc), add `@uirouter/angularjs/lib/legacy/resolveService`.
+     *
+     * ---
+     *
+     * Given an object `invocables`, where keys are strings and values are injectable functions,
+     * injects each function, and waits for the resulting promise to resolve.
+     * When all resulting promises are resolved, returns the results as an object.
+     *
+     * #### Example:
+     * ```js
+     * let invocables = {
+     *   foo: [ '$http', ($http) =>
+     *            $http.get('/api/foo').then(resp => resp.data) ],
+     *   bar: [ 'foo', '$http', (foo, $http) =>
+     *            $http.get('/api/bar/' + foo.barId).then(resp => resp.data) ]
+     * }
+     * $resolve.resolve(invocables)
+     *     .then(results => console.log(results.foo, results.bar))
+     * // Logs foo and bar:
+     * // { id: 123, barId: 456, fooData: 'foo data' }
+     * // { id: 456, barData: 'bar data' }
+     * ```
+     *
+     * @param invocables an object which looks like an [[StateDeclaration.resolve]] object; keys are resolve names and values are injectable functions
+     * @param locals key/value pre-resolved data (locals)
+     * @param parent a promise for a "parent resolve"
+     */
+    resolve: (invocables: {
+        [key: string]: Function;
+    }, locals?: {}, parent?: Promise<any>) => Promise<Obj>;
+};

package/types/router/legacy/stateEvents.d.ts

@@ -0,0 +1,123 @@
+import { IAngularEvent } from 'angular';
+/**
+ * An event broadcast on `$rootScope` when the state transition **begins**.
+ *
+ * ### Deprecation warning: use [[TransitionService.onStart]] instead
+ *
+ * You can use `event.preventDefault()`
+ * to prevent the transition from happening and then the transition promise will be
+ * rejected with a `'transition prevented'` value.
+ *
+ * Additional arguments to the event handler are provided:
+ * - `toState`: the Transition Target state
+ * - `toParams`: the Transition Target Params
+ * - `fromState`: the state the transition is coming from
+ * - `fromParams`: the parameters from the state the transition is coming from
+ * - `options`: any Transition Options
+ * - `$transition$`: the [[Transition]]
+ *
+ * #### Example:
+ * ```js
+ * $rootScope.$on('$stateChangeStart', function(event, transition) {
+ *   event.preventDefault();
+ *   // transitionTo() promise will be rejected with
+ *   // a 'transition prevented' error
+ * })
+ * ```
+ *
+ * @event $stateChangeStart
+ * @deprecated
+ */
+export declare let $stateChangeStart: IAngularEvent;
+/**
+ * An event broadcast on `$rootScope` if a transition is **cancelled**.
+ *
+ * ### Deprecation warning: use [[TransitionService.onStart]] instead
+ *
+ * Additional arguments to the event handler are provided:
+ * - `toState`: the Transition Target state
+ * - `toParams`: the Transition Target Params
+ * - `fromState`: the state the transition is coming from
+ * - `fromParams`: the parameters from the state the transition is coming from
+ * - `options`: any Transition Options
+ * - `$transition$`: the [[Transition]] that was cancelled
+ *
+ * @event $stateChangeCancel
+ * @deprecated
+ */
+export declare let $stateChangeCancel: IAngularEvent;
+/**
+ * An event broadcast on `$rootScope` once the state transition is **complete**.
+ *
+ * ### Deprecation warning: use [[TransitionService.onStart]] and [[Transition.promise]], or [[Transition.onSuccess]]
+ *
+ * Additional arguments to the event handler are provided:
+ * - `toState`: the Transition Target state
+ * - `toParams`: the Transition Target Params
+ * - `fromState`: the state the transition is coming from
+ * - `fromParams`: the parameters from the state the transition is coming from
+ * - `options`: any Transition Options
+ * - `$transition$`: the [[Transition]] that just succeeded
+ *
+ * @event $stateChangeSuccess
+ * @deprecated
+ */
+export declare let $stateChangeSuccess: IAngularEvent;
+/**
+ * An event broadcast on `$rootScope` when an **error occurs** during transition.
+ *
+ * ### Deprecation warning: use [[TransitionService.onStart]] and [[Transition.promise]], or [[Transition.onError]]
+ *
+ * It's important to note that if you
+ * have any errors in your resolve functions (javascript errors, non-existent services, etc)
+ * they will not throw traditionally. You must listen for this $stateChangeError event to
+ * catch **ALL** errors.
+ *
+ * Additional arguments to the event handler are provided:
+ * - `toState`: the Transition Target state
+ * - `toParams`: the Transition Target Params
+ * - `fromState`: the state the transition is coming from
+ * - `fromParams`: the parameters from the state the transition is coming from
+ * - `error`: The reason the transition errored.
+ * - `options`: any Transition Options
+ * - `$transition$`: the [[Transition]] that errored
+ *
+ * @event $stateChangeError
+ * @deprecated
+ */
+export declare let $stateChangeError: IAngularEvent;
+/**
+ * An event broadcast on `$rootScope` when a requested state **cannot be found** using the provided state name.
+ *
+ * ### Deprecation warning: use [[StateService.onInvalid]] instead
+ *
+ * The event is broadcast allowing any handlers a single chance to deal with the error (usually by
+ * lazy-loading the unfound state). A `TargetState` object is passed to the listener handler,
+ * you can see its properties in the example. You can use `event.preventDefault()` to abort the
+ * transition and the promise returned from `transitionTo()` will be rejected with a
+ * `'transition aborted'` error.
+ *
+ * Additional arguments to the event handler are provided:
+ * - `unfoundState` Unfound State information. Contains: `to, toParams, options` properties.
+ * - `fromState`: the state the transition is coming from
+ * - `fromParams`: the parameters from the state the transition is coming from
+ * - `options`: any Transition Options
+ *
+ * #### Example:
+ * ```js
+ * // somewhere, assume lazy.state has not been defined
+ * $state.go("lazy.state", { a: 1, b: 2 }, { inherit: false });
+ *
+ * // somewhere else
+ * $scope.$on('$stateNotFound', function(event, transition) {
+ * function(event, unfoundState, fromState, fromParams){
+ *     console.log(unfoundState.to); // "lazy.state"
+ *     console.log(unfoundState.toParams); // {a:1, b:2}
+ *     console.log(unfoundState.options); // {inherit:false} + default options
+ * });
+ * ```
+ *
+ * @event $stateNotFound
+ * @deprecated
+ */
+export declare let $stateNotFound: IAngularEvent;

package/types/router/locationServices.d.ts

@@ -0,0 +1,43 @@
+/** @publicapi @module ng1 */ /** */
+import { LocationConfig, LocationServices, UIRouter } from './core';
+import { ILocationService, ILocationProvider, IWindowService } from '../index';
+/**
+ * Implements UI-Router LocationServices and LocationConfig using Angular 1's $location service
+ * @internalapi
+ */
+export declare class Ng1LocationServices implements LocationConfig, LocationServices {
+    private $locationProvider;
+    private $location;
+    private $sniffer;
+    private $browser;
+    private $window;
+    path: any;
+    search: any;
+    hash: any;
+    hashPrefix: any;
+    port: any;
+    protocol: any;
+    host: any;
+    private _baseHref;
+    private _urlListeners;
+    /**
+     * Applys ng1-specific path parameter encoding
+     *
+     * The Angular 1 `$location` service is a bit weird.
+     * It doesn't allow slashes to be encoded/decoded bi-directionally.
+     *
+     * See the writeup at https://github.com/angular-ui/ui-router/issues/2598
+     *
+     * This code patches the `path` parameter type so it encoded/decodes slashes as ~2F
+     *
+     * @param router
+     */
+    static monkeyPatchPathParameterType(router: UIRouter): void;
+    dispose(): void;
+    constructor($locationProvider: ILocationProvider);
+    onChange(callback: Function): () => Function[];
+    html5Mode(): any;
+    baseHref(): any;
+    url(newUrl?: string, replace?: boolean, state?: any): string;
+    _runtimeServices($rootScope: any, $location: ILocationService, $sniffer: any, $browser: any, $window: IWindowService): void;
+}