@scion/workbench 17.0.0-beta.7 → 17.0.0-beta.9

package/lib/routing/routing.model.d.ts

@@ -1,30 +1,129 @@
+import { NavigationExtras, UrlSegment } from '@angular/router';
+import { ViewId } from '../view/workbench-view.model';
+import { WorkbenchLayout } from '../layout/workbench-layout';
+/**
+ * Options to control the navigation.
+ */
+export interface WorkbenchNavigationExtras extends NavigationExtras {
+    /**
+     * Controls where to open the view. Default is `auto`.
+     *
+     * One of:
+     * - 'auto':   Navigates existing views that match the path, or opens a new view otherwise. Matrix params do not affect view resolution.
+     * - 'blank':  Navigates in a new view.
+     * - <viewId>: Navigates the specified view. If already opened, replaces it, or opens a new view otherwise.
+     */
+    target?: ViewId | string | 'blank' | 'auto';
+    /**
+     * Controls which part to navigate views in.
+     *
+     * If target is `blank`, opens the view in the specified part.
+     * If target is `auto`, navigates matching views in the specified part, or opens a new view in that part otherwise.
+     *
+     * If the specified part is not in the layout, opens the view in the active part, with the active part of the main area taking precedence.
+     */
+    partId?: string;
+    /**
+     * Sets a hint to control navigation, e.g., for use in a `CanMatch` guard to differentiate between routes with an identical path.
+     *
+     * For example, views of the initial layout or a perspective are usually navigated to the empty path route to avoid cluttering the URL,
+     * requiring a navigation hint to differentiate between the routes. See {@link canMatchWorkbenchView} for an example.
+     *
+     * Like the path, a hint affects view resolution. If set, the router will only navigate views with an equivalent hint, or if not set, views without a hint.
+     *
+     * @see canMatchWorkbenchView
+     */
+    hint?: string;
+    /**
+     * Instructs the router to activate the view. Default is `true`.
+     */
+    activate?: boolean;
+    /**
+     * Specifies where to insert the view into the tab bar. Has no effect if navigating an existing view. Default is after the active view.
+     */
+    position?: number | 'start' | 'end' | 'before-active-view' | 'after-active-view';
+    /**
+     * Associates arbitrary state with a view navigation.
+     *
+     * Navigational state is stored in the browser's session history, supporting back/forward navigation, but is lost on page reload.
+     * Therefore, a view must be able to restore its state without relying on navigational state.
+     *
+     * Navigational state can be read from {@link WorkbenchView.state} or the browser's session history via `history.state`.
+     */
+    state?: ViewState;
+    /**
+     * Closes views that match the specified path and navigation hint. Matrix parameters do not affect view resolution.
+     * The path supports the asterisk wildcard segment (`*`) to match views with any value in a segment.
+     * To close a specific view, set a view target instead of a path.
+     */
+    close?: boolean;
+    /**
+     * Specifies CSS class(es) to add to the view, e.g., to locate the view in tests.
+     */
+    cssClass?: string | string[];
+}
 /**
  * Represents an ordered list of path segments instructing the router which route to navigate to.
  *
- * A command can be either a `string` or an object literal. String literals represent path segments, while object literals associate data
- * with the preceding path segment. Multiple path segments can be combined into a single command, separated by a forward slash. The first
- * path segment supports the usage of navigational symbols such as `/`, `./`, or `../`.
+ * A command can be a string or an object literal. A string represents a path segment, an object literal associates matrix parameters with the preceding segment.
+ * Multiple segments can be combined into a single command, separated by a forward slash.
  *
- * Example:
- * - Navigate to the path 'path/to/view', passing two parameters:
+ * The first path segment supports the usage of navigational symbols such as `/`, `./`, or `../`.
+ *
+ * Examples:
+ * - Navigates to the path 'path/to/view', passing two parameters:
  *   ['path', 'to', 'view', {param1: 'value1', param2: 'value2'}]
  * - Alternative syntax using a combined segment:
  *   ['path/to/view', {param1: 'value1', param2: 'value2'}]
  */
 export type Commands = any[];
+/**
+ * URL segments of views contained in the workbench layout.
+ */
+export type ViewOutlets = {
+    [viewId: ViewId]: UrlSegment[];
+};
 /**
  * Navigational view states associated with a workbench navigation.
  */
 export type ViewStates = {
-    [viewId: string]: ViewState;
+    [viewId: ViewId]: ViewState;
 };
 /**
  * State associated with a view navigation.
  *
- * State is written to the browser session history, not to the URL, so will be lost on page reload.
+ * Navigational state is stored in the browser's session history, supporting back/forward navigation, but is lost on page reload.
+ * Therefore, a view must be able to restore its state without relying on navigational state.
  *
- * State can be read from {@link WorkbenchView.state}, or the browser's session history via `history.state`.
+ * Navigational state can be read from {@link WorkbenchView.state} or the browser's session history via `history.state`.
  */
 export type ViewState = {
     [key: string]: unknown;
 };
+/**
+ * Signature of a function to modify the workbench layout.
+ *
+ * The router will invoke this function with the current workbench layout. The layout has methods for modifying it.
+ * The layout is immutable, so each modification creates a new instance. Use the instance for further modifications and finally return it.
+ *
+ * The function can call `inject` to get any required dependencies.
+ *
+ * ## Workbench Layout
+ * The workbench layout is a grid of parts. Parts are aligned relative to each other. A part is a stack of views. Content is displayed in views.
+ *
+ * ## Example
+ * The following example adds a part to the left of the main area, inserts a view and navigates it.
+ *
+ * ```ts
+ * inject(WorkbenchRouter).navigate(layout => layout
+ *   .addPart('left', {relativeTo: MAIN_AREA, align: 'left'})
+ *   .addView('navigator', {partId: 'left'})
+ *   .navigateView('navigator', ['path/to/view'])
+ *   .activateView('navigator')
+ * );
+ * ```
+ *
+ * @param layout - Reference to the current workbench layout for modification.
+ * @return Modified layout, or `null` to cancel navigation.
+ */
+export type NavigateFn = (layout: WorkbenchLayout) => Promise<WorkbenchLayout | null> | WorkbenchLayout | null;

package/lib/routing/url-segment-matcher.d.ts

@@ -0,0 +1,20 @@
+import { UrlSegment } from '@angular/router';
+/**
+ * Matches an array of URL segments against another array of URL segments.
+ *
+ * Flags:
+ * - matchWildcardPath: Indicates if wildcard path matching is enabled. If enabled, the asterisk `*` path matches any path of a segment.
+ * - matchMatrixParams: Controls whether to match matrix parameters.
+ */
+export declare class UrlSegmentMatcher {
+    private _pattern;
+    private _flags;
+    constructor(_pattern: UrlSegment[], _flags: {
+        matchWildcardPath: boolean;
+        matchMatrixParams: boolean;
+    });
+    /**
+     * Matches given array of URL segments.
+     */
+    matches(segments: UrlSegment[]): boolean;
+}

package/lib/routing/workbench-auxiliary-routes-registrator.service.d.ts

@@ -1,23 +1,25 @@
-import { CanActivateFn, CanDeactivateFn, Data, Router, Routes } from '@angular/router';
+import { InjectionToken } from '@angular/core';
+import { CanMatchFn, Router, Routes } from '@angular/router';
+import { WorkbenchConfig } from '../workbench-config';
 import * as i0 from "@angular/core";
 /**
- * Registers auxiliary routes for views.
+ * Facilitates the registration of auxiliary routes of top-level routes.
  */
 export declare class WorkbenchAuxiliaryRoutesRegistrator {
+    private _workbenchConfig;
     private _router;
-    constructor(_router: Router);
+    constructor(_workbenchConfig: WorkbenchConfig, _router: Router);
     /**
-     * Registers an auxiliary route for every primary route found in the router config, allowing
-     * primary routes to be used in named router outlets.
+     * Registers an auxiliary route for each top-level route, enabling navigation in the specified router outlet(s).
      *
-     * @param outletName - outlet names for which to create named auxiliary routes
-     * @param config of the auxiliary route
+     * @param outlets - Specifies outlets for which to create auxiliary routes.
+     * @param config - Specifies the config of the auxiliary routes.
      */
-    registerOutletAuxiliaryRoutes(outletName: string | string[], config?: OutletAuxiliaryRouteConfig): Routes;
+    registerAuxiliaryRoutes(outlets: string[], config?: AuxiliaryRouteConfig): Routes;
     /**
-     * Unregisters all auxiliary routes for the given outlet.
+     * Unregisters auxiliary routes for the given outlet.
      */
-    unregisterOutletAuxiliaryRoutes(outletName: string | string[]): void;
+    unregisterAuxiliaryRoutes(outlets: string[]): void;
     /**
      * Replaces the router configuration to install or uninstall auxiliary routes.
      */
@@ -26,10 +28,18 @@ export declare class WorkbenchAuxiliaryRoutesRegistrator {
     static ɵprov: i0.ɵɵInjectableDeclaration<WorkbenchAuxiliaryRoutesRegistrator>;
 }
 /**
- * Controls the creation of auxiliary routes for a named router outlet.
+ * Configures auxiliary routes.
  */
-export interface OutletAuxiliaryRouteConfig {
-    canActivate?: CanActivateFn[];
-    canDeactivate?: CanDeactivateFn<any>[];
-    data?: Data;
+export interface AuxiliaryRouteConfig {
+    /**
+     * Specifies "CanMatch" guard(s) to install on the wildcard route (`**`),
+     * selected by the router if no route matches the requested URL.
+     */
+    canMatchNotFoundPage?: Array<CanMatchFn>;
 }
+/**
+ * DI token to inject the outlet name of a workbench auxiliary route.
+ *
+ * Can be injected in a `CanMatch` guard to obtain a reference to the workbench element.
+ */
+export declare const WORKBENCH_AUXILIARY_ROUTE_OUTLET: InjectionToken<string>;

package/lib/routing/workbench-layout-differ.d.ts

@@ -1,6 +1,7 @@
 import { IterableChanges, IterableDiffers } from '@angular/core';
 import { ɵWorkbenchLayout } from '../layout/ɵworkbench-layout';
 import { UrlTree } from '@angular/router';
+import { ViewId } from '../view/workbench-view.model';
 import * as i0 from "@angular/core";
 /**
  * Stateful differ for finding added/removed workbench layout elements.
@@ -8,7 +9,6 @@ import * as i0 from "@angular/core";
 export declare class WorkbenchLayoutDiffer {
     private _partsDiffer;
     private _viewsDiffer;
-    private _viewOutletsDiffer;
     constructor(differs: IterableDiffers);
     /**
      * Computes differences in the layout since last time {@link WorkbenchLayoutDiffer#diff} was invoked.
@@ -23,14 +23,11 @@ export declare class WorkbenchLayoutDiffer {
 export declare class WorkbenchLayoutDiff {
     readonly addedParts: string[];
     readonly removedParts: string[];
-    readonly addedViews: string[];
-    readonly removedViews: string[];
-    readonly addedViewOutlets: string[];
-    readonly removedViewOutlets: string[];
+    readonly addedViews: `view.${number}`[];
+    readonly removedViews: `view.${number}`[];
     constructor(changes: {
         parts: IterableChanges<string> | null;
-        views: IterableChanges<string> | null;
-        viewOutlets: IterableChanges<string> | null;
+        views: IterableChanges<ViewId> | null;
     });
     toString(): string;
 }

package/lib/routing/workbench-message-box-differ.d.ts

@@ -0,0 +1,25 @@
+import { IterableChanges, IterableDiffers } from '@angular/core';
+import { UrlTree } from '@angular/router';
+import * as i0 from "@angular/core";
+/**
+ * Stateful differ for finding added/removed message boxes.
+ */
+export declare class WorkbenchMessageBoxDiffer {
+    private _messageBoxDiffer;
+    constructor(differs: IterableDiffers);
+    /**
+     * Computes differences in the URL since last time {@link WorkbenchMessageBoxDiffer#diff} was invoked.
+     */
+    diff(urlTree: UrlTree): WorkbenchMessageBoxDiff;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkbenchMessageBoxDiffer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WorkbenchMessageBoxDiffer>;
+}
+/**
+ * Lists the message boxes added/removed in the current navigation.
+ */
+export declare class WorkbenchMessageBoxDiff {
+    readonly addedMessageBoxOutlets: string[];
+    readonly removedMessageBoxOutlets: string[];
+    constructor(changes: IterableChanges<string> | null);
+    toString(): string;
+}

package/lib/routing/workbench-navigational-states.d.ts

@@ -1,5 +1,5 @@
-import { Navigation, NavigationExtras } from '@angular/router';
-import { ViewState, ViewStates } from './routing.model';
+import { Navigation } from '@angular/router';
+import { ViewStates } from './routing.model';
 /**
  * Provides methods to associate {@link WorkbenchNavigationalState} with a navigation.
  */
@@ -9,15 +9,11 @@ export declare const WorkbenchNavigationalStates: {
      */
     readonly fromNavigation: (navigation: Navigation) => WorkbenchNavigationalState | null;
     /**
-     * Resolves navigational state associated with a view.
-     *
-     * TODO [WB-LAYOUT] Remove when migrated to the new Router API as state is retained in layout.
-     */
-    readonly resolveViewState: (viewId: string) => ViewState | undefined;
-    /**
-     * Associates workbench-specific state with given navigation extras.
+     * Creates a state object with workbench-specific data that can be passed to a workbench navigation.
      */
-    readonly addToNavigationExtras: (extras: NavigationExtras, state: WorkbenchNavigationalState) => void;
+    readonly create: (state: WorkbenchNavigationalState) => {
+        [key: string]: unknown;
+    };
 };
 /**
  * Represents workbench-specific state associated with a navigation.
@@ -38,12 +34,3 @@ export interface WorkbenchNavigationalState {
      */
     viewStates: ViewStates;
 }
-/**
- * Keys for associating state with a view navigation.
- */
-export declare const WorkbenchNavigationalViewStates: {
-    /**
-     * Key for associating CSS class(es) with a view state.
-     */
-    readonly cssClass: "ɵcssClass";
-};

package/lib/routing/workbench-route-data.d.ts

@@ -5,15 +5,25 @@
  */
 export declare const WorkbenchRouteData: {
     /**
-     * Key to define the title of a view in {@link Route.data}.
+     * Property to set the title of a view in {@link Route.data}.
      */
     readonly title: "ɵworkbenchViewTitle";
     /**
-     * Key to define the heading of a view in {@link Route.data}.
+     * Property to set the heading of a view in {@link Route.data}.
      */
     readonly heading: "ɵworkbenchViewHeading";
     /**
-     * Key to associate CSS class(es) with a view in {@link Route.data}, useful in end-to-end tests for locating views and view tabs.
+     * Property to associate CSS class(es) with a view in {@link Route.data}, e.g., to locate the view in tests.
      */
     readonly cssClass: "ɵworkbenchViewCssClass";
+    /**
+     * @internal
+     *
+     * Property to obtain the outlet name of the route. This property is only set on the top-level route.
+     *
+     * Use if the route's injection context is not available, e.g., in a {@link UrlMatcher}.
+     * Otherwise, the outlet can be injected using the {@link WORKBENCH_AUXILIARY_ROUTE_OUTLET} DI token,
+     * even in child routes, e.g., in guards.
+     */
+    readonly ɵoutlet: "ɵworkbenchOutlet";
 };

package/lib/routing/workbench-router-link.directive.d.ts

@@ -1,17 +1,32 @@
 import { ChangeDetectorRef, ElementRef, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
-import { WorkbenchNavigationExtras, WorkbenchRouter } from './workbench-router.service';
+import { WorkbenchRouter } from './workbench-router.service';
 import { LocationStrategy } from '@angular/common';
 import { ActivatedRoute, Router } from '@angular/router';
 import { WorkbenchView } from '../view/workbench-view.model';
+import { Commands, WorkbenchNavigationExtras } from './routing.model';
 import * as i0 from "@angular/core";
 /**
- * Like 'RouterLink' but with functionality to target a view outlet.
+ * Like the Angular 'RouterLink' directive but with functionality to navigate a view.
  *
- * If in the context of a view in the main area and CTRL (Mac: ⌘, Windows: ⊞) key is not pressed, by default, navigation
- * replaces the content of the current view. Override this default behavior by setting a view target strategy in navigation extras.
+ * Use this directive to navigate the current view. If the user presses the CTRL key (Mac: ⌘, Windows: ⊞), this directive will open a new view.
+ *
+ * ```html
+ * <a [wbRouterLink]="['../path/to/view']">Link</a>
+ * ```
+ *
+ * You can override the default behavior by setting an explicit navigation target in navigation extras.
+ *
+ * ```html
+ * <a [wbRouterLink]="['../path/to/view']" [wbRouterLinkExtras]="{target: 'blank'}">Link</a>
+ * ```
  *
  * By default, navigation is relative to the currently activated route, if any.
+ *
  * Prepend the path with a forward slash '/' to navigate absolutely, or set `relativeTo` property in navigational extras to `null`.
+ *
+ * ```html
+ * <a [wbRouterLink]="['/path/to/view']">Link</a>
+ * ```
  */
 export declare class WorkbenchRouterLinkDirective implements OnChanges, OnDestroy {
     private _workbenchRouter;
@@ -25,14 +40,14 @@ export declare class WorkbenchRouterLinkDirective implements OnChanges, OnDestro
     private _ngOnChange$;
     private _ngOnDestroy$;
     href: string | null;
-    set wbRouterLink(commands: any[] | string | undefined | null);
-    set extras(extras: WorkbenchNavigationExtras | undefined);
+    set wbRouterLink(commands: Commands | string | undefined | null);
+    set extras(extras: Omit<WorkbenchNavigationExtras, 'close'> | undefined);
     constructor(_workbenchRouter: WorkbenchRouter, _router: Router, _route: ActivatedRoute, _locationStrategy: LocationStrategy, _cd: ChangeDetectorRef, host: ElementRef, _view: WorkbenchView | null);
     onClick(button: number, ctrlKey: boolean, metaKey: boolean): boolean;
     /**
      * Computes navigation extras based on the given extras and this directive's injection context.
      */
-    protected computeNavigationExtras(ctrlKey?: boolean, metaKey?: boolean): WorkbenchNavigationExtras;
+    protected computeNavigationExtras(ctrlKey?: boolean, metaKey?: boolean): Omit<WorkbenchNavigationExtras, 'close'>;
     /**
      * Updates the link's href based on given array of commands and navigation extras.
      */

package/lib/routing/workbench-router.service.d.ts

@@ -1,165 +1,65 @@
-import { NavigationExtras, Router } from '@angular/router';
-import { NgZone, OnDestroy } from '@angular/core';
-import { WorkbenchLayoutService } from '../layout/workbench-layout.service';
-import { WorkbenchViewRegistry } from '../view/workbench-view.registry';
-import { ɵWorkbenchLayout } from '../layout/ɵworkbench-layout';
-import { Commands, ViewState, ViewStates } from './routing.model';
+import { NavigationExtras } from '@angular/router';
+import { Commands, NavigateFn, WorkbenchNavigationExtras } from './routing.model';
 import * as i0 from "@angular/core";
 /**
- * Provides workbench view navigation capabilities based on Angular Router.
+ * Enables navigation of workbench views and modification of the workbench layout.
+ *
+ * A view is a visual workbench element for displaying content side-by-side or stacked. A view can be navigated to any route.
+ *
+ * A view can inject `ActivatedRoute` to obtain parameters passed to the navigation and/or read data associated with the route.
  */
-export declare class WorkbenchRouter implements OnDestroy {
-    private _router;
-    private _viewRegistry;
-    private _workbenchLayoutService;
-    private _zone;
-    private _singleTaskExecutor;
+export declare abstract class WorkbenchRouter {
     /**
-     * Holds the current navigational context during a workbench navigation, or `null` if no navigation is in progress.
-     */
-    private _currentNavigationContext;
-    constructor(_router: Router, _viewRegistry: WorkbenchViewRegistry, _workbenchLayoutService: WorkbenchLayoutService, _zone: NgZone);
-    /**
-     * Navigates based on the provided array of commands, and is like 'Router.navigate(...)' but with a workbench view as the router outlet target.
-     * Navigation is absolute unless providing a `relativeTo` route in navigational extras.
+     * Navigates based on the provided array of commands and extras. This method is similar to Angular's `Router.navigate(...)`, but with a view as the navigation target.
      *
-     * By passing navigation extras, you can control navigation. By default, the router opens a new view tab if no view is found that matches the
-     * specified path. Matrix parameters do not affect view resolution. If one (or more) view(s) match the specified path, they are navigated
-     * instead of opening the view in a new view tab, e.g., to update matrix parameters.
+     * A command can be a string or an object literal. A string represents a path segment, an object literal associates matrix parameters with the preceding segment.
+     * Multiple segments can be combined into a single command, separated by a forward slash.
      *
-     * The router supports for closing views matching the routing commands by setting `close` in navigational extras.
+     * By default, navigates existing views that match the path, or opens a new view otherwise. Matrix params do not affect view resolution.
+     * This behavior can be changed by setting an explicit navigation target in navigation extras.
      *
-     * ### Commands
-     * - Multiple static segments can be merged into one, e.g. `['/team/11/user', userName, {details: true}]`
-     * - The first segment name can be prepended with `/`, `./`, or `../`
-     * - Matrix parameters can be used to associate optional data with the URL, e.g. `['user', userName, {details: true}]`
-     *   Matrix parameters are like regular URL parameters, but do not affect route and view resolution. Unlike query parameters, matrix parameters
-     *   are not global but part of the routing path, which makes them suitable for auxiliary routes.
+     * By default, navigation is absolute. Set `relativeTo` in extras for relative navigation.
      *
-     * ### Usage
+     * The router supports for closing views matching the routing commands by setting `close` in navigation extras.
      *
+     * ### Usage
      * ```
-     * router.navigate(['team', 33, 'user', 11]);
-     * router.navigate(['team/11/user', userName, {details: true}]); // multiple static segments can be merged into one
-     * router.navigate(['teams', {selection: 33'}]); // matrix parameter 'selection' with the value '33'.
+     * inject(WorkbenchRouter).navigate(['team', 33, 'user', 11]);
+     * inject(WorkbenchRouter).navigate(['team/11/user', userName, {details: true}]); // multiple static segments can be merged into one
+     * inject(WorkbenchRouter).navigate(['teams', {selection: 33'}]); // matrix parameter `selection` with the value `33`.
      * ```
      *
      * @see WorkbenchRouterLinkDirective
      */
-    navigate(commands: Commands, extras?: WorkbenchNavigationExtras): Promise<boolean>;
+    abstract navigate(commands: Commands, extras?: WorkbenchNavigationExtras): Promise<boolean>;
     /**
-     * Experimental API for modifying the workbench layout.
+     * Performs changes to the current workbench layout.
      *
-     * @param onNavigate - Callback to modify the current layout.
-     *        The callback is passed the current layout which can be modified and returned for navigation. Returning `null` does not perform the navigation.
-     * @param extras - Controls how to perform the navigation.
-     */
-    ɵnavigate(onNavigate: (layout: ɵWorkbenchLayout) => Promise<ɵWorkbenchLayout | WorkbenchNavigation | null> | ɵWorkbenchLayout | WorkbenchNavigation | null, extras?: NavigationExtras): Promise<boolean>;
-    /**
-     * This method name begins with underscores to indicate that it must only be invoked from within {@link SingleTaskExecutor}.
-     */
-    private __createUrlTree;
-    /**
-     * @see normalizeCommands
-     */
-    private normalizeOutletCommands;
-    /**
-     * Normalizes commands to their absolute form.
+     * The router will invoke the passed function with the current workbench layout. The layout has methods for modifying it.
+     * The layout is immutable, so each modification creates a new instance. Use the instance for further modifications and finally return it.
      *
-     * ---
-     * As of Angular 6.x, commands which target a named outlet (auxiliary route) are not normalized, meaning that
-     * relative navigational symbols like `/`, `./`, or `../` are not resolved (see `create_url_tree.ts` method: `computeNavigation`).
+     * The function can call `inject` to get any required dependencies.
      *
-     * Example: router.navigate([{outlets: {[outlet]: commands}}])
+     * ## Workbench Layout
+     * The workbench layout is a grid of parts. Parts are aligned relative to each other. A part is a stack of views. Content is displayed in views.
      *
-     * To bypass that restriction, we first create a URL tree without specifying the target outlet. As expected, this translates into a
-     * URL with all navigational symbols resolved. Then, we extract the URL segments of the resolved route and convert it back into commands.
-     * The resulting commands are in their absolute form and may be used for the effective navigation to target a named router outlet.
-     */
-    private normalizeCommands;
-    /**
-     * Blocks until the initial layout is available, i.e. after completion of Angular's initial navigation.
-     */
-    private waitForInitialLayout;
-    /**
-     * Serializes given commands into valid URL segments.
-     */
-    private serializeCommands;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WorkbenchRouter, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WorkbenchRouter>;
-}
-/**
- * Represents the extra options used during navigation.
- */
-export interface WorkbenchNavigationExtras extends NavigationExtras {
-    /**
-     * Instructs the router to activate the view. Defaults to `true` if not specified.
-     */
-    activate?: boolean;
-    /**
-     * Closes the view(s) that match the specified path. Matrix parameters do not affect view resolution.
-     * The path supports the asterisk wildcard segment (`*`) to match view(s) with any value in that segment.
-     * To close a specific view, set a view target instead of a path.
-     */
-    close?: boolean;
-    /**
-     * Controls where to open the view.
-     *
-     * One of:
-     * - 'auto':    Opens the view in a new view tab if no view is found that matches the specified path. Matrix parameters do not affect
-     *              view resolution. If one (or more) view(s) match the specified path, they are navigated instead of opening the view
-     *              in a new view tab, e.g., to update matrix parameters. This is the default behavior if not set.
-     * - 'blank':   Opens the view in a new view tab.
-     * - <view.id>: Navigates the specified view. If already opened, replaces it, or opens the view in a new view tab otherwise.
-     *              Note that the passed view identifier must start with `view.`, e.g., `view.5`.
-     *
-     * If not specified, defaults to `auto`.
-     */
-    target?: string | 'blank' | 'auto';
-    /**
-     * Specifies in which part to open the view. By default, if not specified, opens the view in the active part of the main area,
-     * if the layout has one, otherwise in the active part of the layout.
-     */
-    blankPartId?: string;
-    /**
-     * Specifies the position where to insert the view into the tab bar when using 'blank' view target strategy.
-     * If not specified, the view is inserted after the active view. Set the index to 'start' or 'end' for inserting
-     * the view at the beginning or at the end.
-     */
-    blankInsertionIndex?: number | 'start' | 'end';
-    /**
-     * Associates state with a view navigation.
+     * ## Example
+     * The following example adds a part to the left of the main area, inserts a view and navigates it.
      *
-     * State is written to the browser session history, not to the URL, so will be lost on page reload.
+     * ```ts
+     * inject(WorkbenchRouter).navigate(layout => layout
+     *   .addPart('left', {relativeTo: MAIN_AREA, align: 'left'})
+     *   .addView('navigator', {partId: 'left'})
+     *   .navigateView('navigator', ['path/to/view'])
+     *   .activateView('navigator')
+     * );
+     * ```
      *
-     * State can be read from {@link WorkbenchView.state}, or the browser's session history via `history.state`.
-     */
-    state?: ViewState;
-    /**
-     * Specifies CSS class(es) to be added to the view, useful in end-to-end tests for locating view and view tab.
-     * CSS class(es) will not be added to the browser URL, consequently will not survive a page reload.
-     */
-    cssClass?: string | string[];
-}
-/**
- * Information about a workbench navigation operation.
- */
-export interface WorkbenchNavigation {
-    /**
-     * The target layout to apply.
-     */
-    layout: ɵWorkbenchLayout;
-    /**
-     * View outlet delta to apply to the current URL. For each outlet to add, remove, or change,
-     * add a property to this dictionary and set the commands to construct the outlet URL.
-     * To remove an outlet from the URL, set its commands to `null`.
-     */
-    viewOutlets?: {
-        [outlet: string]: Commands | null;
-    };
-    /**
-     * View states to be associated with the navigation.
+     * @param onNavigate - Specifies the callback to modify the layout.
+     * @param extras - Controls how to perform the navigation.
+     * @see NavigateFn
      */
-    viewStates?: ViewStates;
+    abstract navigate(onNavigate: NavigateFn, extras?: Omit<NavigationExtras, 'relativeTo' | 'state'>): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkbenchRouter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WorkbenchRouter>;
 }