@angular-wave/angular.ts 0.0.29 → 0.0.31

package/test/router/view.spec.js

@@ -21,7 +21,7 @@ describe("view", () => {
     $injector,
     elem,
     $controllerProvider,
-    $urlMatcherFactoryProvider,
+    $urlServiceProvider,
     $view,
     $q;
   let root, states;
@@ -34,16 +34,12 @@ describe("view", () => {
     window.angular
       .module("defaultModule", ["ng.router"])
       .config(
-        function (
-          _$provide_,
-          _$controllerProvider_,
-          _$urlMatcherFactoryProvider_,
-        ) {
+        function (_$provide_, _$controllerProvider_, _$urlServiceProvider_) {
           _$provide_.factory("foo", () => {
             return "Foo";
           });
           $controllerProvider = _$controllerProvider_;
-          $urlMatcherFactoryProvider = _$urlMatcherFactoryProvider_;
+          $urlServiceProvider = _$urlServiceProvider_;
         },
       );
     $injector = window.angular.bootstrap(document.getElementById("dummy"), [
@@ -58,10 +54,7 @@ describe("view", () => {
 
       states = {};
       const matcher = new StateMatcher(states);
-      const stateBuilder = new StateBuilder(
-        matcher,
-        $urlMatcherFactoryProvider,
-      );
+      const stateBuilder = new StateBuilder(matcher, $urlServiceProvider);
       stateBuilder.builder("views", ng1ViewsBuilder);
       register = registerState(states, stateBuilder);
       root = register({ name: "" });

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

@@ -39,7 +39,7 @@ export interface CoreServices {
  * Implementors should pass these through to the underlying URL mechanism.
  * The underlying URL mechanism might be browser APIs, framework APIs, or some 3rd party URL management library.
  *
- * UI-Router Core includes three basic implementations:
+ * Router Core includes three basic implementations:
  *
  * - [[PushStateLocationService]]
  * - [[HashLocationService]]
@@ -61,7 +61,7 @@ export interface LocationServices {
  * Implementors should pass these through to the underlying URL APIs.
  * The underlying URL mechanism might be browser APIs, framework APIs, or some 3rd party URL management library.
  *
- * UI-Router Core includes two basic implementations:
+ * Router Core includes two basic implementations:
  *
  * - [[BrowserLocationConfig]]
  * - [[MemoryLocationConfig]]

package/types/router/core/common/trace.d.ts

@@ -1,6 +1,6 @@
 import { Transition } from "../transition/transition";
 import { ViewTuple } from "../view";
-import { ActiveUIView, ViewConfig, ViewContext } from "../view/interface";
+import { ActiveNGView, ViewConfig, ViewContext } from "../view/interface";
 import { Resolvable } from "../resolve/resolvable";
 import { PathNode } from "../path/pathNode";
 import { PolicyWhen } from "../resolve/interface";
@@ -24,12 +24,12 @@ declare enum Category {
   RESOLVE = 0,
   TRANSITION = 1,
   HOOK = 2,
-  UIVIEW = 3,
+  NGVIEW = 3,
   VIEWCONFIG = 4,
 }
 export { Category };
 /**
- * Prints UI-Router Transition trace information to the console.
+ * Prints Router Transition trace information to the console.
  */
 export declare class Trace {
   /** @internal */
@@ -101,17 +101,17 @@ export declare class Trace {
   /** @internal called by ui-router code */
   traceSuccess(finalState: StateObject, trans: Transition): void;
   /** @internal called by ui-router code */
-  traceUIViewEvent(event: string, viewData: ActiveUIView, extra?: string): void;
+  traceNGViewEvent(event: string, viewData: ActiveNGView, extra?: string): void;
   /** @internal called by ui-router code */
-  traceUIViewConfigUpdated(viewData: ActiveUIView, context: ViewContext): void;
+  traceNGViewConfigUpdated(viewData: ActiveNGView, context: ViewContext): void;
   /** @internal called by ui-router code */
-  traceUIViewFill(viewData: ActiveUIView, html: string): void;
+  traceNGViewFill(viewData: ActiveNGView, html: string): void;
   /** @internal called by ui-router code */
   traceViewSync(pairs: ViewTuple[]): void;
   /** @internal called by ui-router code */
   traceViewServiceEvent(event: string, viewConfig: ViewConfig): void;
   /** @internal called by ui-router code */
-  traceViewServiceUIViewEvent(event: string, viewData: ActiveUIView): void;
+  traceViewServiceNGViewEvent(event: string, viewData: ActiveNGView): void;
 }
 /**
  * The [[Trace]] singleton

package/types/router/core/globals.d.ts

@@ -3,12 +3,13 @@ import { StateDeclaration } from "./state/interface";
 import { StateObject } from "./state/stateObject";
 import { Transition } from "./transition/transition";
 import { Queue } from "./common/queue";
+/**
  * Global router state
  *
  * This is where we hold the global mutable state such as current state, current
  * params, current transition, etc.
  */
-export declare class UIRouterGlobals {
+export declare class RouterGlobals {
   /**
    * Current parameter values
    *

package/types/router/core/interface.d.ts

@@ -1,9 +1,9 @@
-import { UIRouter } from "./router";
+import { Router } from "./router";
 /**
  * An interface for getting values from dependency injection.
  *
  * This is primarily used to get resolve values for a given token.
- * An instance of the `UIInjector` can be retrieved from the current transition using [[Transition.injector]].
+ * An instance of the `NGInjector` can be retrieved from the current transition using [[Transition.injector]].
  *
  * ---
  *
@@ -13,7 +13,7 @@ import { UIRouter } from "./router";
  * In Angular 2, the native injector might be the root Injector,
  * or it might be a lazy loaded `NgModule` injector scoped to a lazy load state tree.
  */
-export interface UIInjector {
+export interface NGInjector {
   /**
    * Gets a value from the injector.
    *
@@ -89,10 +89,3 @@ export interface UIInjector {
   getNative(token: any): any;
   getNative<T>(token: any): T;
 }
-export interface UIRouterPlugin {
-  name: string;
-}
-export declare abstract class UIRouterPluginBase implements UIRouterPlugin {
-  abstract name: string;
-  dispose(router: UIRouter): void;
-}

package/types/router/core/params/interface.d.ts

@@ -53,7 +53,7 @@ export interface ParamDeclaration {
    * Specifies the default value for this parameter.
    * This implicitly sets this parameter as optional.
    *
-   * When UI-Router routes to a state and no value is specified for this parameter in the URL or transition,
+   * When Router routes to a state and no value is specified for this parameter in the URL or transition,
    * the default value will be used instead.
    * If value is a function, it will be injected and invoked, and the return value used.
    *
@@ -245,7 +245,7 @@ export interface ParamDeclaration {
    * Normally, if a parameter value changes, the state which declared that the parameter will be reloaded (entered/exited).
    * When a parameter is `dynamic`, a transition still occurs, but it does not cause the state to exit/enter.
    *
-   * This can be useful to build UI where the component updates itself when the param values change.
+   * This can be useful to build NG where the component updates itself when the param values change.
    * A common scenario where this is useful is searching/paging/sorting.
    *
    * ---
@@ -373,7 +373,7 @@ export interface Replace {
  * - some internal string representation
  *
  * Typed parameter definitions control how parameter values are encoded (to the URL) and decoded (from the URL).
- * UI-Router always provides the decoded parameter values to the user (from methods such as [[Transition.params]])).
+ * Router always provides the decoded parameter values to the user (from methods such as [[Transition.params]])).
  *
  * For example, if a state has a url of `/foo/{fooId:int}` (the `fooId` parameter is of the `int` ParamType)
  * and if the browser is at `/foo/123`, then the 123 is parsed as an integer:
@@ -395,7 +395,7 @@ export interface Replace {
  * @example
  * ```
  *
- * $urlMatcherFactoryProvider.type('intarray', {
+ * $urlServiceProvider.type('intarray', {
  *   // Take an array of ints [1,2,3] and return a string "1-2-3"
  *   encode: (array) => array.join("-"),
  *
@@ -432,7 +432,7 @@ export interface Replace {
  *
  * var list = ['John', 'Paul', 'George', 'Ringo'];
  *
- * $urlMatcherFactoryProvider.type('listItem', {
+ * $urlServiceProvider.type('listItem', {
  *   encode: function(item) {
  *     // Represent the list item in the URL using its corresponding index
  *     return list.indexOf(item);

package/types/router/core/resolve/resolveContext.d.ts

@@ -3,12 +3,12 @@ import { PathNode } from "../path/pathNode";
 import { Resolvable } from "./resolvable";
 import { StateObject } from "../state/stateObject";
 import { Transition } from "../transition/transition";
-import { UIInjector } from "../interface";
+import { NGInjector } from "../interface";
 export declare const NATIVE_INJECTOR_TOKEN: string;
 /**
  * Encapsulates Dependency Injection for a path of nodes
  *
- * UI-Router states are organized as a tree.
+ * Router states are organized as a tree.
  * A nested state has a path of ancestors to the root of the tree.
  * When a state is being activated, each element in the path is wrapped as a [[PathNode]].
  * A `PathNode` is a stateful object that holds things like parameters and resolvables for the state being activated.
@@ -17,7 +17,7 @@ export declare const NATIVE_INJECTOR_TOKEN: string;
  */
 export declare class ResolveContext {
   private _path;
-  _injector: UIInjector;
+  _injector: NGInjector;
   constructor(_path: PathNode[]);
   /** Gets all the tokens found in the resolve context, de-duplicated */
   getTokens(): any[];
@@ -86,7 +86,7 @@ export declare class ResolveContext {
       value: any;
     }[]
   >;
-  injector(): UIInjector;
+  injector(): NGInjector;
   findNode(resolvable: Resolvable): PathNode;
   /**
    * Gets the async dependencies of a Resolvable

package/types/router/core/router.d.ts

@@ -4,17 +4,16 @@ import { TransitionService } from "./transition/transitionService";
 import { ViewService } from "./view/view";
 import { StateRegistry } from "./state/stateRegistry";
 import { StateService } from "./state/stateService";
-import { UIRouterGlobals } from "./globals";
-import { UIRouterPlugin } from "./interface";
+import { RouterGlobals } from "./globals";
 import { UrlService } from "./url/urlService";
 import { LocationServices, LocationConfig } from "./common/coreservices";
 import { Trace } from "./common/trace";
 /**
- * An instance of UI-Router.
+ * An instance of Router.
  *
  * This object contains references to service APIs which define your application's routing behavior.
  */
-export declare class UIRouter {
+export declare class Router {
   locationService: LocationServices;
   locationConfig: LocationConfig;
   /** @internal */ $id: number;
@@ -25,7 +24,7 @@ export declare class UIRouter {
   /** Provides services related to ui-view synchronization */
   viewService: ViewService;
   /** An object that contains global router state, such as the current state and params */
-  globals: UIRouterGlobals;
+  globals: RouterGlobals;
   /** A service that exposes global Transition Hooks */
   transitionService: TransitionService;
   /**
@@ -44,23 +43,8 @@ export declare class UIRouter {
   stateRegistry: StateRegistry;
   /** Provides services related to states */
   stateService: StateService;
-  /** @internal plugin instances are registered here */
-  private _plugins;
-
   /**
-   * Disposes this router instance
-   *
-   * When called, clears resources retained by the router by calling `dispose(this)` on all
-   * registered [[disposable]] objects.
-   *
-   * Or, if a `disposable` object is provided, calls `dispose(this)` on that object only.
-   *
-   * @internal
-   * @param disposable (optional) the disposable to dispose
-   */
-  dispose(disposable?: any): void;
-  /**
-   * Creates a new `UIRouter` object
+   * Creates a new `Router` object
    *
    * @param locationService a [[LocationServices]] implementation
    * @param locationConfig a [[LocationConfig]] implementation
@@ -70,34 +54,4 @@ export declare class UIRouter {
     locationService?: LocationServices,
     locationConfig?: LocationConfig,
   );
-  /** Add plugin (as ES6 class) */
-  plugin<T extends UIRouterPlugin>(
-    plugin: {
-      new (router: UIRouter, options?: any): T;
-    },
-    options?: any,
-  ): T;
-  /** Add plugin (as javascript constructor function) */
-  plugin<T extends UIRouterPlugin>(
-    plugin: {
-      (router: UIRouter, options?: any): void;
-    },
-    options?: any,
-  ): T;
-  /** Add plugin (as javascript factory function) */
-  plugin<T extends UIRouterPlugin>(plugin: PluginFactory<T>, options?: any): T;
-  /**
-   * Returns a plugin registered with the given `pluginName`.
-   *
-   * @param pluginName the name of the plugin to get
-   * @return the plugin, or undefined
-   */
-  getPlugin(pluginName: string): UIRouterPlugin;
-  /**
-   * Returns all registered plugins
-   * @return all registered plugins
-   */
-  getPlugin(): UIRouterPlugin[];
 }
-/** @internal */
-export declare type PluginFactory<T> = (router: UIRouter, options?: any) => T;

package/types/router/core/state/interface.d.ts

@@ -31,7 +31,7 @@ export declare type ResolveTypes =
  * Base interface for declaring a view
  *
  * This interface defines the basic data that a normalized view declaration will have on it.
- * Each implementation of UI-Router (for a specific framework) should define its own extension of this interface.
+ * Each implementation of Router (for a specific framework) should define its own extension of this interface.
  * Add any additional fields that the framework requires to that interface.
  */
 export interface _ViewDeclaration {
@@ -86,7 +86,7 @@ export declare type RedirectToResult =
 /**
  * The StateDeclaration object is used to define a state or nested state.
  *
- * Note: Each implementation of UI-Router (for a specific framework)
+ * Note: Each implementation of Router (for a specific framework)
  * extends this interface as necessary.
  *
  * #### Example:
@@ -203,7 +203,7 @@ export interface StateDeclaration {
    * - Each key (string) is the name of the dependency.
    * - Each value (function) is an injectable function which returns the dependency, or a promise for the dependency.
    *
-   * This style is based on AngularJS injectable functions, but can be used with any UI-Router implementation.
+   * This style is based on AngularJS injectable functions, but can be used with any Router implementation.
    * If your code will be minified, the function should be ["annotated" in the AngularJS manner](https://docs.angularjs.org/guide/di#dependency-annotation).
    *
    * #### AngularJS Example:
@@ -257,7 +257,7 @@ export interface StateDeclaration {
    *
    * #### Special injectable tokens
    *
-   * - `UIRouter`: The [[UIRouter]] instance which has references to all the UI-Router services.
+   * - `Router`: The [[Router]] instance which has references to all the Router services.
    * - `Transition`: The current [[Transition]] object; information and API about the current transition, such as
    *    "to" and "from" State Parameters and transition options.
    * - `'$transition$'`: A string alias for the `Transition` injectable
@@ -428,7 +428,7 @@ export interface StateDeclaration {
    *
    * Note: `redirectTo` is processed as an `onStart` hook, before `LAZY` resolves.
    * If your redirect function relies on resolve data, get the [[Transition.injector]] and get a
-   * promise for the resolve data using [[UIInjector.getAsync]].
+   * promise for the resolve data using [[NGInjector.getAsync]].
    *
    * #### Example:
    * ```js
@@ -595,7 +595,7 @@ export interface StateDeclaration {
    *   It matches any state name that starts with the `name` (including child states that are not yet loaded).
    * - A `url` prefix.
    *   A future state's `url` property acts as a wildcard.
-   *   UI-Router matches all paths that begin with the `url`.
+   *   Router matches all paths that begin with the `url`.
    *   It effectively appends `.*` to the internal regular expression.
    *   When the prefix matches, the future state will begin loading.
    * - A `lazyLoad` function.

package/types/router/core/state/stateObject.d.ts

@@ -12,7 +12,7 @@ import { TargetState } from "./targetState";
 import { Transition } from "../transition/transition";
 import { Glob } from "../common/glob";
 /**
- * Internal representation of a UI-Router state.
+ * Internal representation of a Router state.
  *
  * Instances of this class are created when a [[StateDeclaration]] is registered with the [[StateRegistry]].
  *

package/types/router/core/state/stateQueueManager.d.ts

@@ -2,7 +2,7 @@ import { _StateDeclaration } from "./interface";
 import { StateObject } from "./stateObject";
 import { StateBuilder } from "./stateBuilder";
 import { StateRegistryListener } from "./stateRegistry";
-import { UIRouter } from "../router";
+import { Router } from "../router";
 export declare class StateQueueManager {
   private router;
   states: {
@@ -12,7 +12,7 @@ export declare class StateQueueManager {
   listeners: StateRegistryListener[];
   queue: StateObject[];
   constructor(
-    router: UIRouter,
+    router: Router,
     states: {
       [key: string]: StateObject;
     },

package/types/router/core/state/stateRegistry.d.ts

@@ -4,7 +4,7 @@ import { StateQueueManager } from "./stateQueueManager";
 import { StateDeclaration, _StateDeclaration } from "./interface";
 import { BuilderFunction } from "./stateBuilder";
 import { StateOrName } from "./interface";
-import { UIRouter } from "../router";
+import { Router } from "../router";
 /**
  * The signature for the callback function provided to [[StateRegistry.onStatesChanged]].
  *
@@ -20,7 +20,7 @@ export declare type StateRegistryListener = (
 /**
  * A registry for all of the application's [[StateDeclaration]]s
  *
- * This API is found at `router.stateRegistry` ([[UIRouter.stateRegistry]])
+ * This API is found at `router.stateRegistry` ([[Router.stateRegistry]])
  */
 export declare class StateRegistry {
   init($injector: any): void;
@@ -35,7 +35,7 @@ export declare class StateRegistry {
   /** @internal */
   listeners: StateRegistryListener[];
   /** @internal */
-  constructor(router: UIRouter);
+  constructor(router: Router);
   /** @internal */
   private _registerRoot;
   /**
@@ -73,7 +73,7 @@ export declare class StateRegistry {
    * Gets the implicit root state
    *
    * Gets the root of the state tree.
-   * The root state is implicitly created by UI-Router.
+   * The root state is implicitly created by Router.
    * Note: this returns the internal [[StateObject]] representation, not a [[StateDeclaration]]
    *
    * @return the root [[StateObject]]

package/types/router/core/state/stateService.d.ts

@@ -10,18 +10,18 @@ import {
 import { StateObject } from "./stateObject";
 import { TargetState } from "./targetState";
 import { RawParams } from "../params/interface";
-import { UIRouter } from "../router";
-import { UIInjector } from "../interface";
+import { Router } from "../router";
+import { NGInjector } from "../interface";
 import { StateParams } from "../params/stateParams";
 export declare type OnInvalidCallback = (
   toState?: TargetState,
   fromState?: TargetState,
-  injector?: UIInjector,
+  injector?: NGInjector,
 ) => HookResult;
 /**
  * Provides services related to ui-router states.
  *
- * This API is located at `router.stateService` ([[UIRouter.stateService]])
+ * This API is located at `router.stateService` ([[Router.stateService]])
  */
 export declare class StateService {
   private router;
@@ -30,29 +30,29 @@ export declare class StateService {
   /**
    * The [[Transition]] currently in progress (or null)
    *
-   * @deprecated This is a passthrough through to [[UIRouterGlobals.transition]]
+   * @deprecated This is a passthrough through to [[RouterGlobals.transition]]
    */
   transition: Transition;
   /**
    * The latest successful state parameters
    *
-   * @deprecated This is a passthrough through to [[UIRouterGlobals.params]]
+   * @deprecated This is a passthrough through to [[RouterGlobals.params]]
    */
   params: StateParams;
   /**
    * The current [[StateDeclaration]]
    *
-   * @deprecated This is a passthrough through to [[UIRouterGlobals.current]]
+   * @deprecated This is a passthrough through to [[RouterGlobals.current]]
    */
   current: StateDeclaration;
   /**
    * The current [[StateObject]] (an internal API)
    *
-   * @deprecated This is a passthrough through to [[UIRouterGlobals.$current]]
+   * @deprecated This is a passthrough through to [[RouterGlobals.$current]]
    */
   $current: StateObject;
   /** @internal */
-  constructor(/** @internal */ router: UIRouter);
+  constructor(/** @internal */ router: Router);
 
   /**
    * Handler for when [[transitionTo]] is called with an invalid state.

package/types/router/core/state/targetState.d.ts

@@ -25,7 +25,7 @@ import { RawParams } from "../params";
  * 3) and transition options
  * 4) the registered state object (the [[StateDeclaration]])
  *
- * Many UI-Router APIs such as [[StateService.go]] take a [[StateOrName]] argument which can
+ * Many Router APIs such as [[StateService.go]] take a [[StateOrName]] argument which can
  * either be a *state object* (a [[StateDeclaration]] or [[StateObject]]) or a *state name* (a string).
  * The `TargetState` class normalizes those options.
  *

package/types/router/core/transition/interface.d.ts

@@ -103,7 +103,7 @@ export interface TransitionHookOptions {
  *
  * Get a TreeChanges object using [[Transition.treeChanges]]
  *
- * A UI-Router Transition is from one Path in a State Tree to another Path.  For a given Transition,
+ * A Router Transition is from one Path in a State Tree to another Path.  For a given Transition,
  * this object stores the "to" and "from" paths, as well as subsets of those: the "retained",
  * "exiting" and "entering" paths.
  *

package/types/router/core/transition/transition.d.ts

@@ -15,8 +15,8 @@ import { StateObject } from "../state/stateObject";
 import { TargetState } from "../state/targetState";
 import { Resolvable } from "../resolve/resolvable";
 import { ViewConfig } from "../view/interface";
-import { UIRouter } from "../router";
-import { UIInjector } from "../interface";
+import { Router } from "../router";
+import { NGInjector } from "../interface";
 import { ResolvableLiteral } from "../resolve/interface";
 import { Rejection } from "./rejectFactory";
 /**
@@ -37,11 +37,11 @@ export declare class Transition implements IHookRegistry {
    */
   $id: number;
   /**
-   * A reference to the [[UIRouter]] instance
+   * A reference to the [[Router]] instance
    *
    * This reference can be used to access the router services, such as the [[StateService]]
    */
-  router: UIRouter;
+  router: Router;
   /** @internal */
   private _deferred;
   /**
@@ -139,10 +139,10 @@ export declare class Transition implements IHookRegistry {
    * @param fromPath The path of [[PathNode]]s from which the transition is leaving.  The last node in the `fromPath`
    *        encapsulates the "from state".
    * @param targetState The target state and parameters being transitioned to (also, the transition options)
-   * @param router The [[UIRouter]] instance
+   * @param router The [[Router]] instance
    * @internal
    */
-  constructor(fromPath: PathNode[], targetState: TargetState, router: UIRouter);
+  constructor(fromPath: PathNode[], targetState: TargetState, router: Router);
   private applyViewConfigs;
   /**
    * @internal
@@ -283,12 +283,12 @@ export declare class Transition implements IHookRegistry {
   };
   paramsChanged<T>(): T;
   /**
-   * Creates a [[UIInjector]] Dependency Injector
+   * Creates a [[NGInjector]] Dependency Injector
    *
    * Returns a Dependency Injector for the Transition's target state (to state).
    * The injector provides resolve values which the target state has access to.
    *
-   * The `UIInjector` can also provide values from the native root/global injector (ng1/ng2).
+   * The `NGInjector` can also provide values from the native root/global injector (ng1/ng2).
    *
    * #### Example:
    * ```js
@@ -300,7 +300,7 @@ export declare class Transition implements IHookRegistry {
    * ```
    *
    * In some cases (such as `onBefore`), you may need access to some resolve data but it has not yet been fetched.
-   * You can use [[UIInjector.getAsync]] to get a promise for the data.
+   * You can use [[NGInjector.getAsync]] to get a promise for the data.
    * #### Example:
    * ```js
    * .onBefore({}, trans => {
@@ -335,9 +335,9 @@ export declare class Transition implements IHookRegistry {
    * @param state Limits the resolves provided to only the resolves the provided state has access to.
    * @param pathName Default: `'to'`: Chooses the path for which to create the injector. Use this to access resolves for `exiting` states.
    *
-   * @returns a [[UIInjector]]
+   * @returns a [[NGInjector]]
    */
-  injector(state?: StateOrName, pathName?: string): UIInjector;
+  injector(state?: StateOrName, pathName?: string): NGInjector;
   /**
    * Gets all available resolve tokens (keys)
    *
@@ -376,7 +376,7 @@ export declare class Transition implements IHookRegistry {
    *
    * Allows a transition hook to dynamically add a Resolvable to this Transition.
    *
-   * Use the [[Transition.injector]] to retrieve the resolved data in subsequent hooks ([[UIInjector.get]]).
+   * Use the [[Transition.injector]] to retrieve the resolved data in subsequent hooks ([[NGInjector.get]]).
    *
    * If a `state` argument is provided, the Resolvable is processed when that state is being entered.
    * If no `state` is provided then the root state is used.

package/types/router/core/transition/transitionService.d.ts

@@ -17,7 +17,7 @@ import { RegisteredHook } from "./hookRegistry";
 import { TargetState } from "../state/targetState";
 import { PathNode } from "../path/pathNode";
 import { ViewService } from "../view/view";
-import { UIRouter } from "../router";
+import { Router } from "../router";
 import { TransitionEventType } from "./transitionEventType";
 import { GetResultHandler, GetErrorHandler } from "./transitionHook";
 /**
@@ -77,9 +77,9 @@ export interface TransitionServicePluginAPI {
  * - It allows the default transition error handler to be set.
  * - It also has a factory function for creating new [[Transition]] objects, (used internally by the [[StateService]]).
  *
- * At bootstrap, [[UIRouter]] creates a single instance (singleton) of this class.
+ * At bootstrap, [[Router]] creates a single instance (singleton) of this class.
  *
- * This API is located at `router.transitionService` ([[UIRouter.transitionService]])
+ * This API is located at `router.transitionService` ([[Router.transitionService]])
  */
 export declare class TransitionService implements IHookRegistry {
   /** @internal */
@@ -119,7 +119,7 @@ export declare class TransitionService implements IHookRegistry {
     lazyLoad: Function;
   };
   /** @internal */
-  constructor(_router: UIRouter);
+  constructor(_router: Router);
   /**
    * Registers a [[TransitionHookFn]], called *while a transition is being constructed*.
    *
@@ -200,7 +200,7 @@ export declare class TransitionService implements IHookRegistry {
    * dispose
    * @internal
    */
-  dispose(router: UIRouter): void;
+  dispose(router: Router): void;
   /**
    * Creates a new [[Transition]] object
    *

package/types/router/core/url/interface.d.ts

@@ -9,7 +9,7 @@
  * @preferred
  */
 import { LocationConfig } from "../common";
-import { UIRouter } from "../router";
+import { Router } from "../router";
 import {
   StateDeclaration,
   StateObject,
@@ -83,7 +83,7 @@ export interface MatchResult {
  * @return the matched value, either truthy or falsey
  */
 export interface UrlRuleMatchFn {
-  (url?: UrlParts, router?: UIRouter): any;
+  (url?: UrlParts, router?: Router): any;
 }
 /**
  * Handler invoked when a rule is matched
@@ -98,7 +98,7 @@ export interface UrlRuleHandlerFn {
   (
     matchValue?: any,
     url?: UrlParts,
-    router?: UIRouter,
+    router?: Router,
   ): string | TargetState | TargetStateDef | void;
 }
 /** @internal */