@angular-wave/angular.ts 0.0.20 → 0.0.22

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

@@ -1,17 +1,26 @@
-import { TransitionHookPhase, PathType } from './interface';
-import { GetErrorHandler, GetResultHandler } from './transitionHook';
+import { TransitionHookPhase, PathType } from "./interface";
+import { GetErrorHandler, GetResultHandler } from "./transitionHook";
 /**
  * This class defines a type of hook, such as `onBefore` or `onEnter`.
  * Plugins can define custom hook types, such as sticky states does for `onInactive`.
  */
 export declare class TransitionEventType {
-    name: string;
-    hookPhase: TransitionHookPhase;
-    hookOrder: number;
-    criteriaMatchPath: PathType;
-    reverseSort: boolean;
-    getResultHandler: GetResultHandler;
-    getErrorHandler: GetErrorHandler;
-    synchronous: boolean;
-    constructor(name: string, hookPhase: TransitionHookPhase, hookOrder: number, criteriaMatchPath: PathType, reverseSort?: boolean, getResultHandler?: GetResultHandler, getErrorHandler?: GetErrorHandler, synchronous?: boolean);
+  name: string;
+  hookPhase: TransitionHookPhase;
+  hookOrder: number;
+  criteriaMatchPath: PathType;
+  reverseSort: boolean;
+  getResultHandler: GetResultHandler;
+  getErrorHandler: GetErrorHandler;
+  synchronous: boolean;
+  constructor(
+    name: string,
+    hookPhase: TransitionHookPhase,
+    hookOrder: number,
+    criteriaMatchPath: PathType,
+    reverseSort?: boolean,
+    getResultHandler?: GetResultHandler,
+    getErrorHandler?: GetErrorHandler,
+    synchronous?: boolean,
+  );
 }

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

@@ -1,88 +1,96 @@
-import { TransitionHookOptions, HookResult } from './interface';
-import { Transition } from './transition';
-import { TransitionEventType } from './transitionEventType';
-import { RegisteredHook } from './hookRegistry';
-import { StateDeclaration } from '../state/interface';
+import { TransitionHookOptions, HookResult } from "./interface";
+import { Transition } from "./transition";
+import { TransitionEventType } from "./transitionEventType";
+import { RegisteredHook } from "./hookRegistry";
+import { StateDeclaration } from "../state/interface";
 export declare type GetResultHandler = (hook: TransitionHook) => ResultHandler;
 export declare type GetErrorHandler = (hook: TransitionHook) => ErrorHandler;
 export declare type ResultHandler = (result: HookResult) => Promise<HookResult>;
 export declare type ErrorHandler = (error: any) => Promise<any>;
 export declare class TransitionHook {
-    private transition;
-    private stateContext;
-    private registeredHook;
-    private options;
-    type: TransitionEventType;
-    /**
-     * These GetResultHandler(s) are used by [[invokeHook]] below
-     * Each HookType chooses a GetResultHandler (See: [[TransitionService._defineCoreEvents]])
-     */
-    static HANDLE_RESULT: GetResultHandler;
-    /**
-     * If the result is a promise rejection, log it.
-     * Otherwise, ignore the result.
-     */
-    static LOG_REJECTED_RESULT: GetResultHandler;
-    /**
-     * These GetErrorHandler(s) are used by [[invokeHook]] below
-     * Each HookType chooses a GetErrorHandler (See: [[TransitionService._defineCoreEvents]])
-     */
-    static LOG_ERROR: GetErrorHandler;
-    static REJECT_ERROR: GetErrorHandler;
-    static THROW_ERROR: GetErrorHandler;
-    /**
-     * Chains together an array of TransitionHooks.
-     *
-     * Given a list of [[TransitionHook]] objects, chains them together.
-     * Each hook is invoked after the previous one completes.
-     *
-     * #### Example:
-     * ```js
-     * var hooks: TransitionHook[] = getHooks();
-     * let promise: Promise<any> = TransitionHook.chain(hooks);
-     *
-     * promise.then(handleSuccess, handleError);
-     * ```
-     *
-     * @param hooks the list of hooks to chain together
-     * @param waitFor if provided, the chain is `.then()`'ed off this promise
-     * @returns a `Promise` for sequentially invoking the hooks (in order)
-     */
-    static chain(hooks: TransitionHook[], waitFor?: Promise<any>): Promise<any>;
-    /**
-     * Invokes all the provided TransitionHooks, in order.
-     * Each hook's return value is checked.
-     * If any hook returns a promise, then the rest of the hooks are chained off that promise, and the promise is returned.
-     * If no hook returns a promise, then all hooks are processed synchronously.
-     *
-     * @param hooks the list of TransitionHooks to invoke
-     * @param doneCallback a callback that is invoked after all the hooks have successfully completed
-     *
-     * @returns a promise for the async result, or the result of the callback
-     */
-    static invokeHooks<T>(hooks: TransitionHook[], doneCallback: (result?: HookResult) => T): Promise<any> | T;
-    /**
-     * Run all TransitionHooks, ignoring their return value.
-     */
-    static runAllHooks(hooks: TransitionHook[]): void;
-    constructor(transition: Transition, stateContext: StateDeclaration, registeredHook: RegisteredHook, options: TransitionHookOptions);
-    private isSuperseded;
-    logError(err: any): any;
-    invokeHook(): Promise<HookResult> | void;
-    /**
-     * This method handles the return value of a Transition Hook.
-     *
-     * A hook can return false (cancel), a TargetState (redirect),
-     * or a promise (which may later resolve to false or a redirect)
-     *
-     * This also handles "transition superseded" -- when a new transition
-     * was started while the hook was still running
-     */
-    handleHookResult(result: HookResult): Promise<HookResult>;
-    /**
-     * Return a Rejection promise if the transition is no longer current due
-     * to a stopped router (disposed), or a new transition has started and superseded this one.
-     */
-    private getNotCurrentRejection;
-    toString(): string;
+  private transition;
+  private stateContext;
+  private registeredHook;
+  private options;
+  type: TransitionEventType;
+  /**
+   * These GetResultHandler(s) are used by [[invokeHook]] below
+   * Each HookType chooses a GetResultHandler (See: [[TransitionService._defineCoreEvents]])
+   */
+  static HANDLE_RESULT: GetResultHandler;
+  /**
+   * If the result is a promise rejection, log it.
+   * Otherwise, ignore the result.
+   */
+  static LOG_REJECTED_RESULT: GetResultHandler;
+  /**
+   * These GetErrorHandler(s) are used by [[invokeHook]] below
+   * Each HookType chooses a GetErrorHandler (See: [[TransitionService._defineCoreEvents]])
+   */
+  static LOG_ERROR: GetErrorHandler;
+  static REJECT_ERROR: GetErrorHandler;
+  static THROW_ERROR: GetErrorHandler;
+  /**
+   * Chains together an array of TransitionHooks.
+   *
+   * Given a list of [[TransitionHook]] objects, chains them together.
+   * Each hook is invoked after the previous one completes.
+   *
+   * #### Example:
+   * ```js
+   * var hooks: TransitionHook[] = getHooks();
+   * let promise: Promise<any> = TransitionHook.chain(hooks);
+   *
+   * promise.then(handleSuccess, handleError);
+   * ```
+   *
+   * @param hooks the list of hooks to chain together
+   * @param waitFor if provided, the chain is `.then()`'ed off this promise
+   * @returns a `Promise` for sequentially invoking the hooks (in order)
+   */
+  static chain(hooks: TransitionHook[], waitFor?: Promise<any>): Promise<any>;
+  /**
+   * Invokes all the provided TransitionHooks, in order.
+   * Each hook's return value is checked.
+   * If any hook returns a promise, then the rest of the hooks are chained off that promise, and the promise is returned.
+   * If no hook returns a promise, then all hooks are processed synchronously.
+   *
+   * @param hooks the list of TransitionHooks to invoke
+   * @param doneCallback a callback that is invoked after all the hooks have successfully completed
+   *
+   * @returns a promise for the async result, or the result of the callback
+   */
+  static invokeHooks<T>(
+    hooks: TransitionHook[],
+    doneCallback: (result?: HookResult) => T,
+  ): Promise<any> | T;
+  /**
+   * Run all TransitionHooks, ignoring their return value.
+   */
+  static runAllHooks(hooks: TransitionHook[]): void;
+  constructor(
+    transition: Transition,
+    stateContext: StateDeclaration,
+    registeredHook: RegisteredHook,
+    options: TransitionHookOptions,
+  );
+  private isSuperseded;
+  logError(err: any): any;
+  invokeHook(): Promise<HookResult> | void;
+  /**
+   * This method handles the return value of a Transition Hook.
+   *
+   * A hook can return false (cancel), a TargetState (redirect),
+   * or a promise (which may later resolve to false or a redirect)
+   *
+   * This also handles "transition superseded" -- when a new transition
+   * was started while the hook was still running
+   */
+  handleHookResult(result: HookResult): Promise<HookResult>;
+  /**
+   * Return a Rejection promise if the transition is no longer current due
+   * to a stopped router (disposed), or a new transition has started and superseded this one.
+   */
+  private getNotCurrentRejection;
+  toString(): string;
 }

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

@@ -1,13 +1,26 @@
-import { IHookRegistry, TransitionOptions, TransitionHookScope, TransitionHookPhase, TransitionCreateHookFn, HookMatchCriteria, HookRegOptions, PathTypes, PathType, RegisteredHooks, TransitionHookFn, TransitionStateHookFn } from './interface';
-import { Transition } from './transition';
-import { RegisteredHook } from './hookRegistry';
-import { TargetState } from '../state/targetState';
-import { PathNode } from '../path/pathNode';
-import { ViewService } from '../view/view';
-import { UIRouter } from '../router';
-import { TransitionEventType } from './transitionEventType';
-import { GetResultHandler, GetErrorHandler } from './transitionHook';
-import { Disposable } from '../interface';
+import {
+  IHookRegistry,
+  TransitionOptions,
+  TransitionHookScope,
+  TransitionHookPhase,
+  TransitionCreateHookFn,
+  HookMatchCriteria,
+  HookRegOptions,
+  PathTypes,
+  PathType,
+  RegisteredHooks,
+  TransitionHookFn,
+  TransitionStateHookFn,
+} from "./interface";
+import { Transition } from "./transition";
+import { RegisteredHook } from "./hookRegistry";
+import { TargetState } from "../state/targetState";
+import { PathNode } from "../path/pathNode";
+import { ViewService } from "../view/view";
+import { UIRouter } from "../router";
+import { TransitionEventType } from "./transitionEventType";
+import { GetResultHandler, GetErrorHandler } from "./transitionHook";
+import { Disposable } from "../interface";
 /**
  * The default [[Transition]] options.
  *
@@ -20,34 +33,43 @@ export declare let defaultTransOpts: TransitionOptions;
  * Plugin API for Transition Service
  */
 export interface TransitionServicePluginAPI {
-    /**
-     * Adds a Path to be used as a criterion against a TreeChanges path
-     *
-     * For example: the `exiting` path in [[HookMatchCriteria]] is a STATE scoped path.
-     * It was defined by calling `defineTreeChangesCriterion('exiting', TransitionHookScope.STATE)`
-     * Each state in the exiting path is checked against the criteria and returned as part of the match.
-     *
-     * Another example: the `to` path in [[HookMatchCriteria]] is a TRANSITION scoped path.
-     * It was defined by calling `defineTreeChangesCriterion('to', TransitionHookScope.TRANSITION)`
-     * Only the tail of the `to` path is checked against the criteria and returned as part of the match.
-     */
-    _definePathType(name: string, hookScope: TransitionHookScope): any;
-    /**
-     * Gets a Path definition used as a criterion against a TreeChanges path
-     */
-    _getPathTypes(): PathTypes;
-    /**
-     * Defines a transition hook type and returns a transition hook registration
-     * function (which can then be used to register hooks of this type).
-     */
-    _defineEvent(name: string, hookPhase: TransitionHookPhase, hookOrder: number, criteriaMatchPath: PathType, reverseSort?: boolean, getResultHandler?: GetResultHandler, getErrorHandler?: GetErrorHandler, rejectIfSuperseded?: boolean): any;
-    /**
-     * Returns the known event types, such as `onBefore`
-     * If a phase argument is provided, returns only events for the given phase.
-     */
-    _getEvents(phase?: TransitionHookPhase): TransitionEventType[];
-    /** Returns the hooks registered for the given hook name */
-    getHooks(hookName: string): RegisteredHook[];
+  /**
+   * Adds a Path to be used as a criterion against a TreeChanges path
+   *
+   * For example: the `exiting` path in [[HookMatchCriteria]] is a STATE scoped path.
+   * It was defined by calling `defineTreeChangesCriterion('exiting', TransitionHookScope.STATE)`
+   * Each state in the exiting path is checked against the criteria and returned as part of the match.
+   *
+   * Another example: the `to` path in [[HookMatchCriteria]] is a TRANSITION scoped path.
+   * It was defined by calling `defineTreeChangesCriterion('to', TransitionHookScope.TRANSITION)`
+   * Only the tail of the `to` path is checked against the criteria and returned as part of the match.
+   */
+  _definePathType(name: string, hookScope: TransitionHookScope): any;
+  /**
+   * Gets a Path definition used as a criterion against a TreeChanges path
+   */
+  _getPathTypes(): PathTypes;
+  /**
+   * Defines a transition hook type and returns a transition hook registration
+   * function (which can then be used to register hooks of this type).
+   */
+  _defineEvent(
+    name: string,
+    hookPhase: TransitionHookPhase,
+    hookOrder: number,
+    criteriaMatchPath: PathType,
+    reverseSort?: boolean,
+    getResultHandler?: GetResultHandler,
+    getErrorHandler?: GetErrorHandler,
+    rejectIfSuperseded?: boolean,
+  ): any;
+  /**
+   * Returns the known event types, such as `onBefore`
+   * If a phase argument is provided, returns only events for the given phase.
+   */
+  _getEvents(phase?: TransitionHookPhase): TransitionEventType[];
+  /** Returns the hooks registered for the given hook name */
+  getHooks(hookName: string): RegisteredHook[];
 }
 /**
  * This class provides services related to Transitions.
@@ -61,127 +83,172 @@ export interface TransitionServicePluginAPI {
  * This API is located at `router.transitionService` ([[UIRouter.transitionService]])
  */
 export declare class TransitionService implements IHookRegistry, Disposable {
-    /** @internal */
-    _transitionCount: number;
-    /** @internal */
-    $view: ViewService;
-    /** The transition hook types, such as `onEnter`, `onStart`, etc */
-    private _eventTypes;
-    /** @internal The registered transition hooks */
-    _registeredHooks: RegisteredHooks;
-    /** The  paths on a criteria object */
-    private _criteriaPaths;
-    private _router;
-    /** @internal */
-    _pluginapi: TransitionServicePluginAPI;
-    /**
-     * This object has hook de-registration functions for the built-in hooks.
-     * This can be used by third parties libraries that wish to customize the behaviors
-     *
-     * @internal
-     */
-    _deregisterHookFns: {
-        addCoreResolves: Function;
-        ignored: Function;
-        invalid: Function;
-        redirectTo: Function;
-        onExit: Function;
-        onRetain: Function;
-        onEnter: Function;
-        eagerResolve: Function;
-        lazyResolve: Function;
-        resolveAll: Function;
-        loadViews: Function;
-        activateViews: Function;
-        updateGlobals: Function;
-        updateUrl: Function;
-        lazyLoad: Function;
-    };
-    /** @internal */
-    constructor(_router: UIRouter);
-    /**
-     * Registers a [[TransitionHookFn]], called *while a transition is being constructed*.
-     *
-     * Registers a transition lifecycle hook, which is invoked during transition construction.
-     *
-     * This low level hook should only be used by plugins.
-     * This can be a useful time for plugins to add resolves or mutate the transition as needed.
-     * The Sticky States plugin uses this hook to modify the treechanges.
-     *
-     * ### Lifecycle
-     *
-     * `onCreate` hooks are invoked *while a transition is being constructed*.
-     *
-     * ### Return value
-     *
-     * The hook's return value is ignored
-     *
-     * @internal
-     * @param criteria defines which Transitions the Hook should be invoked for.
-     * @param callback the hook function which will be invoked.
-     * @param options the registration options
-     * @returns a function which deregisters the hook.
-     */
-    onCreate(criteria: HookMatchCriteria, callback: TransitionCreateHookFn, options?: HookRegOptions): Function;
-    /** @inheritdoc */
-    onBefore(criteria: HookMatchCriteria, callback: TransitionHookFn, options?: HookRegOptions): Function;
-    /** @inheritdoc */
-    onStart(criteria: HookMatchCriteria, callback: TransitionHookFn, options?: HookRegOptions): Function;
-    /** @inheritdoc */
-    onExit(criteria: HookMatchCriteria, callback: TransitionStateHookFn, options?: HookRegOptions): Function;
-    /** @inheritdoc */
-    onRetain(criteria: HookMatchCriteria, callback: TransitionStateHookFn, options?: HookRegOptions): Function;
-    /** @inheritdoc */
-    onEnter(criteria: HookMatchCriteria, callback: TransitionStateHookFn, options?: HookRegOptions): Function;
-    /** @inheritdoc */
-    onFinish(criteria: HookMatchCriteria, callback: TransitionHookFn, options?: HookRegOptions): Function;
-    /** @inheritdoc */
-    onSuccess(criteria: HookMatchCriteria, callback: TransitionHookFn, options?: HookRegOptions): Function;
-    /** @inheritdoc */
-    onError(criteria: HookMatchCriteria, callback: TransitionHookFn, options?: HookRegOptions): Function;
-    /**
-     * dispose
-     * @internal
-     */
-    dispose(router: UIRouter): void;
-    /**
-     * Creates a new [[Transition]] object
-     *
-     * This is a factory function for creating new Transition objects.
-     * It is used internally by the [[StateService]] and should generally not be called by application code.
-     *
-     * @internal
-     * @param fromPath the path to the current state (the from state)
-     * @param targetState the target state (destination)
-     * @returns a Transition
-     */
-    create(fromPath: PathNode[], targetState: TargetState): Transition;
-    /** @internal */
-    private _defineCoreEvents;
-    /** @internal */
-    private _defineCorePaths;
-    /** @internal */
-    _defineEvent(name: string, hookPhase: TransitionHookPhase, hookOrder: number, criteriaMatchPath: PathType, reverseSort?: boolean, getResultHandler?: GetResultHandler, getErrorHandler?: GetErrorHandler, synchronous?: boolean): void;
-    /** @internal */
-    private _getEvents;
-    /**
-     * Adds a Path to be used as a criterion against a TreeChanges path
-     *
-     * For example: the `exiting` path in [[HookMatchCriteria]] is a STATE scoped path.
-     * It was defined by calling `defineTreeChangesCriterion('exiting', TransitionHookScope.STATE)`
-     * Each state in the exiting path is checked against the criteria and returned as part of the match.
-     *
-     * Another example: the `to` path in [[HookMatchCriteria]] is a TRANSITION scoped path.
-     * It was defined by calling `defineTreeChangesCriterion('to', TransitionHookScope.TRANSITION)`
-     * Only the tail of the `to` path is checked against the criteria and returned as part of the match.
-     *
-     * @internal
-     */
-    private _definePathType;
-    /** @internal */
-    private _getPathTypes;
-    /** @internal */
-    getHooks(hookName: string): RegisteredHook[];
-    /** @internal */
-    private _registerCoreTransitionHooks;
+  /** @internal */
+  _transitionCount: number;
+  /** @internal */
+  $view: ViewService;
+  /** The transition hook types, such as `onEnter`, `onStart`, etc */
+  private _eventTypes;
+  /** @internal The registered transition hooks */
+  _registeredHooks: RegisteredHooks;
+  /** The  paths on a criteria object */
+  private _criteriaPaths;
+  private _router;
+  /** @internal */
+  _pluginapi: TransitionServicePluginAPI;
+  /**
+   * This object has hook de-registration functions for the built-in hooks.
+   * This can be used by third parties libraries that wish to customize the behaviors
+   *
+   * @internal
+   */
+  _deregisterHookFns: {
+    addCoreResolves: Function;
+    ignored: Function;
+    invalid: Function;
+    redirectTo: Function;
+    onExit: Function;
+    onRetain: Function;
+    onEnter: Function;
+    eagerResolve: Function;
+    lazyResolve: Function;
+    resolveAll: Function;
+    loadViews: Function;
+    activateViews: Function;
+    updateGlobals: Function;
+    updateUrl: Function;
+    lazyLoad: Function;
+  };
+  /** @internal */
+  constructor(_router: UIRouter);
+  /**
+   * Registers a [[TransitionHookFn]], called *while a transition is being constructed*.
+   *
+   * Registers a transition lifecycle hook, which is invoked during transition construction.
+   *
+   * This low level hook should only be used by plugins.
+   * This can be a useful time for plugins to add resolves or mutate the transition as needed.
+   * The Sticky States plugin uses this hook to modify the treechanges.
+   *
+   * ### Lifecycle
+   *
+   * `onCreate` hooks are invoked *while a transition is being constructed*.
+   *
+   * ### Return value
+   *
+   * The hook's return value is ignored
+   *
+   * @internal
+   * @param criteria defines which Transitions the Hook should be invoked for.
+   * @param callback the hook function which will be invoked.
+   * @param options the registration options
+   * @returns a function which deregisters the hook.
+   */
+  onCreate(
+    criteria: HookMatchCriteria,
+    callback: TransitionCreateHookFn,
+    options?: HookRegOptions,
+  ): Function;
+  /** @inheritdoc */
+  onBefore(
+    criteria: HookMatchCriteria,
+    callback: TransitionHookFn,
+    options?: HookRegOptions,
+  ): Function;
+  /** @inheritdoc */
+  onStart(
+    criteria: HookMatchCriteria,
+    callback: TransitionHookFn,
+    options?: HookRegOptions,
+  ): Function;
+  /** @inheritdoc */
+  onExit(
+    criteria: HookMatchCriteria,
+    callback: TransitionStateHookFn,
+    options?: HookRegOptions,
+  ): Function;
+  /** @inheritdoc */
+  onRetain(
+    criteria: HookMatchCriteria,
+    callback: TransitionStateHookFn,
+    options?: HookRegOptions,
+  ): Function;
+  /** @inheritdoc */
+  onEnter(
+    criteria: HookMatchCriteria,
+    callback: TransitionStateHookFn,
+    options?: HookRegOptions,
+  ): Function;
+  /** @inheritdoc */
+  onFinish(
+    criteria: HookMatchCriteria,
+    callback: TransitionHookFn,
+    options?: HookRegOptions,
+  ): Function;
+  /** @inheritdoc */
+  onSuccess(
+    criteria: HookMatchCriteria,
+    callback: TransitionHookFn,
+    options?: HookRegOptions,
+  ): Function;
+  /** @inheritdoc */
+  onError(
+    criteria: HookMatchCriteria,
+    callback: TransitionHookFn,
+    options?: HookRegOptions,
+  ): Function;
+  /**
+   * dispose
+   * @internal
+   */
+  dispose(router: UIRouter): void;
+  /**
+   * Creates a new [[Transition]] object
+   *
+   * This is a factory function for creating new Transition objects.
+   * It is used internally by the [[StateService]] and should generally not be called by application code.
+   *
+   * @internal
+   * @param fromPath the path to the current state (the from state)
+   * @param targetState the target state (destination)
+   * @returns a Transition
+   */
+  create(fromPath: PathNode[], targetState: TargetState): Transition;
+  /** @internal */
+  private _defineCoreEvents;
+  /** @internal */
+  private _defineCorePaths;
+  /** @internal */
+  _defineEvent(
+    name: string,
+    hookPhase: TransitionHookPhase,
+    hookOrder: number,
+    criteriaMatchPath: PathType,
+    reverseSort?: boolean,
+    getResultHandler?: GetResultHandler,
+    getErrorHandler?: GetErrorHandler,
+    synchronous?: boolean,
+  ): void;
+  /** @internal */
+  private _getEvents;
+  /**
+   * Adds a Path to be used as a criterion against a TreeChanges path
+   *
+   * For example: the `exiting` path in [[HookMatchCriteria]] is a STATE scoped path.
+   * It was defined by calling `defineTreeChangesCriterion('exiting', TransitionHookScope.STATE)`
+   * Each state in the exiting path is checked against the criteria and returned as part of the match.
+   *
+   * Another example: the `to` path in [[HookMatchCriteria]] is a TRANSITION scoped path.
+   * It was defined by calling `defineTreeChangesCriterion('to', TransitionHookScope.TRANSITION)`
+   * Only the tail of the `to` path is checked against the criteria and returned as part of the match.
+   *
+   * @internal
+   */
+  private _definePathType;
+  /** @internal */
+  private _getPathTypes;
+  /** @internal */
+  getHooks(hookName: string): RegisteredHook[];
+  /** @internal */
+  private _registerCoreTransitionHooks;
 }

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

@@ -1,8 +1,8 @@
-export * from './interface';
-export * from './urlMatcher';
-export * from './urlMatcherFactory';
-export * from './urlRouter';
-export * from './urlRule';
-export * from './urlService';
-export { UrlRules } from './urlRules';
-export { UrlConfig } from './urlConfig';
+export * from "./interface";
+export * from "./urlMatcher";
+export * from "./urlMatcherFactory";
+export * from "./urlRouter";
+export * from "./urlRule";
+export * from "./urlService";
+export { UrlRules } from "./urlRules";
+export { UrlConfig } from "./urlConfig";