@umbraco-cms/backoffice 1.0.0-next.f1bd6ec7 → 1.0.0-next.f63da516

package/repository.d.ts

@@ -1,16 +1,19 @@
-import { ProblemDetailsModel, FolderReponseModel, CreateFolderRequestModel, UpdateFolderReponseModel, FolderModelBaseModel } from './backend-api';
-import { DataSourceResponse as DataSourceResponse$1 } from './repository';
+import { ApiError, CancelError, FolderReponseModel, CreateFolderRequestModel, UpdateFolderReponseModel, TreeItemPresentationModel, ProblemDetailsModel, FolderModelBaseModel, ItemResponseModelBaseModel } from '@umbraco-cms/backoffice/backend-api';
+import { DataSourceResponse as DataSourceResponse$1, UmbDataSourceErrorResponse as UmbDataSourceErrorResponse$1 } from '@umbraco-cms/backoffice/repository';
 import { Observable } from 'rxjs';
+import { UmbTreeRootModel, UmbTreeRootEntityModel } from '@umbraco-cms/backoffice/tree';
 
-interface DataSourceResponse<T = undefined> {
+interface DataSourceResponse<T = undefined> extends UmbDataSourceErrorResponse {
     data?: T;
-    error?: ProblemDetailsModel;
+}
+interface UmbDataSourceErrorResponse {
+    error?: ApiError | CancelError;
 }
 
-interface UmbDataSource<CreateRequestType, UpdateRequestType, ResponseType> {
+interface UmbDataSource<CreateRequestType, CreateResponseType, UpdateRequestType, ResponseType> {
     createScaffold(parentId: string | null): Promise<DataSourceResponse$1<CreateRequestType>>;
     get(unique: string): Promise<DataSourceResponse$1<ResponseType>>;
-    insert(data: CreateRequestType): Promise<any>;
+    insert(data: CreateRequestType): Promise<DataSourceResponse$1<CreateResponseType>>;
     update(unique: string, data: UpdateRequestType): Promise<DataSourceResponse$1<ResponseType>>;
     delete(unique: string): Promise<DataSourceResponse$1>;
 }
@@ -23,10 +26,56 @@ interface UmbFolderDataSource {
     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 UmbPagedData<T> {
+    total: number;
+    items: Array<T>;
+}
+interface UmbTreeRepository<TreeItemType extends TreeItemPresentationModel, TreeRootType extends UmbTreeRootModel = UmbTreeRootEntityModel> {
+    requestTreeRoot: () => Promise<{
+        data?: TreeRootType;
+        error?: ProblemDetailsModel;
+    }>;
+    requestRootTreeItems: () => Promise<{
+        data?: UmbPagedData<TreeItemType>;
+        error?: ProblemDetailsModel;
+        asObservable?: () => Observable<TreeItemType[]>;
+    }>;
+    requestTreeItemsOf: (parentUnique: string | null) => Promise<{
+        data?: UmbPagedData<TreeItemType>;
+        error?: ProblemDetailsModel;
+        asObservable?: () => Observable<TreeItemType[]>;
+    }>;
+    requestItemsLegacy?: (uniques: string[]) => Promise<{
+        data?: Array<TreeItemType>;
+        error?: ProblemDetailsModel;
+        asObservable?: () => Observable<any[]>;
+    }>;
+    rootTreeItems: () => Promise<Observable<TreeItemType[]>>;
+    treeItemsOf: (parentUnique: string | null) => Promise<Observable<TreeItemType[]>>;
+    itemsLegacy?: (uniques: string[]) => Promise<Observable<any[]>>;
+}
+
+interface UmbTreeDataSource<ItemType = any, PagedItemType = UmbPagedData<ItemType>> {
+    getRootItems(): Promise<DataSourceResponse<PagedItemType>>;
+    getChildrenOf(parentUnique: string | null): Promise<DataSourceResponse<PagedItemType>>;
+    getItems(unique: Array<string>): Promise<DataSourceResponse<Array<any>>>;
+}
+
+interface UmbItemDataSource<ItemType> {
+    getItems(unique: Array<string>): Promise<DataSourceResponse$1<Array<ItemType>>>;
+}
+
+interface UmbMoveDataSource {
+    move(unique: string, targetUnique: string | null): Promise<UmbDataSourceErrorResponse$1>;
+}
+
+interface UmbCopyDataSource {
+    copy(unique: string, targetUnique: string | null): Promise<DataSourceResponse$1<string>>;
+}
+
+interface UmbCollectionDataSource<ItemType = any, PagedItemType = UmbPagedData<ItemType>> {
+    getCollection(): Promise<DataSourceResponse<PagedItemType>>;
+    filterCollection(filter: any): Promise<DataSourceResponse<PagedItemType>>;
 }
 
 interface UmbRepositoryErrorResponse {
@@ -35,39 +84,15 @@ interface UmbRepositoryErrorResponse {
 interface UmbRepositoryResponse<T> extends UmbRepositoryErrorResponse {
     data?: T;
 }
-interface UmbDetailRepository<CreateRequestType = any, UpdateRequestType = any, ResponseType = any> {
+interface UmbDetailRepository<CreateRequestType = any, CreateResponseType = any, UpdateRequestType = any, ResponseType = any> {
     createScaffold(parentId: string | null): Promise<UmbRepositoryResponse<CreateRequestType>>;
     requestById(id: string): Promise<UmbRepositoryResponse<ResponseType>>;
-    create(data: CreateRequestType): Promise<UmbRepositoryErrorResponse>;
+    byId(id: string): Promise<Observable<ResponseType>>;
+    create(data: CreateRequestType): Promise<UmbRepositoryResponse<CreateResponseType>>;
     save(id: string, data: UpdateRequestType): Promise<UmbRepositoryErrorResponse>;
     delete(id: string): Promise<UmbRepositoryErrorResponse>;
 }
 
-interface UmbPagedData<T> {
-    total: number;
-    items: Array<T>;
-}
-interface UmbTreeRepository<ItemType = any, PagedItemType = UmbPagedData<ItemType>> {
-    requestRootTreeItems: () => Promise<{
-        data: PagedItemType | undefined;
-        error: ProblemDetailsModel | undefined;
-        asObservable?: () => Observable<ItemType[]>;
-    }>;
-    requestTreeItemsOf: (parentUnique: string | null) => Promise<{
-        data: PagedItemType | undefined;
-        error: ProblemDetailsModel | undefined;
-        asObservable?: () => Observable<ItemType[]>;
-    }>;
-    requestTreeItems: (uniques: string[]) => Promise<{
-        data: Array<ItemType> | undefined;
-        error: ProblemDetailsModel | undefined;
-        asObservable?: () => Observable<ItemType[]>;
-    }>;
-    rootTreeItems: () => Promise<Observable<ItemType[]>>;
-    treeItemsOf: (parentUnique: string | null) => Promise<Observable<ItemType[]>>;
-    treeItems: (uniques: string[]) => Promise<Observable<ItemType[]>>;
-}
-
 interface UmbFolderRepository {
     createFolderScaffold(parentId: string | null): Promise<{
         data?: FolderReponseModel;
@@ -90,4 +115,25 @@ interface UmbFolderRepository {
     }>;
 }
 
-export { DataSourceResponse, UmbDataSource, UmbDetailRepository, UmbFolderDataSource, UmbFolderRepository, UmbPagedData, UmbRepositoryErrorResponse, UmbRepositoryResponse, UmbTreeDataSource, UmbTreeRepository };
+interface UmbCollectionRepository {
+    requestCollection(filter?: any): Promise<any>;
+}
+
+interface UmbItemRepository<ItemType extends ItemResponseModelBaseModel> {
+    requestItems: (uniques: string[]) => Promise<{
+        data?: Array<ItemType> | undefined;
+        error?: ProblemDetailsModel | undefined;
+        asObservable?: () => Observable<Array<ItemType>>;
+    }>;
+    items: (uniques: string[]) => Promise<Observable<Array<ItemType>>>;
+}
+
+interface UmbMoveRepository {
+    move(unique: string, targetUnique: string): Promise<UmbRepositoryErrorResponse>;
+}
+
+interface UmbCopyRepository {
+    copy(unique: string, targetUnique: string): Promise<UmbRepositoryResponse<string>>;
+}
+
+export { DataSourceResponse, UmbCollectionDataSource, UmbCollectionRepository, UmbCopyDataSource, UmbCopyRepository, UmbDataSource, UmbDataSourceErrorResponse, UmbDetailRepository, UmbFolderDataSource, UmbFolderRepository, UmbItemDataSource, UmbItemRepository, UmbMoveDataSource, UmbMoveRepository, UmbPagedData, UmbRepositoryErrorResponse, UmbRepositoryResponse, UmbTreeDataSource, UmbTreeRepository };

package/resources.d.ts

@@ -1,25 +1,20 @@
-import { UmbNotificationOptions } from './notification';
-import { ProblemDetailsModel } from './backend-api';
-import { UmbController, UmbControllerHostElement } from './controller';
-import { DataSourceResponse as DataSourceResponse$1 } from './repository';
+import { UmbNotificationOptions } from '@umbraco-cms/backoffice/notification';
+import { UmbController, UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { DataSourceResponse as DataSourceResponse$1 } from '@umbraco-cms/backoffice/repository';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { ApiError, CancelError } from '@umbraco-cms/backoffice/backend-api';
 
 declare class UmbResourceController extends UmbController {
     #private;
     constructor(host: UmbControllerHostElement, promise: Promise<any>, alias?: string);
     hostConnected(): void;
     hostDisconnected(): void;
-    /**
-     * Extract the ProblemDetailsModel object from an ApiError.
-     *
-     * This assumes that all ApiErrors contain a ProblemDetailsModel object in their body.
-     */
-    static toProblemDetailsModel(error: unknown): ProblemDetailsModel | undefined;
     /**
      * Base execute function with a try/catch block and return a tuple with the result and the error.
      */
     static tryExecute<T>(promise: Promise<T>): Promise<DataSourceResponse$1<T>>;
     /**
-     * Wrap the {execute} function in a try/catch block and return the result.
+     * Wrap the {tryExecute} function in a try/catch block and return the result.
      * If the executor function throws an error, then show the details in a notification.
      */
     tryExecuteAndNotify<T>(options?: UmbNotificationOptions): Promise<DataSourceResponse$1<T>>;
@@ -38,13 +33,27 @@ declare class UmbResourceController extends UmbController {
     destroy(): void;
 }
 
-interface DataSourceResponse<T = undefined> {
+/**
+ * The base URL of the configured Umbraco server.
+ * If the server is local, this will be an empty string.
+ *
+ * @remarks This is the base URL of the Umbraco server, not the base URL of the backoffice.
+ *
+ * @example https://localhost:44300
+ * @example https://my-umbraco-site.com
+ * @example ''
+ */
+declare const UMB_SERVER_URL: UmbContextToken<string>;
+
+interface DataSourceResponse<T = undefined> extends UmbDataSourceErrorResponse {
     data?: T;
-    error?: ProblemDetailsModel;
+}
+interface UmbDataSourceErrorResponse {
+    error?: ApiError | CancelError;
 }
 
 declare function tryExecute<T>(promise: Promise<T>): Promise<DataSourceResponse<T>>;
 
-declare function tryExecuteAndNotify<T>(host: UmbControllerHostElement, resource: Promise<T>, options?: UmbNotificationOptions<any>): Promise<DataSourceResponse<T>>;
+declare function tryExecuteAndNotify<T>(host: UmbControllerHostElement, resource: Promise<T>, options?: UmbNotificationOptions): Promise<DataSourceResponse<T>>;
 
-export { UmbResourceController, tryExecute, tryExecuteAndNotify };
+export { UMB_SERVER_URL, UmbResourceController, tryExecute, tryExecuteAndNotify };

package/router.d.ts

@@ -1,6 +1,6 @@
-import { UmbContextToken } from './context-api';
-import { UmbControllerHostElement } from './controller';
-import { UmbModalRouteRegistration } from './modal';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { UmbModalRouteRegistration } from '@umbraco-cms/backoffice/modal';
 
 interface IRouterSlot<D = any, P = any> extends HTMLElement {
     readonly route: IRoute<D> | null;
@@ -22,7 +22,6 @@ 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 Cancel = (() => boolean);
 type PageComponent = HTMLElement | undefined;
 type ModuleResolver = Promise<{
     default: any;
@@ -99,10 +98,6 @@ type Query = {
     [key: string]: string;
 };
 type EventListenerSubscription = (() => void);
-/**
- * RouterSlot related events.
- */
-type RouterSlotEvent = "changestate";
 /**
  * History related events.
  */
@@ -355,13 +350,6 @@ declare function toQueryString(query: Query): string;
  */
 declare function ensureAnchorHistory(): void;
 
-interface UmbRouteLocation {
-    name?: string;
-    params: {
-        [key: string]: string;
-    };
-}
-
 declare class UmbRouteContext {
     #private;
     private _onGotModals;
@@ -377,4 +365,4 @@ declare function generateRoutePathBuilder(path: string): (params: {
     [key: string]: string | number;
 }) => string;
 
-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 };
+export { Guard, IComponentRoute, IRedirectRoute, IResolverRoute, IRoutingInfo, PageComponent, Params, Query, UMB_ROUTE_CONTEXT_TOKEN, IRoute as UmbRoute, UmbRouteContext, 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/section.d.ts

@@ -0,0 +1,29 @@
+import * as rxjs from 'rxjs';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { ManifestSection } from '@umbraco-cms/backoffice/extensions-registry';
+
+declare class UmbSectionSidebarContext {
+    #private;
+    contextMenuIsOpen: rxjs.Observable<boolean>;
+    entityType: rxjs.Observable<string | undefined>;
+    unique: rxjs.Observable<string | null | undefined>;
+    headline: rxjs.Observable<string | undefined>;
+    constructor(host: UmbControllerHostElement);
+    toggleContextMenu(entityType: string, unique: string | null | undefined, headline: string): void;
+    openContextMenu(entityType: string, unique: string | null | undefined, headline: string): void;
+    closeContextMenu(): void;
+}
+declare const UMB_SECTION_SIDEBAR_CONTEXT_TOKEN: UmbContextToken<UmbSectionSidebarContext>;
+
+declare class UmbSectionContext {
+    #private;
+    readonly alias: rxjs.Observable<string | undefined>;
+    readonly pathname: rxjs.Observable<string | undefined>;
+    readonly label: rxjs.Observable<string | undefined>;
+    constructor(manifest: ManifestSection);
+    setManifest(manifest?: ManifestSection): void;
+}
+declare const UMB_SECTION_CONTEXT_TOKEN: UmbContextToken<UmbSectionContext>;
+
+export { UMB_SECTION_CONTEXT_TOKEN, UMB_SECTION_SIDEBAR_CONTEXT_TOKEN, UmbSectionContext, UmbSectionSidebarContext };

package/sorter.d.ts

@@ -0,0 +1,103 @@
+import { UmbControllerInterface, UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+
+type INTERNAL_UmbSorterConfig<T> = {
+    compareElementToModel: (el: HTMLElement, modelEntry: T) => boolean;
+    querySelectModelToElement: (container: HTMLElement, modelEntry: T) => HTMLElement | null;
+    identifier: string;
+    itemSelector: string;
+    disabledItemSelector?: string;
+    containerSelector: string;
+    ignorerSelector: string;
+    placeholderClass: string;
+    draggableSelector?: string;
+    boundarySelector?: string;
+    dataTransferResolver?: (dataTransfer: DataTransfer | null, currentItem: T) => void;
+    onStart?: (argument: {
+        item: T;
+        element: HTMLElement;
+    }) => void;
+    onChange?: (argument: {
+        item: T;
+        element: HTMLElement;
+    }) => void;
+    onContainerChange?: (argument: {
+        item: T;
+        element: HTMLElement;
+    }) => void;
+    onEnd?: (argument: {
+        item: T;
+        element: HTMLElement;
+    }) => void;
+    onSync?: (argument: {
+        item: T;
+        fromController: UmbSorterController<T>;
+        toController: UmbSorterController<T>;
+    }) => void;
+    itemHasNestedContainersResolver?: (element: HTMLElement) => boolean;
+    onDisallowed?: () => void;
+    onAllowed?: () => void;
+    onRequestDrop?: (argument: {
+        item: T;
+    }) => boolean | void;
+    resolveVerticalDirection?: (argument: {
+        containerElement: Element;
+        containerRect: DOMRect;
+        item: T;
+        element: HTMLElement;
+        elementRect: DOMRect;
+        relatedElement: HTMLElement;
+        relatedRect: DOMRect;
+        placeholderIsInThisRow: boolean;
+        horizontalPlaceAfter: boolean;
+    }) => void;
+    performItemInsert?: (argument: {
+        item: T;
+        newIndex: number;
+    }) => Promise<boolean> | boolean;
+    performItemRemove?: (argument: {
+        item: T;
+    }) => Promise<boolean> | boolean;
+};
+type UmbSorterConfig<T> = Omit<INTERNAL_UmbSorterConfig<T>, 'placeholderClass' | 'ignorerSelector' | 'containerSelector'> & Partial<Pick<INTERNAL_UmbSorterConfig<T>, 'placeholderClass' | 'ignorerSelector' | 'containerSelector'>>;
+/**
+ * @export
+ * @class UmbSorterController
+ * @implements {UmbControllerInterface}
+ * @description This controller can make user able to sort items.
+ */
+declare class UmbSorterController<T> implements UmbControllerInterface {
+    #private;
+    private _lastIndicationContainerVM;
+    get unique(): string;
+    constructor(host: UmbControllerHostElement, config: UmbSorterConfig<T>);
+    setModel(model: Array<T>): void;
+    hostConnected(): void;
+    private _onFirstRender;
+    hostDisconnected(): void;
+    setupItem(element: HTMLElement): void;
+    destroyItem(element: HTMLElement): void;
+    handleDragStart: (event: DragEvent) => void;
+    handleDragEnd: () => Promise<void>;
+    handleDragMove: (event: DragEvent) => void;
+    moveCurrentElement: () => void;
+    move(orderedContainerElements: Array<Element>, newElIndex: number): void;
+    /** Management methods: */
+    getItemOfElement(element: HTMLElement): T | null | undefined;
+    removeItem(item: T): Promise<boolean | T | null>;
+    hasOtherItemsThan(item: T): boolean;
+    sync(element: HTMLElement, fromVm: UmbSorterController<T>): Promise<boolean>;
+    updateAllowIndication(contextVM: UmbSorterController<T>, item: T): boolean;
+    removeAllowIndication(): void;
+    private autoScrollX;
+    private autoScrollY;
+    private handleAutoScroll;
+    private _performAutoScroll;
+    private stopAutoScroll;
+    notifySync(data: any): void;
+    notifyDisallowed(): void;
+    notifyAllowed(): void;
+    notifyRequestDrop(data: any): boolean;
+    destroy(): void;
+}
+
+export { UmbSorterConfig, UmbSorterController };

package/store.d.ts

@@ -1,8 +1,9 @@
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
-import { UmbControllerHostElement } from './controller';
-import { EntityTreeItemResponseModel, FileSystemTreeItemPresentationModel } from './backend-api';
-import { UmbStoreBase as UmbStoreBase$1, UmbTreeStore as UmbTreeStore$1 } from './store';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { UmbArrayState } from '@umbraco-cms/backoffice/observable-api';
+import { EntityTreeItemResponseModel, FileSystemTreeItemPresentationModel } from '@umbraco-cms/backoffice/backend-api';
+import { UmbStoreBase as UmbStoreBase$1, UmbTreeStore as UmbTreeStore$1 } from '@umbraco-cms/backoffice/store';
 
 interface UmbDataStoreIdentifiers {
     key?: string;
@@ -38,39 +39,46 @@ interface UmbContentStore<T> extends UmbEntityDetailStore<T> {
     save(data: T[]): Promise<void>;
 }
 
-declare class UmbStoreBase {
-    protected _host: UmbControllerHostElement;
-    readonly storeAlias: string;
-    constructor(_host: UmbControllerHostElement, storeAlias: string);
+interface UmbStore<T> {
+    appendItems: (items: Array<T>) => void;
+    updateItem: (unique: string, item: Partial<T>) => void;
+    removeItem: (unique: string) => void;
 }
 
-/**
- * @export
- * @class UmbEntityTreeStore
- * @extends {UmbStoreBase}
- * @description - General Tree Data Store
- */
-declare class UmbEntityTreeStore extends UmbStoreBase$1 implements UmbTreeStore$1<EntityTreeItemResponseModel> {
-    #private;
+declare class UmbStoreBase<StoreItemType = any> implements UmbStore<StoreItemType> {
+    protected _host: UmbControllerHostElement;
+    protected _data: UmbArrayState<StoreItemType>;
+    readonly storeAlias: string;
+    constructor(_host: UmbControllerHostElement, storeAlias: string, data: UmbArrayState<StoreItemType>);
     /**
      * Appends items to the store
-     * @param {Array<EntityTreeItemResponseModel>} items
+     * @param {Array<StoreItemType>} items
      * @memberof UmbEntityTreeStore
      */
-    appendItems(items: Array<EntityTreeItemResponseModel>): void;
+    appendItems(items: Array<StoreItemType>): void;
     /**
      * Updates an item in the store
      * @param {string} id
-     * @param {Partial<EntityTreeItemResponseModel>} data
+     * @param {Partial<StoreItemType>} data
      * @memberof UmbEntityTreeStore
      */
-    updateItem(id: string, data: Partial<EntityTreeItemResponseModel>): void;
+    updateItem(unique: string, data: Partial<StoreItemType>): void;
     /**
      * Removes an item from the store
      * @param {string} id
      * @memberof UmbEntityTreeStore
      */
-    removeItem(id: string): void;
+    removeItem(unique: string): void;
+}
+
+/**
+ * @export
+ * @class UmbEntityTreeStore
+ * @extends {UmbStoreBase}
+ * @description - Entity Tree Store
+ */
+declare class UmbEntityTreeStore extends UmbStoreBase$1<EntityTreeItemResponseModel> implements UmbTreeStore$1<EntityTreeItemResponseModel> {
+    constructor(host: UmbControllerHostElement, storeAlias: string);
     /**
      * An observable to observe the root items
      * @memberof UmbEntityTreeStore
@@ -89,36 +97,17 @@ declare class UmbEntityTreeStore extends UmbStoreBase$1 implements UmbTreeStore$
      * @return {*}
      * @memberof UmbEntityTreeStore
      */
-    items(ids: Array<string>): rxjs.Observable<EntityTreeItemResponseModel[]>;
+    items(ids: Array<string | null>): rxjs.Observable<EntityTreeItemResponseModel[]>;
 }
 
 /**
  * @export
  * @class UmbFileSystemTreeStore
  * @extends {UmbStoreBase}
- * @description - General Tree Data Store
+ * @description - File System Tree Store
  */
-declare class UmbFileSystemTreeStore extends UmbStoreBase$1 implements UmbTreeStore$1<FileSystemTreeItemPresentationModel> {
-    #private;
-    /**
-     * Appends items to the store
-     * @param {Array<FileSystemTreeItemPresentationModel>} items
-     * @memberof UmbFileSystemTreeStore
-     */
-    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;
+declare class UmbFileSystemTreeStore extends UmbStoreBase$1<FileSystemTreeItemPresentationModel> implements UmbTreeStore$1<FileSystemTreeItemPresentationModel> {
+    constructor(host: UmbControllerHostElement, storeAlias: string);
     /**
      * An observable to observe the root items
      * @memberof UmbFileSystemTreeStore
@@ -147,13 +136,19 @@ type TreeItemPresentationModel = {
     hasChildren?: boolean;
 };
 
-interface UmbTreeStore<T extends TreeItemPresentationModel = any> {
-    appendItems: (items: Array<T>) => void;
-    updateItem: (unique: string, item: Partial<T>) => void;
-    removeItem: (unique: string) => void;
+type ItemResponseModelBaseModel = {
+    name?: string;
+    id?: string;
+};
+
+interface UmbTreeStore<T extends TreeItemPresentationModel = any> extends UmbStore<T> {
     rootItems: Observable<Array<T>>;
     childrenOf: (parentUnique: string | null) => Observable<Array<T>>;
     items: (uniques: Array<string>) => Observable<Array<T>>;
 }
 
-export { UmbContentStore, UmbDataStore, UmbDataStoreIdentifiers, UmbEntityDetailStore, UmbEntityTreeStore, UmbFileSystemTreeStore, UmbStoreBase, UmbTreeStore };
+interface UmbItemStore<T extends ItemResponseModelBaseModel = any> extends UmbStore<T> {
+    items: (uniques: Array<string>) => Observable<Array<T>>;
+}
+
+export { UmbContentStore, UmbDataStore, UmbDataStoreIdentifiers, UmbEntityDetailStore, UmbEntityTreeStore, UmbFileSystemTreeStore, UmbItemStore, UmbStoreBase, UmbTreeStore };

package/tree.d.ts

@@ -0,0 +1,14 @@
+interface UmbTreeRootModel {
+    type: string;
+    name: string;
+    hasChildren: boolean;
+    icon?: string;
+}
+interface UmbTreeRootEntityModel extends UmbTreeRootModel {
+    id: string | null;
+}
+interface UmbTreeRootFileSystemModel extends UmbTreeRootModel {
+    path: string | null;
+}
+
+export { UmbTreeRootEntityModel, UmbTreeRootFileSystemModel, UmbTreeRootModel };