@umbraco-cms/backoffice 1.0.0-next.de0ffca0 → 1.0.0-next.e3cf00d3

package/observable-api.d.ts

@@ -1,6 +1,6 @@
 import * as rxjs from 'rxjs';
 import { Observable, BehaviorSubject } from 'rxjs';
-import { UmbControllerInterface, UmbControllerHostElement } from './controller';
+import { UmbControllerInterface, UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
 
 declare class UmbObserver<T> {
     #private;
@@ -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,48 +90,62 @@ 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[]> {
-    private _getUnique?;
+declare class UmbArrayState<T> extends UmbDeepState<T[]> {
+    #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 UmbArrayState(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.
+     * @return {UmbArrayState<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 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 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 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 = [
@@ -139,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:
@@ -153,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'}
@@ -185,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;
@@ -200,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;
@@ -240,13 +254,25 @@ 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>
- * const entry = {key: 'myKey', value: 'myValue'};
- * const newDataSet = appendToFrozenArray(mySubject.getValue(), entry, x => x.key === key);
+ * @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);
  */
 declare function appendToFrozenArray<T>(data: T[], entry: T, getUniqueMethod?: (entry: T) => unknown): T[];
 
+/**
+ * @export
+ * @method filterFrozenArray
+ * @param {Array<T>} data - RxJS Subject to use for this Observable.
+ * @param {(entry: T) => boolean} filterMethod - Method to filter the array.
+ * @description - Creates a RxJS Observable from RxJS Subject.
+ * @example <caption>Example remove an entry of 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 newDataSet = filterFrozenArray(mySubject.getValue(), x => x.id !== "myKey");
+ * mySubject.next(newDataSet);
+ */
+declare function filterFrozenArray<T>(data: T[], filterMethod: (entry: T) => boolean): T[];
+
 /**
  * @export
  * @method partialUpdateFrozenArray
@@ -254,11 +280,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, filterFrozenArray, partialUpdateFrozenArray };

package/package.json

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

package/picker-input.d.ts

@@ -0,0 +1,24 @@
+import * as rxjs from 'rxjs';
+import { UmbItemRepository } from '@umbraco-cms/backoffice/repository';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { UmbModalToken, UmbModalContext } from '@umbraco-cms/backoffice/modal';
+import { ItemResponseModelBaseModel } from '@umbraco-cms/backoffice/backend-api';
+
+declare class UmbPickerInputContext<ItemType extends ItemResponseModelBaseModel> {
+    #private;
+    host: UmbControllerHostElement;
+    modalAlias: string | UmbModalToken;
+    repository?: UmbItemRepository<ItemType>;
+    modalContext?: UmbModalContext;
+    selection: rxjs.Observable<string[]>;
+    selectedItems: rxjs.Observable<ItemType[]>;
+    max: number;
+    min: number;
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, modalAlias: string | UmbModalToken, getUniqueMethod?: (entry: ItemType) => string | undefined);
+    getSelection(): string[];
+    setSelection(selection: string[]): void;
+    openPicker(pickerData?: any): void;
+    requestRemoveItem(unique: string): Promise<void>;
+}
+
+export { UmbPickerInputContext };

package/repository.d.ts

@@ -1,69 +1,139 @@
-import { ProblemDetailsModel } 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/models';
 
-interface DataSourceResponse<T = undefined> {
+interface DataSourceResponse<T = undefined> extends UmbDataSourceErrorResponse {
     data?: T;
-    error?: ProblemDetailsModel;
+}
+interface UmbDataSourceErrorResponse {
+    error?: ApiError | CancelError;
 }
 
-interface UmbDataSource<T> {
-    createScaffold(parentKey: string | null): Promise<DataSourceResponse$1<T>>;
-    get(key: string): Promise<DataSourceResponse$1<T>>;
-    insert(data: T): Promise<DataSourceResponse$1<T>>;
-    update(data: T): Promise<DataSourceResponse$1<T>>;
-    delete(key: string): Promise<DataSourceResponse$1<T>>;
+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<DataSourceResponse$1<CreateResponseType>>;
+    update(unique: string, data: UpdateRequestType): Promise<DataSourceResponse$1<ResponseType>>;
+    delete(unique: string): Promise<DataSourceResponse$1>;
 }
 
-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 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 UmbDetailRepository<DetailType> {
-    createScaffold(parentKey: string | null): Promise<{
-        data?: DetailType;
-        error?: ProblemDetailsModel;
-    }>;
-    requestByKey(key: string): Promise<{
-        data?: DetailType;
+interface UmbPagedData<T> {
+    total: number;
+    items: Array<T>;
+}
+interface UmbTreeRepository<TreeItemType extends TreeItemPresentationModel, TreeRootType extends UmbTreeRootModel = UmbTreeRootEntityModel> {
+    requestTreeRoot: () => Promise<{
+        data?: TreeRootType;
         error?: ProblemDetailsModel;
     }>;
-    create(data: DetailType): Promise<{
+    requestRootTreeItems: () => Promise<{
+        data?: UmbPagedData<TreeItemType>;
         error?: ProblemDetailsModel;
+        asObservable?: () => Observable<TreeItemType[]>;
     }>;
-    save(data: DetailType): Promise<{
+    requestTreeItemsOf: (parentUnique: string | null) => Promise<{
+        data?: UmbPagedData<TreeItemType>;
         error?: ProblemDetailsModel;
+        asObservable?: () => Observable<TreeItemType[]>;
     }>;
-    delete(key: string): Promise<{
+    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 UmbPagedData<T> {
-    total: number;
-    items: Array<T>;
+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 UmbTreeRepository<ItemType = any, PagedItemType = UmbPagedData<ItemType>> {
-    requestRootTreeItems: () => Promise<{
-        data: PagedItemType | undefined;
-        error: ProblemDetailsModel | undefined;
-        asObservable?: () => Observable<ItemType[]>;
+
+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 {
+    error?: ProblemDetailsModel;
+}
+interface UmbRepositoryResponse<T> extends UmbRepositoryErrorResponse {
+    data?: T;
+}
+interface UmbDetailRepository<CreateRequestType = any, CreateResponseType = any, UpdateRequestType = any, ResponseType = any> {
+    createScaffold(parentId: string | null): Promise<UmbRepositoryResponse<CreateRequestType>>;
+    requestById(id: string): Promise<UmbRepositoryResponse<ResponseType>>;
+    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 UmbFolderRepository {
+    createFolderScaffold(parentId: string | null): Promise<{
+        data?: FolderReponseModel;
+        error?: ProblemDetailsModel;
     }>;
-    requestTreeItemsOf: (parentUnique: string | null) => Promise<{
-        data: PagedItemType | undefined;
-        error: ProblemDetailsModel | undefined;
-        asObservable?: () => Observable<ItemType[]>;
+    createFolder(folderRequest: CreateFolderRequestModel): Promise<{
+        data?: string;
+        error?: ProblemDetailsModel;
     }>;
-    requestTreeItems: (uniques: string[]) => Promise<{
-        data: Array<ItemType> | undefined;
-        error: ProblemDetailsModel | undefined;
-        asObservable?: () => Observable<ItemType[]>;
+    requestFolder(unique: string): Promise<{
+        data?: FolderReponseModel;
+        error?: ProblemDetailsModel;
+    }>;
+    updateFolder(unique: string, folder: FolderModelBaseModel): Promise<{
+        data?: UpdateFolderReponseModel;
+        error?: ProblemDetailsModel;
     }>;
-    rootTreeItems: () => Promise<Observable<ItemType[]>>;
-    treeItemsOf: (parentUnique: string | null) => Promise<Observable<ItemType[]>>;
-    treeItems: (uniques: string[]) => Promise<Observable<ItemType[]>>;
+    deleteFolder(id: string): Promise<{
+        error?: ProblemDetailsModel;
+    }>;
+}
+
+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, UmbDataSource, UmbDetailRepository, UmbPagedData, UmbTreeDataSource, UmbTreeRepository };
+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 };