@ngxs/router-plugin 3.7.6 → 3.8.0-dev.master-c341c15

package/fesm2015/ngxs-router-plugin.js

@@ -1,232 +1,129 @@
-import { NgZone, Injectable, NgModule } from '@angular/core';
-import { Store, Action, Selector, State, NgxsModule } from '@ngxs/store';
+import * as i0 from '@angular/core';
+import { InjectionToken, NgZone, Injector, Injectable, NgModule } from '@angular/core';
+import * as i1 from '@ngxs/store';
+import { Action, Selector, State, Store, NgxsModule } from '@ngxs/store';
 import { __decorate, __metadata } from 'tslib';
+import * as i2 from '@angular/router';
 import { NavigationStart, RoutesRecognized, ResolveEnd, NavigationCancel, NavigationError, NavigationEnd, Router } from '@angular/router';
 import { Subscription } from 'rxjs';
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * Public event api of the router
  */
 class Navigate {
-    /**
-     * @param {?} path
-     * @param {?=} queryParams
-     * @param {?=} extras
-     */
     constructor(path, queryParams, extras) {
         this.path = path;
         this.queryParams = queryParams;
         this.extras = extras;
     }
-    /**
-     * @return {?}
-     */
     static get type() {
         // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
         return '[Router] Navigate';
     }
 }
-if (false) {
-    /** @type {?} */
-    Navigate.prototype.path;
-    /** @type {?} */
-    Navigate.prototype.queryParams;
-    /** @type {?} */
-    Navigate.prototype.extras;
-}
 /**
  *
  * Angular Routers internal state events
  *
  */
+/**
+ * An action dispatched when the router starts the navigation.
+ */
+class RouterRequest {
+    constructor(routerState, event, trigger = 'none') {
+        this.routerState = routerState;
+        this.event = event;
+        this.trigger = trigger;
+    }
+    static get type() {
+        // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
+        return '[Router] RouterRequest';
+    }
+}
 /**
  * An action dispatched when the router navigates.
- * @template T
  */
 class RouterNavigation {
-    /**
-     * @param {?} routerState
-     * @param {?} event
-     * @param {?=} trigger
-     */
     constructor(routerState, event, trigger = 'none') {
         this.routerState = routerState;
         this.event = event;
         this.trigger = trigger;
     }
-    /**
-     * @return {?}
-     */
     static get type() {
         // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
         return '[Router] RouterNavigation';
     }
 }
-if (false) {
-    /** @type {?} */
-    RouterNavigation.prototype.routerState;
-    /** @type {?} */
-    RouterNavigation.prototype.event;
-    /** @type {?} */
-    RouterNavigation.prototype.trigger;
-}
 /**
  * An action dispatched when the router cancel navigation.
- * @template T, V
  */
 class RouterCancel {
-    /**
-     * @param {?} routerState
-     * @param {?} storeState
-     * @param {?} event
-     * @param {?=} trigger
-     */
     constructor(routerState, storeState, event, trigger = 'none') {
         this.routerState = routerState;
         this.storeState = storeState;
         this.event = event;
         this.trigger = trigger;
     }
-    /**
-     * @return {?}
-     */
     static get type() {
         // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
         return '[Router] RouterCancel';
     }
 }
-if (false) {
-    /** @type {?} */
-    RouterCancel.prototype.routerState;
-    /** @type {?} */
-    RouterCancel.prototype.storeState;
-    /** @type {?} */
-    RouterCancel.prototype.event;
-    /** @type {?} */
-    RouterCancel.prototype.trigger;
-}
 /**
  * An action dispatched when the router errors.
- * @template T, V
  */
 class RouterError {
-    /**
-     * @param {?} routerState
-     * @param {?} storeState
-     * @param {?} event
-     * @param {?=} trigger
-     */
     constructor(routerState, storeState, event, trigger = 'none') {
         this.routerState = routerState;
         this.storeState = storeState;
         this.event = event;
         this.trigger = trigger;
     }
-    /**
-     * @return {?}
-     */
     static get type() {
         // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
         return '[Router] RouterError';
     }
 }
-if (false) {
-    /** @type {?} */
-    RouterError.prototype.routerState;
-    /** @type {?} */
-    RouterError.prototype.storeState;
-    /** @type {?} */
-    RouterError.prototype.event;
-    /** @type {?} */
-    RouterError.prototype.trigger;
-}
 /**
  * An action dispatched when the `ResolveEnd` event is triggered.
- * @template T
  */
 class RouterDataResolved {
-    /**
-     * @param {?} routerState
-     * @param {?} event
-     * @param {?=} trigger
-     */
     constructor(routerState, event, trigger = 'none') {
         this.routerState = routerState;
         this.event = event;
         this.trigger = trigger;
     }
-    /**
-     * @return {?}
-     */
     static get type() {
         // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
         return '[Router] RouterDataResolved';
     }
 }
-if (false) {
-    /** @type {?} */
-    RouterDataResolved.prototype.routerState;
-    /** @type {?} */
-    RouterDataResolved.prototype.event;
-    /** @type {?} */
-    RouterDataResolved.prototype.trigger;
-}
-
 /**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * An action dispatched when the router navigation has been finished successfully.
  */
-/**
- * @abstract
- * @template T
- */
-class RouterStateSerializer {
-}
-if (false) {
-    /**
-     * @abstract
-     * @param {?} routerState
-     * @return {?}
-     */
-    RouterStateSerializer.prototype.serialize = function (routerState) { };
+class RouterNavigated {
+    constructor(routerState, event, trigger = 'none') {
+        this.routerState = routerState;
+        this.event = event;
+        this.trigger = trigger;
+    }
+    static get type() {
+        // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
+        return '[Router] RouterNavigated';
+    }
 }
-/**
- * @record
- */
-function SerializedRouterStateSnapshot() { }
-if (false) {
-    /** @type {?} */
-    SerializedRouterStateSnapshot.prototype.root;
-    /** @type {?} */
-    SerializedRouterStateSnapshot.prototype.url;
+
+class RouterStateSerializer {
 }
 class DefaultRouterStateSerializer {
-    /**
-     * @param {?} routerState
-     * @return {?}
-     */
     serialize(routerState) {
         return {
             root: this.serializeRoute(routerState.root),
             url: routerState.url
         };
     }
-    /**
-     * @private
-     * @param {?} route
-     * @return {?}
-     */
     serializeRoute(route) {
-        /** @type {?} */
-        const children = route.children.map((/**
-         * @param {?} c
-         * @return {?}
-         */
-        c => this.serializeRoute(c)));
+        const children = route.children.map(c => this.serializeRoute(c));
         return {
             url: route.url,
             params: route.params,
@@ -236,11 +133,11 @@ class DefaultRouterStateSerializer {
             outlet: route.outlet,
             component: null,
             routeConfig: null,
-            root: (/** @type {?} */ (null)),
+            root: null,
             parent: null,
             firstChild: children[0],
             children: children,
-            pathFromRoot: (/** @type {?} */ (null)),
+            pathFromRoot: null,
             paramMap: route.paramMap,
             queryParamMap: route.queryParamMap,
             toString: route.toString
@@ -248,28 +145,17 @@ class DefaultRouterStateSerializer {
     }
 }
 
-var RouterState_1;
-/**
- * @record
- * @template T
- */
-function RouterStateModel() { }
-if (false) {
-    /** @type {?|undefined} */
-    RouterStateModel.prototype.state;
-    /** @type {?|undefined} */
-    RouterStateModel.prototype.navigationId;
-    /** @type {?} */
-    RouterStateModel.prototype.trigger;
+const USER_OPTIONS = new InjectionToken('USER_OPTIONS', { providedIn: 'root', factory: () => undefined });
+const NGXS_ROUTER_PLUGIN_OPTIONS = new InjectionToken('NGXS_ROUTER_PLUGIN_OPTIONS', { providedIn: 'root', factory: () => ({}) });
+function createRouterPluginOptions(options) {
+    return {
+        navigationActionTiming: (options && options.navigationActionTiming) || 1 /* PreActivation */
+    };
 }
+
+var RouterState_1;
 let RouterState = RouterState_1 = class RouterState {
-    /**
-     * @param {?} _store
-     * @param {?} _router
-     * @param {?} _serializer
-     * @param {?} _ngZone
-     */
-    constructor(_store, _router, _serializer, _ngZone) {
+    constructor(_store, _router, _serializer, _ngZone, injector) {
         this._store = _store;
         this._router = _router;
         this._serializer = _serializer;
@@ -287,189 +173,129 @@ let RouterState = RouterState_1 = class RouterState {
          * That's the value of the `RouterState` state
          */
         this._storeState = null;
-        this._lastRoutesRecognized = (/** @type {?} */ (null));
+        this._lastEvent = null;
         this._subscription = new Subscription();
-        this.setUpStoreListener();
-        this.setUpRouterEventsListener();
-    }
-    /**
-     * @template T
-     * @param {?} state
-     * @return {?}
-     */
+        this._options = null;
+        // Note: do not use `@Inject` since it fails on lower versions of Angular with Jest
+        // integration, it cannot resolve the token provider.
+        this._options = injector.get(NGXS_ROUTER_PLUGIN_OPTIONS, null);
+        this._setUpStoreListener();
+        this._setUpRouterEventsListener();
+    }
     static state(state) {
         return state && state.state;
     }
-    /**
-     * @param {?} state
-     * @return {?}
-     */
     static url(state) {
         return state && state.state && state.state.url;
     }
-    /**
-     * @return {?}
-     */
     ngOnDestroy() {
         this._subscription.unsubscribe();
     }
-    /**
-     * @param {?} _
-     * @param {?} action
-     * @return {?}
-     */
     navigate(_, action) {
-        return this._ngZone.run((/**
-         * @return {?}
-         */
-        () => this._router.navigate(action.path, Object.assign({ queryParams: action.queryParams }, action.extras))));
+        return this._ngZone.run(() => this._router.navigate(action.path, Object.assign({ queryParams: action.queryParams }, action.extras)));
     }
-    /**
-     * @param {?} ctx
-     * @param {?} action
-     * @return {?}
-     */
     angularRouterAction(ctx, action) {
-        ctx.setState(Object.assign({}, ctx.getState(), { trigger: action.trigger, state: action.routerState, navigationId: action.event.id }));
-    }
-    /**
-     * @private
-     * @return {?}
-     */
-    setUpStoreListener() {
-        /** @type {?} */
+        ctx.setState({
+            trigger: action.trigger,
+            state: action.routerState,
+            navigationId: action.event.id
+        });
+    }
+    _setUpStoreListener() {
         const subscription = this._store
             .select(RouterState_1)
-            .subscribe((/**
-         * @param {?} state
-         * @return {?}
-         */
-        (state) => {
-            this.navigateIfNeeded(state);
-        }));
+            .subscribe((state) => {
+            this._navigateIfNeeded(state);
+        });
         this._subscription.add(subscription);
     }
-    /**
-     * @private
-     * @return {?}
-     */
-    setUpRouterEventsListener() {
-        /** @type {?} */
-        const subscription = this._router.events.subscribe((/**
-         * @param {?} event
-         * @return {?}
-         */
-        event => {
+    _navigateIfNeeded(routerState) {
+        if (routerState && routerState.trigger === 'devtools') {
+            this._storeState = this._store.selectSnapshot(RouterState_1);
+        }
+        const canSkipNavigation = !this._storeState ||
+            !this._storeState.state ||
+            !routerState ||
+            routerState.trigger === 'router' ||
+            this._router.url === this._storeState.state.url ||
+            this._lastEvent instanceof NavigationStart;
+        if (canSkipNavigation) {
+            return;
+        }
+        this._storeState = this._store.selectSnapshot(RouterState_1);
+        this._trigger = 'store';
+        this._ngZone.run(() => this._router.navigateByUrl(this._storeState.state.url));
+    }
+    _setUpRouterEventsListener() {
+        const dispatchRouterNavigationLate = this._options != null &&
+            this._options.navigationActionTiming === 2 /* PostActivation */;
+        let lastRoutesRecognized;
+        const subscription = this._router.events.subscribe(event => {
+            this._lastEvent = event;
             if (event instanceof NavigationStart) {
-                this.navigationStart();
+                this._navigationStart(event);
             }
             else if (event instanceof RoutesRecognized) {
-                this._lastRoutesRecognized = event;
+                lastRoutesRecognized = event;
+                if (!dispatchRouterNavigationLate && this._trigger !== 'store') {
+                    this._dispatchRouterNavigation(lastRoutesRecognized);
+                }
             }
             else if (event instanceof ResolveEnd) {
-                this.dispatchRouterDataResolved(event);
+                this._dispatchRouterDataResolved(event);
             }
             else if (event instanceof NavigationCancel) {
-                this.dispatchRouterCancel(event);
-                this.reset();
+                this._dispatchRouterCancel(event);
+                this._reset();
             }
             else if (event instanceof NavigationError) {
-                this.dispatchRouterError(event);
-                this.reset();
+                this._dispatchRouterError(event);
+                this._reset();
             }
             else if (event instanceof NavigationEnd) {
-                this.navigationEnd();
-                this.reset();
+                if (this._trigger !== 'store') {
+                    if (dispatchRouterNavigationLate) {
+                        this._dispatchRouterNavigation(lastRoutesRecognized);
+                    }
+                    this._dispatchRouterNavigated(event);
+                }
+                this._reset();
             }
-        }));
+        });
         this._subscription.add(subscription);
     }
-    /**
-     * @private
-     * @return {?}
-     */
-    navigationStart() {
+    /** Reacts to `NavigationStart`. */
+    _navigationStart(event) {
         this._routerState = this._serializer.serialize(this._router.routerState.snapshot);
         if (this._trigger !== 'none') {
             this._storeState = this._store.selectSnapshot(RouterState_1);
+            this._dispatchRouterAction(new RouterRequest(this._routerState, event, this._trigger));
         }
     }
-    /**
-     * @private
-     * @return {?}
-     */
-    navigationEnd() {
-        if (this.shouldDispatchRouterNavigation()) {
-            this.dispatchRouterNavigation();
-        }
+    /** Reacts to `ResolveEnd`. */
+    _dispatchRouterDataResolved(event) {
+        const routerState = this._serializer.serialize(event.state);
+        this._dispatchRouterAction(new RouterDataResolved(routerState, event, this._trigger));
     }
-    /**
-     * @private
-     * @return {?}
-     */
-    shouldDispatchRouterNavigation() {
-        if (!this._storeState)
-            return true;
-        return this._trigger !== 'store';
-    }
-    /**
-     * @private
-     * @param {?} state
-     * @return {?}
-     */
-    navigateIfNeeded(state) {
-        if (state && state.trigger === 'devtools') {
-            this._storeState = this._store.selectSnapshot(RouterState_1);
-        }
-        /** @type {?} */
-        const canSkipNavigation = !this._storeState ||
-            !this._storeState.state ||
-            !state ||
-            state.trigger === 'router' ||
-            this._router.url === this._storeState.state.url;
-        if (canSkipNavigation) {
-            return;
-        }
-        this._trigger = 'store';
-        this._ngZone.run((/**
-         * @return {?}
-         */
-        () => {
-            this._router.navigateByUrl((/** @type {?} */ ((/** @type {?} */ (this._storeState)).state)).url);
-        }));
-    }
-    /**
-     * @private
-     * @return {?}
-     */
-    dispatchRouterNavigation() {
-        /** @type {?} */
-        const nextRouterState = this._serializer.serialize(this._lastRoutesRecognized.state);
-        this.dispatchRouterAction(new RouterNavigation(nextRouterState, new RoutesRecognized(this._lastRoutesRecognized.id, this._lastRoutesRecognized.url, this._lastRoutesRecognized.urlAfterRedirects, nextRouterState), this._trigger));
-    }
-    /**
-     * @private
-     * @param {?} event
-     * @return {?}
-     */
-    dispatchRouterCancel(event) {
-        this.dispatchRouterAction(new RouterCancel((/** @type {?} */ (this._routerState)), this._storeState, event, this._trigger));
-    }
-    /**
-     * @private
-     * @param {?} event
-     * @return {?}
-     */
-    dispatchRouterError(event) {
-        this.dispatchRouterAction(new RouterError((/** @type {?} */ (this._routerState)), this._storeState, new NavigationError(event.id, event.url, `${event}`), this._trigger));
-    }
-    /**
-     * @private
-     * @template T
-     * @param {?} action
-     * @return {?}
-     */
-    dispatchRouterAction(action) {
+    /** Reacts to `RoutesRecognized` or `NavigationEnd`, depends on the `navigationActionTiming`. */
+    _dispatchRouterNavigation(lastRoutesRecognized) {
+        const nextRouterState = this._serializer.serialize(lastRoutesRecognized.state);
+        this._dispatchRouterAction(new RouterNavigation(nextRouterState, new RoutesRecognized(lastRoutesRecognized.id, lastRoutesRecognized.url, lastRoutesRecognized.urlAfterRedirects, nextRouterState), this._trigger));
+    }
+    /** Reacts to `NavigationCancel`. */
+    _dispatchRouterCancel(event) {
+        this._dispatchRouterAction(new RouterCancel(this._routerState, this._storeState, event, this._trigger));
+    }
+    /** Reacts to `NavigationEnd`. */
+    _dispatchRouterError(event) {
+        this._dispatchRouterAction(new RouterError(this._routerState, this._storeState, new NavigationError(event.id, event.url, `${event}`), this._trigger));
+    }
+    /** Reacts to `NavigationEnd`. */
+    _dispatchRouterNavigated(event) {
+        const routerState = this._serializer.serialize(this._router.routerState.snapshot);
+        this._dispatchRouterAction(new RouterNavigated(routerState, event, this._trigger));
+    }
+    _dispatchRouterAction(action) {
         this._trigger = 'router';
         try {
             this._store.dispatch(action);
@@ -478,42 +304,14 @@ let RouterState = RouterState_1 = class RouterState {
             this._trigger = 'none';
         }
     }
-    /**
-     * @private
-     * @param {?} event
-     * @return {?}
-     */
-    dispatchRouterDataResolved(event) {
-        /** @type {?} */
-        const routerState = this._serializer.serialize(event.state);
-        this.dispatchRouterAction(new RouterDataResolved(routerState, event, this._trigger));
-    }
-    /**
-     * @private
-     * @return {?}
-     */
-    reset() {
+    _reset() {
         this._trigger = 'none';
         this._storeState = null;
         this._routerState = null;
     }
 };
-RouterState.ctorParameters = () => [
-    { type: Store },
-    { type: Router },
-    { type: RouterStateSerializer },
-    { type: NgZone }
-];
-RouterState.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-RouterState.ctorParameters = () => [
-    { type: Store },
-    { type: Router },
-    { type: RouterStateSerializer },
-    { type: NgZone }
-];
+/** @nocollapse */ RouterState.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RouterState, deps: [{ token: i1.Store }, { token: i2.Router }, { token: RouterStateSerializer }, { token: i0.NgZone }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ RouterState.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RouterState });
 __decorate([
     Action(Navigate),
     __metadata("design:type", Function),
@@ -521,7 +319,14 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], RouterState.prototype, "navigate", null);
 __decorate([
-    Action([RouterNavigation, RouterError, RouterCancel, RouterDataResolved]),
+    Action([
+        RouterRequest,
+        RouterNavigation,
+        RouterError,
+        RouterCancel,
+        RouterDataResolved,
+        RouterNavigated
+    ]),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", void 0)
@@ -550,95 +355,46 @@ RouterState = RouterState_1 = __decorate([
     __metadata("design:paramtypes", [Store,
         Router,
         RouterStateSerializer,
-        NgZone])
+        NgZone,
+        Injector])
 ], RouterState);
-if (false) {
-    /**
-     * Determines how navigation was performed by the `RouterState` itself
-     * or outside via `new Navigate(...)`
-     * @type {?}
-     * @private
-     */
-    RouterState.prototype._trigger;
-    /**
-     * That's the serialized state from the `Router` class
-     * @type {?}
-     * @private
-     */
-    RouterState.prototype._routerState;
-    /**
-     * That's the value of the `RouterState` state
-     * @type {?}
-     * @private
-     */
-    RouterState.prototype._storeState;
-    /**
-     * @type {?}
-     * @private
-     */
-    RouterState.prototype._lastRoutesRecognized;
-    /**
-     * @type {?}
-     * @private
-     */
-    RouterState.prototype._subscription;
-    /**
-     * @type {?}
-     * @private
-     */
-    RouterState.prototype._store;
-    /**
-     * @type {?}
-     * @private
-     */
-    RouterState.prototype._router;
-    /**
-     * @type {?}
-     * @private
-     */
-    RouterState.prototype._serializer;
-    /**
-     * @type {?}
-     * @private
-     */
-    RouterState.prototype._ngZone;
-}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RouterState, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.Router }, { type: RouterStateSerializer }, { type: i0.NgZone }, { type: i0.Injector }]; }, propDecorators: { navigate: [], angularRouterAction: [] } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class NgxsRouterPluginModule {
-    /**
-     * @return {?}
-     */
-    static forRoot() {
+    static forRoot(options) {
         return {
             ngModule: NgxsRouterPluginModule,
-            providers: [{ provide: RouterStateSerializer, useClass: DefaultRouterStateSerializer }]
+            providers: [
+                { provide: USER_OPTIONS, useValue: options },
+                {
+                    provide: NGXS_ROUTER_PLUGIN_OPTIONS,
+                    useFactory: createRouterPluginOptions,
+                    deps: [USER_OPTIONS]
+                },
+                { provide: RouterStateSerializer, useClass: DefaultRouterStateSerializer }
+            ]
         };
     }
 }
-NgxsRouterPluginModule.decorators = [
-    { type: NgModule, args: [{
-                imports: [NgxsModule.forFeature([RouterState])]
-            },] }
-];
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
+/** @nocollapse */ NgxsRouterPluginModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsRouterPluginModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ NgxsRouterPluginModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsRouterPluginModule, imports: [i1.ɵNgxsFeatureModule] });
+/** @nocollapse */ NgxsRouterPluginModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsRouterPluginModule, imports: [[NgxsModule.forFeature([RouterState])]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsRouterPluginModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [NgxsModule.forFeature([RouterState])]
+                }]
+        }] });
 
 /**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * The public api for consumers of @ngxs/router-plugin
  */
 
 /**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * Generated bundle index. Do not edit.
  */
 
-export { DefaultRouterStateSerializer, Navigate, NgxsRouterPluginModule, RouterCancel, RouterDataResolved, RouterError, RouterNavigation, RouterState, RouterStateSerializer };
+export { DefaultRouterStateSerializer, Navigate, NgxsRouterPluginModule, RouterCancel, RouterDataResolved, RouterError, RouterNavigated, RouterNavigation, RouterRequest, RouterState, RouterStateSerializer };
 //# sourceMappingURL=ngxs-router-plugin.js.map