@umbraco-cms/backoffice 1.0.0-next.48e903f7 → 1.0.0-next.4e56c5c5

package/models.d.ts

@@ -3,13 +3,18 @@ import { EntityTreeItemResponseModel, FolderTreeItemResponseModel, PackageManife
 type HTMLElementConstructor<T = HTMLElement> = new (...args: any[]) => T;
 type ClassConstructor<T> = new (...args: any[]) => T;
 interface Entity {
-    key: string;
+    id: string;
     name: string;
     icon: string;
     type: string;
     hasChildren: boolean;
-    parentKey: string | null;
+    parentId: string | null;
 }
+/** Tried to find a common base of our entities — used by Entity Workspace Context */
+type BaseEntity = {
+    id?: string;
+    name?: string;
+};
 interface UserEntity extends Entity {
     type: 'user';
 }
@@ -38,23 +43,23 @@ interface UserGroupDetails extends UserGroupEntity {
     permissions: Array<string>;
 }
 interface MemberTypeDetails extends EntityTreeItemResponseModel {
-    key: string;
+    id: string;
     alias: string;
     properties: [];
 }
 interface MediaTypeDetails extends FolderTreeItemResponseModel {
-    key: string;
+    id: string;
     alias: string;
     properties: [];
 }
 interface MemberGroupDetails extends EntityTreeItemResponseModel {
-    key: string;
+    id: string;
 }
 interface MemberDetails extends EntityTreeItemResponseModel {
-    key: string;
+    id: string;
 }
 interface DocumentBlueprintDetails {
-    key: string;
+    id: string;
     name: string;
     type: 'document-blueprint';
     properties: Array<any>;
@@ -72,4 +77,4 @@ type UmbPackageWithMigrationStatus = UmbPackage & {
     hasPendingMigrations: boolean;
 };
 
-export { ClassConstructor, DocumentBlueprintDetails, Entity, HTMLElementConstructor, MediaTypeDetails, MemberDetails, MemberGroupDetails, MemberTypeDetails, PackageManifestResponse, SwatchDetails, UmbPackage, UmbPackageWithMigrationStatus, UserDetails, UserEntity, UserGroupDetails, UserGroupEntity, UserStatus };
+export { BaseEntity, ClassConstructor, DocumentBlueprintDetails, Entity, HTMLElementConstructor, MediaTypeDetails, MemberDetails, MemberGroupDetails, MemberTypeDetails, PackageManifestResponse, SwatchDetails, UmbPackage, UmbPackageWithMigrationStatus, UserDetails, UserEntity, UserGroupDetails, UserGroupEntity, UserStatus };

package/observable-api.d.ts

@@ -1,6 +1,6 @@
 import * as rxjs from 'rxjs';
 import { Observable, BehaviorSubject } from 'rxjs';
-import { UmbControllerInterface, UmbControllerHostInterface } from './controller';
+import { UmbControllerInterface, UmbControllerHostElement } from './controller';
 
 declare class UmbObserver<T> {
     #private;
@@ -13,7 +13,7 @@ declare class UmbObserver<T> {
 declare class UmbObserverController<T = unknown> extends UmbObserver<T> implements UmbControllerInterface {
     _alias?: string;
     get unique(): string | undefined;
-    constructor(host: UmbControllerHostInterface, source: Observable<T>, callback: (_value: T) => void, alias?: string);
+    constructor(host: UmbControllerHostElement, source: Observable<T>, callback: (_value: T) => void, alias?: string);
 }
 
 /**
@@ -98,19 +98,33 @@ declare class DeepState<T> extends BehaviorSubject<T> {
  * The ArrayState provides methods to append data when the data is an Object.
  */
 declare class ArrayState<T> extends DeepState<T[]> {
-    private _getUnique?;
-    constructor(initialData: T[], _getUnique?: ((entry: T) => unknown) | undefined);
+    #private;
+    constructor(initialData: T[], getUniqueMethod?: (entry: T) => unknown);
+    /**
+     * @method sortBy
+     * @param {(a: T, b: T) => number} sortMethod - A method to be used for sorting everytime data is set.
+     * @description - A sort method to this Subject.
+     * @example <caption>Example add sort method</caption>
+     * const data = [
+     * 	{ key: 1, value: 'foo'},
+     * 	{ key: 2, value: 'bar'}
+     * ];
+     * const myState = new ArrayState(data, (x) => x.key);
+     * myState.sortBy((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0));
+     */
+    sortBy(sortMethod?: (a: T, b: T) => number): this;
+    next(value: T[]): void;
     /**
      * @method remove
      * @param {unknown[]} uniques - The unique values to remove.
      * @return {ArrayState<T>} Reference to it self.
      * @description - Remove some new data of this Subject.
-     * @example <caption>Example remove entry with key '1' and '2'</caption>
+     * @example <caption>Example remove entry with id '1' and '2'</caption>
      * const data = [
-     * 	{ key: 1, value: 'foo'},
-     * 	{ key: 2, value: 'bar'}
+     * 	{ id: 1, value: 'foo'},
+     * 	{ id: 2, value: 'bar'}
      * ];
-     * const myState = new ArrayState(data, (x) => x.key);
+     * const myState = new ArrayState(data, (x) => x.id);
      * myState.remove([1, 2]);
      */
     remove(uniques: unknown[]): this;
@@ -119,12 +133,12 @@ declare class ArrayState<T> extends DeepState<T[]> {
      * @param {unknown} unique - The unique value to remove.
      * @return {ArrayState<T>} Reference to it self.
      * @description - Remove some new data of this Subject.
-     * @example <caption>Example remove entry with key '1'</caption>
+     * @example <caption>Example remove entry with id '1'</caption>
      * const data = [
-     * 	{ key: 1, value: 'foo'},
-     * 	{ key: 2, value: 'bar'}
+     * 	{ id: 1, value: 'foo'},
+     * 	{ id: 2, value: 'bar'}
      * ];
-     * const myState = new ArrayState(data, (x) => x.key);
+     * const myState = new ArrayState(data, (x) => x.id);
      * myState.removeOne(1);
      */
     removeOne(unique: unknown): this;
@@ -181,6 +195,21 @@ declare class ArrayState<T> extends DeepState<T[]> {
      * ]);
      */
     append(entries: T[]): this;
+    /**
+     * @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.
+     * @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);
+     * myState.updateOne(2, {value: 'updated-bar'});
+     */
+    updateOne(unique: unknown, entry: Partial<T>): this;
 }
 
 /**
@@ -226,8 +255,8 @@ declare function createObservablePart<R, T>(source$: Observable<T>, mappingFunct
  * @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>
- * const entry = {key: 'myKey', value: 'myValue'};
- * const newDataSet = appendToFrozenArray(mySubject.getValue(), entry, x => x.key === key);
+ * const entry = {id: 'myKey', value: 'myValue'};
+ * const newDataSet = appendToFrozenArray(mySubject.getValue(), entry, x => x.id === id);
  * mySubject.next(newDataSet);
  */
 declare function appendToFrozenArray<T>(data: T[], entry: T, getUniqueMethod?: (entry: T) => unknown): T[];
@@ -246,4 +275,4 @@ declare function appendToFrozenArray<T>(data: T[], entry: T, getUniqueMethod?: (
  */
 declare function partialUpdateFrozenArray<T>(data: T[], partialEntry: Partial<T>, findMethod: (entry: T) => boolean): T[];
 
-export { ArrayState, BooleanState, ClassState, DeepState, NumberState, ObjectState, StringState, UmbObserver, UmbObserverController, appendToFrozenArray, createObservablePart, partialUpdateFrozenArray };
+export { ArrayState, BasicState, BooleanState, ClassState, DeepState, MappingFunction, NumberState, ObjectState, StringState, UmbObserver, UmbObserverController, appendToFrozenArray, createObservablePart, partialUpdateFrozenArray };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@umbraco-cms/backoffice",
-	"version": "1.0.0-next.48e903f7",
+	"version": "1.0.0-next.4e56c5c5",
 	"license": "MIT",
 	"keywords": [
 		"umbraco",
@@ -20,7 +20,9 @@
 	},
 	"type": "module",
 	"files": [
-		"*.d.ts"
+		"*.d.ts",
+		"*.json",
+		"*.md"
 	],
 	"peerDependencies": {
 		"@types/uuid": "^9.0.1",

package/repository.d.ts

@@ -1,18 +1,40 @@
-import { ProblemDetailsModel, PagedEntityTreeItemResponseModel, EntityTreeItemResponseModel } from './backend-api';
-import { Observable } from 'rxjs';
+import { ProblemDetailsModel, FolderReponseModel, CreateFolderRequestModel, UpdateFolderReponseModel, FolderModelBaseModel } from './backend-api';
 import { DataSourceResponse as DataSourceResponse$1 } from './repository';
+import { Observable } from 'rxjs';
 
 interface DataSourceResponse<T = undefined> {
     data?: T;
     error?: ProblemDetailsModel;
 }
 
+interface UmbDataSource<CreateRequestType, UpdateRequestType, ResponseType> {
+    createScaffold(parentId: string | null): Promise<DataSourceResponse$1<ResponseType>>;
+    get(unique: string): Promise<DataSourceResponse$1<ResponseType>>;
+    insert(data: CreateRequestType): Promise<any>;
+    update(unique: string, data: UpdateRequestType): Promise<DataSourceResponse$1<ResponseType>>;
+    delete(unique: string): Promise<DataSourceResponse$1>;
+}
+
+interface UmbFolderDataSource {
+    createScaffold(parentId: string | null): Promise<DataSourceResponse<FolderReponseModel>>;
+    get(unique: string): Promise<DataSourceResponse<FolderReponseModel>>;
+    insert(data: CreateFolderRequestModel): Promise<DataSourceResponse<string>>;
+    update(unique: string, data: CreateFolderRequestModel): Promise<DataSourceResponse<UpdateFolderReponseModel>>;
+    delete(unique: string): Promise<DataSourceResponse>;
+}
+
+interface UmbTreeDataSource<PagedItemsType = any, ItemsType = any> {
+    getRootItems(): Promise<DataSourceResponse$1<PagedItemsType>>;
+    getChildrenOf(parentUnique: string): Promise<DataSourceResponse$1<PagedItemsType>>;
+    getItems(unique: Array<string>): Promise<DataSourceResponse$1<Array<ItemsType>>>;
+}
+
 interface UmbDetailRepository<DetailType> {
-    createScaffold(parentKey: string | null): Promise<{
+    createScaffold(parentId: string | null): Promise<{
         data?: DetailType;
         error?: ProblemDetailsModel;
     }>;
-    requestByKey(key: string): Promise<{
+    requestById(id: string): Promise<{
         data?: DetailType;
         error?: ProblemDetailsModel;
     }>;
@@ -22,44 +44,56 @@ interface UmbDetailRepository<DetailType> {
     save(data: DetailType): Promise<{
         error?: ProblemDetailsModel;
     }>;
-    delete(key: string): Promise<{
+    delete(id: string): Promise<{
         error?: ProblemDetailsModel;
     }>;
 }
 
-interface UmbTreeRepository {
+interface UmbPagedData<T> {
+    total: number;
+    items: Array<T>;
+}
+interface UmbTreeRepository<ItemType = any, PagedItemType = UmbPagedData<ItemType>> {
     requestRootTreeItems: () => Promise<{
-        data: PagedEntityTreeItemResponseModel | undefined;
+        data: PagedItemType | undefined;
         error: ProblemDetailsModel | undefined;
-        asObservable?: () => Observable<EntityTreeItemResponseModel[]>;
+        asObservable?: () => Observable<ItemType[]>;
     }>;
-    requestTreeItemsOf: (parentKey: string | null) => Promise<{
-        data: PagedEntityTreeItemResponseModel | undefined;
+    requestTreeItemsOf: (parentUnique: string | null) => Promise<{
+        data: PagedItemType | undefined;
         error: ProblemDetailsModel | undefined;
-        asObservable?: () => Observable<EntityTreeItemResponseModel[]>;
+        asObservable?: () => Observable<ItemType[]>;
     }>;
-    requestTreeItems: (keys: string[]) => Promise<{
-        data: Array<EntityTreeItemResponseModel> | undefined;
+    requestTreeItems: (uniques: string[]) => Promise<{
+        data: Array<ItemType> | undefined;
         error: ProblemDetailsModel | undefined;
-        asObservable?: () => Observable<EntityTreeItemResponseModel[]>;
+        asObservable?: () => Observable<ItemType[]>;
     }>;
-    rootTreeItems: () => Promise<Observable<EntityTreeItemResponseModel[]>>;
-    treeItemsOf: (parentKey: string | null) => Promise<Observable<EntityTreeItemResponseModel[]>>;
-    treeItems: (keys: string[]) => Promise<Observable<EntityTreeItemResponseModel[]>>;
-}
-
-interface RepositoryTreeDataSource {
-    getRootItems(): Promise<DataSourceResponse$1<PagedEntityTreeItemResponseModel>>;
-    getChildrenOf(parentKey: string): Promise<DataSourceResponse$1<PagedEntityTreeItemResponseModel>>;
-    getItems(key: Array<string>): Promise<DataSourceResponse$1<EntityTreeItemResponseModel[]>>;
+    rootTreeItems: () => Promise<Observable<ItemType[]>>;
+    treeItemsOf: (parentUnique: string | null) => Promise<Observable<ItemType[]>>;
+    treeItems: (uniques: string[]) => Promise<Observable<ItemType[]>>;
 }
 
-interface RepositoryDetailDataSource<DetailType> {
-    createScaffold(parentKey: string | null): Promise<DataSourceResponse$1<DetailType>>;
-    get(key: string): Promise<DataSourceResponse$1<DetailType>>;
-    insert(data: DetailType): Promise<DataSourceResponse$1<DetailType>>;
-    update(data: DetailType): Promise<DataSourceResponse$1<DetailType>>;
-    delete(key: string): Promise<DataSourceResponse$1<DetailType>>;
+interface UmbFolderRepository {
+    createFolderScaffold(parentId: string | null): Promise<{
+        data?: FolderReponseModel;
+        error?: ProblemDetailsModel;
+    }>;
+    createFolder(folderRequest: CreateFolderRequestModel): Promise<{
+        data?: string;
+        error?: ProblemDetailsModel;
+    }>;
+    requestFolder(unique: string): Promise<{
+        data?: FolderReponseModel;
+        error?: ProblemDetailsModel;
+    }>;
+    updateFolder(unique: string, folder: FolderModelBaseModel): Promise<{
+        data?: UpdateFolderReponseModel;
+        error?: ProblemDetailsModel;
+    }>;
+    deleteFolder(id: string): Promise<{
+        error?: ProblemDetailsModel;
+    }>;
 }
 
-export { DataSourceResponse, RepositoryDetailDataSource, RepositoryTreeDataSource, UmbDetailRepository, UmbTreeRepository };
+export { DataSourceResponse, UmbDataSource, UmbDetailRepository, UmbFolderDataSource, UmbFolderRepository, UmbPagedData, UmbTreeDataSource, UmbTreeRepository };

package/resources.d.ts

@@ -1,11 +1,11 @@
 import { UmbNotificationOptions } from './notification';
 import { ProblemDetailsModel } from './backend-api';
-import { UmbController, UmbControllerHostInterface } from './controller';
+import { UmbController, UmbControllerHostElement } from './controller';
 import { DataSourceResponse as DataSourceResponse$1 } from './repository';
 
 declare class UmbResourceController extends UmbController {
     #private;
-    constructor(host: UmbControllerHostInterface, promise: Promise<any>, alias?: string);
+    constructor(host: UmbControllerHostElement, promise: Promise<any>, alias?: string);
     hostConnected(): void;
     hostDisconnected(): void;
     /**
@@ -45,6 +45,6 @@ interface DataSourceResponse<T = undefined> {
 
 declare function tryExecute<T>(promise: Promise<T>): Promise<DataSourceResponse<T>>;
 
-declare function tryExecuteAndNotify<T>(host: UmbControllerHostInterface, resource: Promise<T>, options?: UmbNotificationOptions<any>): Promise<DataSourceResponse<T>>;
+declare function tryExecuteAndNotify<T>(host: UmbControllerHostElement, resource: Promise<T>, options?: UmbNotificationOptions<any>): Promise<DataSourceResponse<T>>;
 
 export { UmbResourceController, tryExecute, tryExecuteAndNotify };

package/router.d.ts

@@ -0,0 +1,130 @@
+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;
+    readonly fragments: IPathFragments | null;
+    readonly params: Params | null;
+    readonly match: IRouteMatch<D> | null;
+    routes: IRoute<D>[];
+    add: ((routes: IRoute<D>[], navigate?: boolean) => void);
+    clear: (() => void);
+    render: (() => Promise<void>);
+    constructAbsolutePath: ((path: PathFragment) => string);
+    parent: IRouterSlot<P> | null | undefined;
+    queryParentRouterSlot: (() => IRouterSlot<P> | null);
+}
+type IRoutingInfo<D = any, P = any> = {
+    slot: IRouterSlot<D, P>;
+    match: IRouteMatch<D>;
+};
+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 ModuleResolver = Promise<{
+    default: any;
+}>;
+type Class<T extends PageComponent = PageComponent> = {
+    new (...args: any[]): T;
+};
+type Setup<D = any> = ((component: PageComponent, info: IRoutingInfo<D>) => void);
+type PathMatch = "prefix" | "suffix" | "full" | "fuzzy";
+/**
+ * The base route interface.
+ * D = the data type of the data
+ */
+interface IRouteBase<D = any> {
+    path: PathFragment;
+    data?: D;
+    guards?: Guard[];
+    pathMatch?: PathMatch;
+}
+/**
+ * Route type used for redirection.
+ */
+interface IRedirectRoute<D = any> extends IRouteBase<D> {
+    redirectTo: string;
+    preserveQuery?: boolean;
+}
+/**
+ * Route type used to resolve and stamp components.
+ */
+interface IComponentRoute<D = any> extends IRouteBase<D> {
+    component: Class | ModuleResolver | PageComponent | (() => Class) | (() => PageComponent) | (() => ModuleResolver);
+    setup?: Setup;
+}
+/**
+ * Route type used to take control of how the route should resolve.
+ */
+interface IResolverRoute<D = any> extends IRouteBase<D> {
+    resolve: CustomResolver;
+}
+type IRoute<D = any> = IRedirectRoute<D> | IComponentRoute<D> | IResolverRoute<D>;
+type PathFragment = string;
+type IPathFragments = {
+    consumed: PathFragment;
+    rest: PathFragment;
+};
+interface IRouteMatch<D = any> {
+    route: IRoute<D>;
+    params: Params;
+    fragments: IPathFragments;
+    match: RegExpMatchArray;
+}
+type PushStateEvent = CustomEvent<null>;
+type ReplaceStateEvent = CustomEvent<null>;
+type ChangeStateEvent = CustomEvent<null>;
+type WillChangeStateEvent = CustomEvent<{
+    url?: string | null;
+    eventName: GlobalRouterEvent;
+}>;
+type NavigationStartEvent<D = any> = CustomEvent<IRoutingInfo<D>>;
+type NavigationSuccessEvent<D = any> = CustomEvent<IRoutingInfo<D>>;
+type NavigationCancelEvent<D = any> = CustomEvent<IRoutingInfo<D>>;
+type NavigationErrorEvent<D = any> = CustomEvent<IRoutingInfo<D>>;
+type NavigationEndEvent<D = any> = CustomEvent<IRoutingInfo<D>>;
+type Params = {
+    [key: string]: string;
+};
+/**
+ * History related events.
+ */
+type GlobalRouterEvent = "pushstate" | "replacestate" | "popstate" | "changestate" | "willchangestate" | "navigationstart" | "navigationcancel" | "navigationerror" | "navigationsuccess" | "navigationend";
+declare global {
+    interface GlobalEventHandlersEventMap {
+        "pushstate": PushStateEvent;
+        "replacestate": ReplaceStateEvent;
+        "popstate": PopStateEvent;
+        "changestate": ChangeStateEvent;
+        "navigationstart": NavigationStartEvent;
+        "navigationend": NavigationEndEvent;
+        "navigationsuccess": NavigationSuccessEvent;
+        "navigationcancel": NavigationCancelEvent;
+        "navigationerror": NavigationErrorEvent;
+        "willchangestate": WillChangeStateEvent;
+    }
+}
+
+type UmbRoute = IRoute;
+
+export { UMB_ROUTE_CONTEXT_TOKEN, UmbRoute, UmbRouteContext, UmbRouteLocation };

package/store.d.ts

@@ -1,8 +1,8 @@
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
-import { UmbControllerHostInterface } from './controller';
-import { EntityTreeItemResponseModel } from './backend-api';
-import { UmbStoreBase as UmbStoreBase$1 } from './store';
+import { UmbControllerHostElement } from './controller';
+import { EntityTreeItemResponseModel, FileSystemTreeItemPresentationModel } from './backend-api';
+import { UmbStoreBase as UmbStoreBase$1, UmbTreeStore as UmbTreeStore$1 } from './store';
 
 interface UmbDataStoreIdentifiers {
     key?: string;
@@ -11,24 +11,6 @@ interface UmbDataStoreIdentifiers {
 interface UmbDataStore {
     readonly storeAlias: string;
 }
-interface UmbTreeStore<T> extends UmbDataStore {
-    getTreeRoot(): Observable<Array<T>>;
-    getTreeItemChildren(key: string): Observable<Array<T>>;
-    /**
-     * @description - Trash data.
-     * @param {string[]} keys
-     * @return {*}  {(Promise<void>)}
-     * @memberof UmbTreeStore
-     */
-    trash(keys: string[]): Promise<void>;
-    /**
-     * @description - Move data.
-     * @param {string[]} keys
-     * @return {*}  {(Promise<void>)}
-     * @memberof UmbTreeStore
-     */
-    move(keys: string[], destination: string): Promise<void>;
-}
 interface UmbEntityDetailStore<T> extends UmbDataStore {
     /**
      * @description - Request scaffold data by entityType and . The data is added to the store and is returned as an Observable.
@@ -36,7 +18,7 @@ interface UmbEntityDetailStore<T> extends UmbDataStore {
      * @return {*}  {T}
      * @memberof UmbEntityDetailStore
      */
-    getScaffold: (entityType: string, parentKey: string | null) => T;
+    getScaffold: (entityType: string, parentId: string | null) => T;
     /**
      * @description - Request data by key. The data is added to the store and is returned as an Observable.
      * @param {string} key
@@ -57,57 +39,121 @@ interface UmbContentStore<T> extends UmbEntityDetailStore<T> {
 }
 
 declare class UmbStoreBase {
-    protected _host: UmbControllerHostInterface;
+    protected _host: UmbControllerHostElement;
     readonly storeAlias: string;
-    constructor(_host: UmbControllerHostInterface, storeAlias: string);
+    constructor(_host: UmbControllerHostElement, storeAlias: string);
 }
 
 /**
  * @export
- * @class UmbTreeStoreBase
+ * @class UmbEntityTreeStore
  * @extends {UmbStoreBase}
  * @description - General Tree Data Store
  */
-declare class UmbTreeStoreBase extends UmbStoreBase$1 {
+declare class UmbEntityTreeStore extends UmbStoreBase$1 implements UmbTreeStore$1<EntityTreeItemResponseModel> {
     #private;
     /**
      * Appends items to the store
-     * @param {Array<EntityTreeItemModel>} items
-     * @memberof UmbTreeStoreBase
+     * @param {Array<EntityTreeItemResponseModel>} items
+     * @memberof UmbEntityTreeStore
      */
     appendItems(items: Array<EntityTreeItemResponseModel>): void;
     /**
      * Updates an item in the store
-     * @param {string} key
-     * @param {Partial<EntityTreeItemModel>} data
-     * @memberof UmbTreeStoreBase
+     * @param {string} id
+     * @param {Partial<EntityTreeItemResponseModel>} data
+     * @memberof UmbEntityTreeStore
      */
-    updateItem(key: string, data: Partial<EntityTreeItemResponseModel>): void;
+    updateItem(id: string, data: Partial<EntityTreeItemResponseModel>): void;
     /**
      * Removes an item from the store
-     * @param {string} key
-     * @memberof UmbTreeStoreBase
+     * @param {string} id
+     * @memberof UmbEntityTreeStore
      */
-    removeItem(key: string): void;
+    removeItem(id: string): void;
     /**
      * An observable to observe the root items
-     * @memberof UmbTreeStoreBase
+     * @memberof UmbEntityTreeStore
      */
     rootItems: rxjs.Observable<EntityTreeItemResponseModel[]>;
     /**
      * Returns an observable to observe the children of a given parent
-     * @param {(string | null)} parentKey
+     * @param {(string | null)} parentId
      * @return {*}
-     * @memberof UmbTreeStoreBase
+     * @memberof UmbEntityTreeStore
      */
-    childrenOf(parentKey: string | null): rxjs.Observable<EntityTreeItemResponseModel[]>;
+    childrenOf(parentId: string | null): rxjs.Observable<EntityTreeItemResponseModel[]>;
     /**
-     * Returns an observable to observe the items with the given keys
-     * @param {Array<string>} keys
+     * Returns an observable to observe the items with the given ids
+     * @param {Array<string>} ids
      * @return {*}
-     * @memberof UmbTreeStoreBase
+     * @memberof UmbEntityTreeStore
+     */
+    items(ids: Array<string>): rxjs.Observable<EntityTreeItemResponseModel[]>;
+}
+
+/**
+ * @export
+ * @class UmbFileSystemTreeStore
+ * @extends {UmbStoreBase}
+ * @description - General Tree Data Store
+ */
+declare class UmbFileSystemTreeStore extends UmbStoreBase$1 implements UmbTreeStore$1<FileSystemTreeItemPresentationModel> {
+    #private;
+    /**
+     * Appends items to the store
+     * @param {Array<FileSystemTreeItemPresentationModel>} items
+     * @memberof UmbFileSystemTreeStore
      */
-    items(keys: Array<string>): rxjs.Observable<EntityTreeItemResponseModel[]>;
+    appendItems(items: Array<FileSystemTreeItemPresentationModel>): void;
+    /**
+     * Updates an item in the store
+     * @param {string} path
+     * @param {Partial<FileSystemTreeItemPresentationModel>} data
+     * @memberof UmbFileSystemTreeStore
+     */
+    updateItem(path: string, data: Partial<FileSystemTreeItemPresentationModel>): void;
+    /**
+     * Removes an item from the store
+     * @param {string} path
+     * @memberof UmbFileSystemTreeStore
+     */
+    removeItem(path: string): void;
+    /**
+     * An observable to observe the root items
+     * @memberof UmbFileSystemTreeStore
+     */
+    rootItems: rxjs.Observable<FileSystemTreeItemPresentationModel[]>;
+    /**
+     * Returns an observable to observe the children of a given parent
+     * @param {(string | null)} parentPath
+     * @return {*}
+     * @memberof UmbFileSystemTreeStore
+     */
+    childrenOf(parentPath: string | null): rxjs.Observable<FileSystemTreeItemPresentationModel[]>;
+    /**
+     * Returns an observable to observe the items with the given ids
+     * @param {Array<string>} paths
+     * @return {*}
+     * @memberof UmbFileSystemTreeStore
+     */
+    items(paths: Array<string>): rxjs.Observable<FileSystemTreeItemPresentationModel[]>;
+}
+
+type TreeItemPresentationModel = {
+    name?: string;
+    type?: string;
+    icon?: string;
+    hasChildren?: boolean;
+};
+
+interface UmbTreeStore<T extends TreeItemPresentationModel = any> {
+    appendItems: (items: Array<T>) => void;
+    updateItem: (unique: string, item: Partial<T>) => void;
+    removeItem: (unique: string) => void;
+    rootItems: Observable<Array<T>>;
+    childrenOf: (parentUnique: string | null) => Observable<Array<T>>;
+    items: (uniques: Array<string>) => Observable<Array<T>>;
 }
 
-export { UmbContentStore, UmbDataStore, UmbDataStoreIdentifiers, UmbEntityDetailStore, UmbStoreBase, UmbTreeStore, UmbTreeStoreBase };
+export { UmbContentStore, UmbDataStore, UmbDataStoreIdentifiers, UmbEntityDetailStore, UmbEntityTreeStore, UmbFileSystemTreeStore, UmbStoreBase, UmbTreeStore };

package/utils.d.ts

@@ -11,4 +11,6 @@ declare function umbracoPath(path: string): string;
 declare function buildUdi(entityType: string, guid: string): string;
 declare function getKeyFromUdi(udi: string): string;
 
-export { buildUdi, getKeyFromUdi, getLookAndColorFromUserStatus, umbracoPath };
+declare function generateGuid(): string;
+
+export { buildUdi, generateGuid, getKeyFromUdi, getLookAndColorFromUserStatus, umbracoPath };