@umbraco-cms/backoffice 1.0.0-next.ce55cd35 → 1.0.0-next.d46c6b3e

package/observable-api.d.ts

@@ -18,55 +18,55 @@ declare class UmbObserverController<T = unknown> extends UmbObserver<T> implemen
 
 /**
  * @export
- * @class BasicState
+ * @class UmbBasicState
  * @extends {BehaviorSubject<T>}
  * @description - A RxJS BehaviorSubject this Subject ensures the data is unique, not updating any Observes unless there is an actual change of the value.
  */
-declare class BasicState<T> extends BehaviorSubject<T> {
+declare class UmbBasicState<T> extends BehaviorSubject<T> {
     constructor(initialData: T);
     next(newData: T): void;
 }
 
 /**
  * @export
- * @class BooleanState
+ * @class UmbBooleanState
  * @extends {BehaviorSubject<T>}
  * @description - A RxJS BehaviorSubject this Subject ensures the data is unique, not updating any Observes unless there is an actual change of the value.
  */
-declare class BooleanState<T> extends BasicState<T | boolean> {
+declare class UmbBooleanState<T> extends UmbBasicState<T | boolean> {
     constructor(initialData: T | boolean);
 }
 
 /**
  * @export
- * @class NumberState
+ * @class UmbNumberState
  * @extends {BehaviorSubject<T>}
  * @description - A RxJS BehaviorSubject this Subject ensures the data is unique, not updating any Observes unless there is an actual change of the value.
  */
-declare class NumberState<T> extends BasicState<T | number> {
+declare class UmbNumberState<T> extends UmbBasicState<T | number> {
     constructor(initialData: T | number);
 }
 
 /**
  * @export
- * @class StringState
- * @extends {BasicState<T>}
+ * @class UmbStringState
+ * @extends {UmbBasicState<T>}
  * @description - A RxJS BehaviorSubject this Subject ensures the data is unique, not updating any Observes unless there is an actual change of the value.
  */
-declare class StringState<T> extends BasicState<T | string> {
+declare class UmbStringState<T> extends UmbBasicState<T | string> {
     constructor(initialData: T | string);
 }
 
-interface ClassStateData {
-    equal(otherClass: ClassStateData): boolean;
+interface UmbClassStateData {
+    equal(otherClass: UmbClassStateData): boolean;
 }
 /**
  * @export
- * @class ClassState
+ * @class UmbClassState
  * @extends {BehaviorSubject<T>}
  * @description - A RxJS BehaviorSubject which can hold class instance which has a equal method to compare in coming instances for changes.
  */
-declare class ClassState<T extends ClassStateData | undefined | null> extends BehaviorSubject<T> {
+declare class UmbClassState<T extends UmbClassStateData | undefined | null> extends BehaviorSubject<T> {
     constructor(initialData: T);
     next(newData: T): void;
 }
@@ -77,12 +77,12 @@ type MemoizationFunction<R> = (previousResult: R, currentResult: R) => boolean;
 
 /**
  * @export
- * @class DeepState
+ * @class UmbDeepState
  * @extends {BehaviorSubject<T>}
  * @description - A RxJS BehaviorSubject which deepFreezes the data to ensure its not manipulated from any implementations.
  * Additionally the Subject ensures the data is unique, not updating any Observes unless there is an actual change of the content.
  */
-declare class DeepState<T> extends BehaviorSubject<T> {
+declare class UmbDeepState<T> extends BehaviorSubject<T> {
     constructor(initialData: T);
     getObservablePart<ReturnType>(mappingFunction: MappingFunction<T, ReturnType>, memoizationFunction?: MemoizationFunction<ReturnType>): rxjs.Observable<ReturnType>;
     next(newData: T): void;
@@ -90,14 +90,14 @@ declare class DeepState<T> extends BehaviorSubject<T> {
 
 /**
  * @export
- * @class ArrayState
- * @extends {DeepState<T>}
+ * @class UmbArrayState
+ * @extends {UmbDeepState<T>}
  * @description - A RxJS BehaviorSubject which deepFreezes the object-data to ensure its not manipulated from any implementations.
  * Additionally the Subject ensures the data is unique, not updating any Observes unless there is an actual change of the content.
  *
  * The ArrayState provides methods to append data when the data is an Object.
  */
-declare class ArrayState<T> extends DeepState<T[]> {
+declare class UmbArrayState<T> extends UmbDeepState<T[]> {
     #private;
     constructor(initialData: T[], getUniqueMethod?: (entry: T) => unknown);
     /**
@@ -109,7 +109,7 @@ declare class ArrayState<T> extends DeepState<T[]> {
      * 	{ key: 1, value: 'foo'},
      * 	{ key: 2, value: 'bar'}
      * ];
-     * const myState = new ArrayState(data, (x) => x.key);
+     * const myState = new UmbArrayState(data, (x) => x.key);
      * myState.sortBy((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0));
      */
     sortBy(sortMethod?: (a: T, b: T) => number): this;
@@ -117,35 +117,35 @@ declare class ArrayState<T> extends DeepState<T[]> {
     /**
      * @method remove
      * @param {unknown[]} uniques - The unique values to remove.
-     * @return {ArrayState<T>} Reference to it self.
+     * @return {UmbArrayState<T>} Reference to it self.
      * @description - Remove some new data of this Subject.
      * @example <caption>Example remove entry with id '1' and '2'</caption>
      * const data = [
      * 	{ id: 1, value: 'foo'},
      * 	{ id: 2, value: 'bar'}
      * ];
-     * const myState = new ArrayState(data, (x) => x.id);
+     * const myState = new UmbArrayState(data, (x) => x.id);
      * myState.remove([1, 2]);
      */
     remove(uniques: unknown[]): this;
     /**
      * @method removeOne
      * @param {unknown} unique - The unique value to remove.
-     * @return {ArrayState<T>} Reference to it self.
+     * @return {UmbArrayState<T>} Reference to it self.
      * @description - Remove some new data of this Subject.
      * @example <caption>Example remove entry with id '1'</caption>
      * const data = [
      * 	{ id: 1, value: 'foo'},
      * 	{ id: 2, value: 'bar'}
      * ];
-     * const myState = new ArrayState(data, (x) => x.id);
+     * const myState = new UmbArrayState(data, (x) => x.id);
      * myState.removeOne(1);
      */
     removeOne(unique: unknown): this;
     /**
      * @method filter
      * @param {unknown} filterMethod - The unique value to remove.
-     * @return {ArrayState<T>} Reference to it self.
+     * @return {UmbArrayState<T>} Reference to it self.
      * @description - Remove some new data of this Subject.
      * @example <caption>Example remove entry with key '1'</caption>
      * const data = [
@@ -153,7 +153,7 @@ declare class ArrayState<T> extends DeepState<T[]> {
      * 	{ key: 2, value: 'bar'},
      * 	{ key: 3, value: 'poo'}
      * ];
-     * const myState = new ArrayState(data, (x) => x.key);
+     * const myState = new UmbArrayState(data, (x) => x.key);
      * myState.filter((entry) => entry.key !== 1);
      *
      * Result:
@@ -167,28 +167,28 @@ declare class ArrayState<T> extends DeepState<T[]> {
     /**
      * @method appendOne
      * @param {T} entry - new data to be added in this Subject.
-     * @return {ArrayState<T>} Reference to it self.
+     * @return {UmbArrayState<T>} Reference to it self.
      * @description - Append some new data to this Subject.
      * @example <caption>Example append some data.</caption>
      * const data = [
      * 	{ key: 1, value: 'foo'},
      * 	{ key: 2, value: 'bar'}
      * ];
-     * const myState = new ArrayState(data);
+     * const myState = new UmbArrayState(data);
      * myState.append({ key: 1, value: 'replaced-foo'});
      */
     appendOne(entry: T): this;
     /**
      * @method append
      * @param {T[]} entries - A array of new data to be added in this Subject.
-     * @return {ArrayState<T>} Reference to it self.
+     * @return {UmbArrayState<T>} Reference to it self.
      * @description - Append some new data to this Subject, if it compares to existing data it will replace it.
      * @example <caption>Example append some data.</caption>
      * const data = [
      * 	{ key: 1, value: 'foo'},
      * 	{ key: 2, value: 'bar'}
      * ];
-     * const myState = new ArrayState(data);
+     * const myState = new UmbArrayState(data);
      * myState.append([
      * 	{ key: 1, value: 'replaced-foo'},
      * 	{ key: 3, value: 'another-bla'}
@@ -199,14 +199,14 @@ declare class ArrayState<T> extends DeepState<T[]> {
      * @method updateOne
      * @param {unknown} unique - Unique value to find entry to update.
      * @param {Partial<T>} entry - new data to be added in this Subject.
-     * @return {ArrayState<T>} Reference to it self.
+     * @return {UmbArrayState<T>} Reference to it self.
      * @description - Update a item with some new data, requires the ArrayState to be constructed with a getUnique method.
      * @example <caption>Example append some data.</caption>
      * const data = [
      * 	{ key: 1, value: 'foo'},
      * 	{ key: 2, value: 'bar'}
      * ];
-     * const myState = new ArrayState(data, (x) => x.key);
+     * const myState = new UmbArrayState(data, (x) => x.key);
      * myState.updateOne(2, {value: 'updated-bar'});
      */
     updateOne(unique: unknown, entry: Partial<T>): this;
@@ -214,22 +214,22 @@ declare class ArrayState<T> extends DeepState<T[]> {
 
 /**
  * @export
- * @class ObjectState
- * @extends {DeepState<T>}
+ * @class UmbObjectState
+ * @extends {UmbDeepState<T>}
  * @description - A RxJS BehaviorSubject which deepFreezes the object-data to ensure its not manipulated from any implementations.
  * Additionally the Subject ensures the data is unique, not updating any Observes unless there is an actual change of the content.
  *
- * The ObjectState provides methods to append data when the data is an Object.
+ * The UmbObjectState provides methods to append data when the data is an Object.
  */
-declare class ObjectState<T> extends DeepState<T> {
+declare class UmbObjectState<T> extends UmbDeepState<T> {
     /**
      * @method update
      * @param {Partial<T>} partialData - A object containing some of the data to update in this Subject.
      * @description - Append some new data to this Object.
-     * @return {ObjectState<T>} Reference to it self.
+     * @return {UmbObjectState<T>} Reference to it self.
      * @example <caption>Example append some data.</caption>
      * const data = {key: 'myKey', value: 'myInitialValue'};
-     * const myState = new ObjectState(data);
+     * const myState = new UmbObjectState(data);
      * myState.update({value: 'myNewValue'});
      */
     update(partialData: Partial<T>): this;
@@ -254,7 +254,7 @@ declare function createObservablePart<R, T>(source$: Observable<T>, mappingFunct
  * @param {(mappable: T) => R} mappingFunction - Method to return the part for this Observable to return.
  * @param {(previousResult: R, currentResult: R) => boolean} [memoizationFunction] - Method to Compare if the data has changed. Should return true when data is different.
  * @description - Creates a RxJS Observable from RxJS Subject.
- * @example <caption>Example append new entry for a ArrayState or a part of DeepState/ObjectState it which is an array. Where the key is unique and the item will be updated if matched with existing.</caption>
+ * @example <caption>Example append new entry for a ArrayState or a part of UmbDeepState/UmbObjectState it which is an array. Where the key is unique and the item will be updated if matched with existing.</caption>
  * const entry = {id: 'myKey', value: 'myValue'};
  * const newDataSet = appendToFrozenArray(mySubject.getValue(), entry, x => x.id === id);
  * mySubject.next(newDataSet);
@@ -268,11 +268,11 @@ declare function appendToFrozenArray<T>(data: T[], entry: T, getUniqueMethod?: (
  * @param {(mappable: T) => R} mappingFunction - Method to return the part for this Observable to return.
  * @param {(previousResult: R, currentResult: R) => boolean} [memoizationFunction] - Method to Compare if the data has changed. Should return true when data is different.
  * @description - Creates a RxJS Observable from RxJS Subject.
- * @example <caption>Example append new entry for a ArrayState or a part of DeepState/ObjectState it which is an array. Where the key is unique and the item will be updated if matched with existing.</caption>
+ * @example <caption>Example append new entry for a ArrayState or a part of UmbDeepState/UmbObjectState it which is an array. Where the key is unique and the item will be updated if matched with existing.</caption>
  * const partialEntry = {value: 'myValue'};
  * const newDataSet = partialUpdateFrozenArray(mySubject.getValue(), partialEntry, x => x.key === 'myKey');
  * mySubject.next(newDataSet);
  */
 declare function partialUpdateFrozenArray<T>(data: T[], partialEntry: Partial<T>, findMethod: (entry: T) => boolean): T[];
 
-export { ArrayState, BasicState, BooleanState, ClassState, DeepState, MappingFunction, NumberState, ObjectState, StringState, UmbObserver, UmbObserverController, appendToFrozenArray, createObservablePart, partialUpdateFrozenArray };
+export { MappingFunction, UmbArrayState, UmbBasicState, UmbBooleanState, UmbClassState, UmbDeepState, UmbNumberState, UmbObjectState, UmbObserver, UmbObserverController, UmbStringState, appendToFrozenArray, createObservablePart, partialUpdateFrozenArray };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@umbraco-cms/backoffice",
-	"version": "1.0.0-next.ce55cd35",
+	"version": "1.0.0-next.d46c6b3e",
 	"license": "MIT",
 	"keywords": [
 		"umbraco",

package/repository.d.ts

@@ -8,7 +8,7 @@ interface DataSourceResponse<T = undefined> {
 }
 
 interface UmbDataSource<CreateRequestType, UpdateRequestType, ResponseType> {
-    createScaffold(parentId: string | null): Promise<DataSourceResponse$1<ResponseType>>;
+    createScaffold(parentId: string | null): Promise<DataSourceResponse$1<CreateRequestType>>;
     get(unique: string): Promise<DataSourceResponse$1<ResponseType>>;
     insert(data: CreateRequestType): Promise<any>;
     update(unique: string, data: UpdateRequestType): Promise<DataSourceResponse$1<ResponseType>>;
@@ -29,24 +29,18 @@ interface UmbTreeDataSource<PagedItemsType = any, ItemsType = any> {
     getItems(unique: Array<string>): Promise<DataSourceResponse$1<Array<ItemsType>>>;
 }
 
-interface UmbDetailRepository<DetailType> {
-    createScaffold(parentId: string | null): Promise<{
-        data?: DetailType;
-        error?: ProblemDetailsModel;
-    }>;
-    requestById(id: string): Promise<{
-        data?: DetailType;
-        error?: ProblemDetailsModel;
-    }>;
-    create(data: DetailType): Promise<{
-        error?: ProblemDetailsModel;
-    }>;
-    save(data: DetailType): Promise<{
-        error?: ProblemDetailsModel;
-    }>;
-    delete(key: string): Promise<{
-        error?: ProblemDetailsModel;
-    }>;
+interface UmbRepositoryErrorResponse {
+    error?: ProblemDetailsModel;
+}
+interface UmbRepositoryResponse<T> extends UmbRepositoryErrorResponse {
+    data?: T;
+}
+interface UmbDetailRepository<CreateRequestType = any, UpdateRequestType = any, ResponseType = any> {
+    createScaffold(parentId: string | null): Promise<UmbRepositoryResponse<CreateRequestType>>;
+    requestById(id: string): Promise<UmbRepositoryResponse<ResponseType>>;
+    create(data: CreateRequestType): Promise<UmbRepositoryErrorResponse>;
+    save(id: string, data: UpdateRequestType): Promise<UmbRepositoryErrorResponse>;
+    delete(id: string): Promise<UmbRepositoryErrorResponse>;
 }
 
 interface UmbPagedData<T> {
@@ -91,9 +85,9 @@ interface UmbFolderRepository {
         data?: UpdateFolderReponseModel;
         error?: ProblemDetailsModel;
     }>;
-    deleteFolder(key: string): Promise<{
+    deleteFolder(id: string): Promise<{
         error?: ProblemDetailsModel;
     }>;
 }
 
-export { DataSourceResponse, UmbDataSource, UmbDetailRepository, UmbFolderDataSource, UmbFolderRepository, UmbPagedData, UmbTreeDataSource, UmbTreeRepository };
+export { DataSourceResponse, UmbDataSource, UmbDetailRepository, UmbFolderDataSource, UmbFolderRepository, UmbPagedData, UmbRepositoryErrorResponse, UmbRepositoryResponse, UmbTreeDataSource, UmbTreeRepository };

package/router.d.ts

@@ -2,24 +2,6 @@ import { UmbContextToken } from './context-api';
 import { UmbControllerHostElement } from './controller';
 import { UmbModalRouteRegistration } from './modal';
 
-interface UmbRouteLocation {
-    name?: string;
-    params: {
-        [key: string]: string;
-    };
-}
-
-declare class UmbRouteContext {
-    #private;
-    private _onGotModals;
-    constructor(host: UmbControllerHostElement, _onGotModals: (contextRoutes: any) => void);
-    registerModal(registration: UmbModalRouteRegistration): UmbModalRouteRegistration<object, any>;
-    unregisterModal(registrationToken: ReturnType<typeof this$1.registerModal>): void;
-    _internal_routerGotBasePath(routerBasePath: string): void;
-    _internal_modalRouterChanged(activeModalPath: string | undefined): void;
-}
-declare const UMB_ROUTE_CONTEXT_TOKEN: UmbContextToken<UmbRouteContext>;
-
 interface IRouterSlot<D = any, P = any> extends HTMLElement {
     readonly route: IRoute<D> | null;
     readonly isRoot: boolean;
@@ -40,14 +22,21 @@ type IRoutingInfo<D = any, P = any> = {
 };
 type CustomResolver<D = any, P = any> = ((info: IRoutingInfo<D>) => boolean | void | Promise<boolean> | Promise<void>);
 type Guard<D = any, P = any> = ((info: IRoutingInfo<D, P>) => boolean | Promise<boolean>);
-type PageComponent = HTMLElement;
+type Cancel = (() => boolean);
+type PageComponent = HTMLElement | undefined;
 type ModuleResolver = Promise<{
     default: any;
 }>;
 type Class<T extends PageComponent = PageComponent> = {
     new (...args: any[]): T;
 };
+type Component = Class | ModuleResolver | PageComponent | (() => Class) | (() => PromiseLike<Class>) | (() => PageComponent) | (() => PromiseLike<PageComponent>) | (() => ModuleResolver) | (() => PromiseLike<ModuleResolver>);
 type Setup<D = any> = ((component: PageComponent, info: IRoutingInfo<D>) => void);
+type RouterTree<D = any, P = any> = {
+    slot: IRouterSlot<D, P>;
+} & {
+    child?: RouterTree;
+} | null | undefined;
 type PathMatch = "prefix" | "suffix" | "full" | "fuzzy";
 /**
  * The base route interface.
@@ -70,7 +59,7 @@ interface IRedirectRoute<D = any> extends IRouteBase<D> {
  * Route type used to resolve and stamp components.
  */
 interface IComponentRoute<D = any> extends IRouteBase<D> {
-    component: Class | ModuleResolver | PageComponent | (() => Class) | (() => PageComponent) | (() => ModuleResolver);
+    component: Component | PromiseLike<Component>;
     setup?: Setup;
 }
 /**
@@ -106,10 +95,22 @@ type NavigationEndEvent<D = any> = CustomEvent<IRoutingInfo<D>>;
 type Params = {
     [key: string]: string;
 };
+type Query = {
+    [key: string]: string;
+};
+type EventListenerSubscription = (() => void);
+/**
+ * RouterSlot related events.
+ */
+type RouterSlotEvent = "changestate";
 /**
  * History related events.
  */
 type GlobalRouterEvent = "pushstate" | "replacestate" | "popstate" | "changestate" | "willchangestate" | "navigationstart" | "navigationcancel" | "navigationerror" | "navigationsuccess" | "navigationend";
+interface ISlashOptions {
+    start: boolean;
+    end: boolean;
+}
 declare global {
     interface GlobalEventHandlersEventMap {
         "pushstate": PushStateEvent;
@@ -125,6 +126,255 @@ declare global {
     }
 }
 
-type UmbRoute = IRoute;
+/**
+ * Dispatches a did change route event.
+ * @param $elem
+ * @param {IRoute} detail
+ */
+declare function dispatchRouteChangeEvent<D = any>($elem: HTMLElement, detail: IRoutingInfo<D>): void;
+/**
+ * Dispatches an event on the window object.
+ * @param name
+ * @param detail
+ */
+declare function dispatchGlobalRouterEvent<D = any>(name: GlobalRouterEvent, detail?: IRoutingInfo<D>): void;
+/**
+ * Adds an event listener (or more) to an element and returns a function to unsubscribe.
+ * @param $elem
+ * @param type
+ * @param listener
+ * @param options
+ */
+declare function addListener<T extends Event, eventType extends string>($elem: EventTarget, type: eventType[] | eventType, listener: ((e: T) => void), options?: boolean | AddEventListenerOptions): EventListenerSubscription;
+/**
+ * Removes the event listeners in the array.
+ * @param listeners
+ */
+declare function removeListeners(listeners: EventListenerSubscription[]): void;
+
+declare const historyPatches: [string, GlobalRouterEvent[]][];
+/**
+ * Patches the history object by ensuring correct events are dispatches when the history changes.
+ */
+declare function ensureHistoryEvents(): void;
+/**
+ * Attaches a global router event after the native function on the object has been invoked.
+ * Stores the original function at the _name.
+ * @param obj
+ * @param functionName
+ * @param eventName
+ */
+declare function attachCallback(obj: any, functionName: string, eventName: GlobalRouterEvent): void;
+/**
+ * Saves the native function on the history object.
+ * @param obj
+ * @param name
+ * @param func
+ */
+declare function saveNativeFunction(obj: any, name: string, func: (() => void)): void;
+declare global {
+    interface History {
+        "native": {
+            "back": ((distance?: any) => void);
+            "forward": ((distance?: any) => void);
+            "go": ((delta?: any) => void);
+            "pushState": ((data: any, title?: string, url?: string | null) => void);
+            "replaceState": ((data: any, title?: string, url?: string | null) => void);
+        };
+    }
+}
+
+/**
+ * Determines whether the path is active.
+ * If the full path starts with the path and is followed by the end of the string or a "/" the path is considered active.
+ * @param path
+ * @param fullPath
+ */
+declare function isPathActive(path: string | PathFragment, fullPath?: string): boolean;
+/**
+ * Matches a route.
+ * @param route
+ * @param path
+ */
+declare function matchRoute<D = any>(route: IRoute<D>, path: string | PathFragment): IRouteMatch<D> | null;
+/**
+ * Matches the first route that matches the given path.
+ * @param routes
+ * @param path
+ */
+declare function matchRoutes<D = any>(routes: IRoute<D>[], path: string | PathFragment): IRouteMatch<D> | null;
+/**
+ * Returns the page from the route.
+ * If the component provided is a function (and not a class) call the function to get the promise.
+ * @param route
+ * @param info
+ */
+declare function resolvePageComponent(route: IComponentRoute, info: IRoutingInfo): Promise<PageComponent>;
+/**
+ * Determines if a route is a redirect route.
+ * @param route
+ */
+declare function isRedirectRoute(route: IRoute): route is IRedirectRoute;
+/**
+ * Determines if a route is a resolver route.
+ * @param route
+ */
+declare function isResolverRoute(route: IRoute): route is IResolverRoute;
+/**
+ * Traverses the router tree up to the root route.
+ * @param slot
+ */
+declare function traverseRouterTree(slot: IRouterSlot): {
+    tree: RouterTree;
+    depth: number;
+};
+/**
+ * Generates a path based on the router tree.
+ * @param tree
+ * @param depth
+ */
+declare function getFragments(tree: RouterTree, depth: number): PathFragment[];
+/**
+ * Constructs the correct absolute path based on a router.
+ * - Handles relative paths: "mypath"
+ * - Handles absolute paths: "/mypath"
+ * - Handles traversing paths: "../../mypath"
+ * @param slot
+ * @param path
+ */
+declare function constructAbsolutePath<D = any, P = any>(slot: IRouterSlot<D, P>, path?: string | PathFragment): string;
+/**
+ * Handles a redirect.
+ * @param slot
+ * @param route
+ */
+declare function handleRedirect(slot: IRouterSlot, route: IRedirectRoute): void;
+/**
+ * Determines whether the navigation should start based on the current match and the new match.
+ * @param currentMatch
+ * @param newMatch
+ */
+declare function shouldNavigate<D>(currentMatch: IRouteMatch<D> | null, newMatch: IRouteMatch<D>): boolean;
+
+/**
+ * Queries the parent router.
+ * @param $elem
+ */
+declare function queryParentRouterSlot<D = any>($elem: Element): IRouterSlot<D> | null;
+/**
+ * Traverses the roots and returns the first match.
+ * The minRoots parameter indicates how many roots should be traversed before we started matching with the query.
+ * @param $elem
+ * @param query
+ * @param minRoots
+ * @param roots
+ */
+declare function queryParentRoots<T>($elem: Element, query: string, minRoots?: number, roots?: number): T | null;
+
+/**
+ * The current path of the location.
+ * As default slashes are included at the start and end.
+ * @param options
+ */
+declare function path(options?: Partial<ISlashOptions>): string;
+/**
+ * Returns the path without the base path.
+ * @param options
+ */
+declare function pathWithoutBasePath(options?: Partial<ISlashOptions>): string;
+/**
+ * Returns the base path as defined in the <base> tag in the head in a reliable way.
+ * If eg. <base href="/router-slot/"> is defined this function will return "/router-slot/".
+ *
+ * An alternative would be to use regex on document.baseURI,
+ * but that will be unreliable in some cases because it
+ * doesn't use the built in HTMLHyperlinkElementUtils.
+ *
+ * To make this method more performant we could cache the anchor element.
+ * As default it will return the base path with slashes in front and at the end.
+ */
+declare function basePath(options?: Partial<ISlashOptions>): string;
+/**
+ * Creates an URL using the built in HTMLHyperlinkElementUtils.
+ * An alternative would be to use regex on document.baseURI,
+ * but that will be unreliable in some cases because it
+ * doesn't use the built in HTMLHyperlinkElementUtils.
+ *
+ * As default it will return the base path with slashes in front and at the end.
+ * @param path
+ * @param options
+ */
+declare function constructPathWithBasePath(path: string, options?: Partial<ISlashOptions>): string;
+/**
+ * Removes the start of the path that matches the part.
+ * @param path
+ * @param part
+ */
+declare function stripStart(path: string, part: string): string;
+/**
+ * Returns the query string.
+ */
+declare function queryString(): string;
+/**
+ * Returns the params for the current path.
+ * @returns Params
+ */
+declare function query(): Query;
+/**
+ * Strips the slash from the start and end of a path.
+ * @param path
+ */
+declare function stripSlash(path: string): string;
+/**
+ * Ensures the path starts and ends with a slash
+ * @param path
+ */
+declare function ensureSlash(path: string): string;
+/**
+ * Makes sure that the start and end slashes are present or not depending on the options.
+ * @param path
+ * @param start
+ * @param end
+ */
+declare function slashify(path: string, { start, end }?: Partial<ISlashOptions>): string;
+/**
+ * Turns a query string into an object.
+ * @param {string} queryString (example: ("test=123&hejsa=LOL&wuhuu"))
+ * @returns {Query}
+ */
+declare function toQuery(queryString: string): Query;
+/**
+ * Turns a query object into a string query.
+ * @param query
+ */
+declare function toQueryString(query: Query): string;
+
+/**
+ * Hook up a click listener to the window that, for all anchor tags
+ * that has a relative HREF, uses the history API instead.
+ */
+declare function ensureAnchorHistory(): void;
+
+interface UmbRouteLocation {
+    name?: string;
+    params: {
+        [key: string]: string;
+    };
+}
+
+declare class UmbRouteContext {
+    #private;
+    private _onGotModals;
+    constructor(host: UmbControllerHostElement, _onGotModals: (contextRoutes: any) => void);
+    registerModal(registration: UmbModalRouteRegistration): UmbModalRouteRegistration<object, any>;
+    unregisterModal(registrationToken: ReturnType<typeof this$1.registerModal>): void;
+    _internal_routerGotBasePath(routerBasePath: string): void;
+    _internal_modalRouterChanged(activeModalPath: string | undefined): void;
+}
+declare const UMB_ROUTE_CONTEXT_TOKEN: UmbContextToken<UmbRouteContext>;
+
+declare function generateRoutePathBuilder(path: string): (params: {
+    [key: string]: string | number;
+}) => string;
 
-export { UMB_ROUTE_CONTEXT_TOKEN, UmbRoute, UmbRouteContext, UmbRouteLocation };
+export { Cancel, ChangeStateEvent, Class, Component, CustomResolver, EventListenerSubscription, GlobalRouterEvent, Guard, IComponentRoute, IPathFragments, IRedirectRoute, IResolverRoute, IRoute, IRouteBase, IRouteMatch, IRouterSlot, IRoutingInfo, ISlashOptions, ModuleResolver, NavigationCancelEvent, NavigationEndEvent, NavigationErrorEvent, NavigationStartEvent, NavigationSuccessEvent, PageComponent, Params, PathFragment, PathMatch, PushStateEvent, Query, ReplaceStateEvent, RouterSlotEvent, RouterTree, Setup, UMB_ROUTE_CONTEXT_TOKEN, IRoute as UmbRoute, UmbRouteContext, UmbRouteLocation, WillChangeStateEvent, addListener, attachCallback, basePath, constructAbsolutePath, constructPathWithBasePath, dispatchGlobalRouterEvent, dispatchRouteChangeEvent, ensureAnchorHistory, ensureHistoryEvents, ensureSlash, generateRoutePathBuilder, getFragments, handleRedirect, historyPatches, isPathActive, isRedirectRoute, isResolverRoute, matchRoute, matchRoutes, path, pathWithoutBasePath, query, queryParentRoots, queryParentRouterSlot, queryString, removeListeners, resolvePageComponent, saveNativeFunction, shouldNavigate, slashify, stripSlash, stripStart, toQuery, toQueryString, traverseRouterTree };

package/store.d.ts

@@ -132,7 +132,7 @@ declare class UmbFileSystemTreeStore extends UmbStoreBase$1 implements UmbTreeSt
      */
     childrenOf(parentPath: string | null): rxjs.Observable<FileSystemTreeItemPresentationModel[]>;
     /**
-     * Returns an observable to observe the items with the given keys
+     * Returns an observable to observe the items with the given ids
      * @param {Array<string>} paths
      * @return {*}
      * @memberof UmbFileSystemTreeStore