@umbraco-cms/backoffice 1.0.0-next.48e903f7 → 1.0.0-next.54c4e01c

package/element.d.ts

@@ -1,18 +1,18 @@
 import { Observable } from 'rxjs';
-import { HTMLElementConstructor } from './models';
-import { UmbControllerHostInterface } from './controller';
-import { UmbContextToken, UmbContextProviderController, UmbContextCallback, UmbContextConsumerController } from './context-api';
-import { UmbObserverController } from './observable-api';
+import { HTMLElementConstructor } from '@umbraco-cms/backoffice/models';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { UmbContextToken, UmbContextProviderController, UmbContextCallback, UmbContextConsumerController } from '@umbraco-cms/backoffice/context-api';
+import { UmbObserverController } from '@umbraco-cms/backoffice/observable-api';
 
 interface ResolvedContexts {
     [key: string]: any;
 }
-declare class UmbElementMixinInterface extends UmbControllerHostInterface {
+declare class UmbElementMixinInterface extends UmbControllerHostElement {
     observe<T>(source: Observable<T>, callback: (_value: T) => void, unique?: string): UmbObserverController<T>;
     provideContext<R = unknown>(alias: string | UmbContextToken<R>, instance: R): UmbContextProviderController<R>;
     consumeContext<R = unknown>(alias: string | UmbContextToken<R>, callback: UmbContextCallback<R>): UmbContextConsumerController<R>;
     consumeAllContexts(contextAliases: string[], callback: (_instances: ResolvedContexts) => void): void;
 }
-declare const UmbElementMixin: <T extends HTMLElementConstructor<HTMLElement>>(superClass: T) => HTMLElementConstructor<UmbElementMixinInterface> & T;
+declare const UmbElementMixin: <T extends HTMLElementConstructor>(superClass: T) => HTMLElementConstructor<UmbElementMixinInterface> & T;
 
 export { UmbElementMixin, UmbElementMixinInterface };

package/entity-action.d.ts

@@ -1,15 +1,16 @@
-import { UmbControllerHostInterface } from './controller';
-import { UmbEntityActionBase as UmbEntityActionBase$1 } from './entity-action';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { UmbEntityActionBase as UmbEntityActionBase$1 } from '@umbraco-cms/backoffice/entity-action';
+import { UmbDetailRepository, UmbItemRepository, UmbFolderRepository } from '@umbraco-cms/backoffice/repository';
 
 interface UmbAction<RepositoryType = unknown> {
-    host: UmbControllerHostInterface;
+    host: UmbControllerHostElement;
     repository: RepositoryType;
     execute(): Promise<void>;
 }
 declare class UmbActionBase<RepositoryType> {
-    host: UmbControllerHostInterface;
+    host: UmbControllerHostElement;
     repository?: RepositoryType;
-    constructor(host: UmbControllerHostInterface, repositoryAlias: string);
+    constructor(host: UmbControllerHostElement, repositoryAlias: string);
 }
 
 interface UmbEntityAction<RepositoryType> extends UmbAction<RepositoryType> {
@@ -17,7 +18,8 @@ interface UmbEntityAction<RepositoryType> extends UmbAction<RepositoryType> {
 }
 declare class UmbEntityActionBase<RepositoryType> extends UmbActionBase<RepositoryType> {
     unique: string;
-    constructor(host: UmbControllerHostInterface, repositoryAlias: string, unique: string);
+    repositoryAlias: string;
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
 }
 
 interface UmbEntityBulkAction<RepositoryType = unknown> extends UmbAction<RepositoryType> {
@@ -26,47 +28,55 @@ interface UmbEntityBulkAction<RepositoryType = unknown> extends UmbAction<Reposi
 }
 declare class UmbEntityBulkActionBase<RepositoryType = unknown> extends UmbActionBase<RepositoryType> {
     selection: Array<string>;
-    constructor(host: UmbControllerHostInterface, repositoryAlias: string, selection: Array<string>);
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, selection: Array<string>);
     setSelection(selection: Array<string>): void;
 }
 
 declare class UmbCopyEntityAction<T extends {
     copy(): Promise<void>;
 }> extends UmbEntityActionBase$1<T> {
-    constructor(host: UmbControllerHostInterface, repositoryAlias: string, unique: string);
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
     execute(): Promise<void>;
 }
 
-declare class UmbDeleteEntityAction<T extends {
-    delete(unique: string): Promise<void>;
-    requestItems(uniques: Array<string>): any;
-}> extends UmbEntityActionBase$1<T> {
+declare class UmbDeleteEntityAction<T extends UmbDetailRepository & UmbItemRepository<any>> extends UmbEntityActionBase$1<T> {
+    #private;
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
+    execute(): Promise<void>;
+}
+
+declare class UmbDeleteFolderEntityAction<T extends UmbFolderRepository> extends UmbEntityActionBase$1<T> {
+    #private;
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
+    execute(): Promise<void>;
+}
+
+declare class UmbFolderUpdateEntityAction<T extends UmbFolderRepository = UmbFolderRepository> extends UmbEntityActionBase$1<T> {
     #private;
-    constructor(host: UmbControllerHostInterface, repositoryAlias: string, unique: string);
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
     execute(): Promise<void>;
 }
 
 declare class UmbMoveEntityAction<T extends {
     move(): Promise<void>;
 }> extends UmbEntityActionBase$1<T> {
-    constructor(host: UmbControllerHostInterface, repositoryAlias: string, unique: string);
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
     execute(): Promise<void>;
 }
 
 declare class UmbSortChildrenOfEntityAction<T extends {
     sortChildrenOf(): Promise<void>;
 }> extends UmbEntityActionBase$1<T> {
-    constructor(host: UmbControllerHostInterface, repositoryAlias: string, unique: string);
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
     execute(): Promise<void>;
 }
 
-declare class UmbTrashEntityAction<T extends {
+declare class UmbTrashEntityAction<T extends UmbItemRepository<any> & {
     trash(unique: Array<string>): Promise<void>;
-    requestTreeItems(uniques: Array<string>): any;
 }> extends UmbEntityActionBase$1<T> {
     #private;
-    constructor(host: UmbControllerHostInterface, repositoryAlias: string, unique: string);
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
     execute(): Promise<void>;
 }
 
-export { UmbAction, UmbActionBase, UmbCopyEntityAction, UmbDeleteEntityAction, UmbEntityAction, UmbEntityActionBase, UmbEntityBulkAction, UmbEntityBulkActionBase, UmbMoveEntityAction, UmbSortChildrenOfEntityAction, UmbTrashEntityAction };
+export { UmbAction, UmbActionBase, UmbCopyEntityAction, UmbDeleteEntityAction, UmbDeleteFolderEntityAction, UmbEntityAction, UmbEntityActionBase, UmbEntityBulkAction, UmbEntityBulkActionBase, UmbFolderUpdateEntityAction, UmbMoveEntityAction, UmbSortChildrenOfEntityAction, UmbTrashEntityAction };

package/extensions-api.d.ts

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
-import { ManifestTypes, ManifestKind, ManifestTypeMap, ManifestBase, SpecificManifestTypeOrManifestBase, ManifestElement, ManifestElementWithElementName, ManifestClass } from './extensions-registry';
-import { UmbContextToken } from './context-api';
-import { UmbControllerHostInterface } from './controller';
+import { ManifestTypes, ManifestKind, ManifestTypeMap, ManifestBase, SpecificManifestTypeOrManifestBase, ManifestElement, ManifestElementWithElementName, ManifestWithLoader, ManifestClass } from '@umbraco-cms/backoffice/extensions-registry';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
 
 declare class UmbExtensionRegistry {
     private _extensions;
@@ -10,6 +10,7 @@ declare class UmbExtensionRegistry {
     readonly kinds: Observable<ManifestKind[]>;
     defineKind(kind: ManifestKind): void;
     register(manifest: ManifestTypes | ManifestKind): void;
+    registerMany(manifests: Array<ManifestTypes>): void;
     unregister(alias: string): void;
     isRegistered(alias: string): boolean;
     private _kindsOfType;
@@ -22,13 +23,13 @@ declare class UmbExtensionRegistry {
 }
 declare const UMB_EXTENSION_REGISTRY_TOKEN: UmbContextToken<UmbExtensionRegistry>;
 
-declare function createExtensionElement(manifest: ManifestElement): Promise<HTMLElement | undefined>;
+declare function createExtensionElement<ElementType extends HTMLElement>(manifest: ManifestElement<ElementType>): Promise<ElementType | undefined>;
 
 declare function hasDefaultExport<ConstructorType>(object: unknown): object is {
     default: ConstructorType;
 };
 
-type UmbEntrypointOnInit = (host: UmbControllerHostInterface, extensionRegistry: UmbExtensionRegistry) => void;
+type UmbEntrypointOnInit = (host: UmbControllerHostElement, extensionRegistry: UmbExtensionRegistry) => void;
 /**
  * Interface containing supported life-cycle functions for ESModule entrypoints
  */
@@ -43,19 +44,19 @@ declare function hasInitExport(obj: unknown): obj is Pick<UmbEntrypointModule, '
 
 declare function isManifestElementNameType(manifest: unknown): manifest is ManifestElementWithElementName;
 
-declare function isManifestElementableType(manifest: ManifestBase): manifest is ManifestElement;
+declare function isManifestElementableType<ElementType extends HTMLElement = HTMLElement>(manifest: ManifestBase): manifest is ManifestElement;
 
-type ManifestLoaderType = ManifestElement & {
-    loader: () => Promise<object | HTMLElement>;
-};
-type ManifestJSType = ManifestElement & {
+type ManifestJSType<T> = ManifestWithLoader<T> & {
     js: string;
 };
-declare function loadExtension(manifest: ManifestElement): Promise<object | HTMLElement | null>;
+declare function isManifestJSType<T>(manifest: ManifestBase | unknown): manifest is ManifestJSType<T>;
 
-declare function isManifestJSType(manifest: ManifestBase | unknown): manifest is ManifestJSType;
+type ManifestLoaderType<T> = ManifestWithLoader<T> & {
+    loader: () => Promise<T>;
+};
+declare function isManifestLoaderType<T>(manifest: ManifestBase): manifest is ManifestLoaderType<T>;
 
-declare function isManifestLoaderType(manifest: ManifestBase): manifest is ManifestLoaderType;
+declare function loadExtension<T = unknown>(manifest: ManifestWithLoader<T>): Promise<T | null>;
 
 declare function createExtensionElementOrFallback(manifest: any, fallbackElementName: string): Promise<HTMLElement | undefined>;