@umbraco-cms/backoffice 1.0.0-next.37dcc47c → 1.0.0-next.426eb58e

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,8 @@
 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, ManifestClass } from '@umbraco-cms/backoffice/extensions-registry';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { PageComponent } from '@umbraco-cms/backoffice/router';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
 
 declare class UmbExtensionRegistry {
     private _extensions;
@@ -10,6 +11,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 +24,13 @@ declare class UmbExtensionRegistry {
 }
 declare const UMB_EXTENSION_REGISTRY_TOKEN: UmbContextToken<UmbExtensionRegistry>;
 
-declare function createExtensionElement(manifest: ManifestElement): Promise<HTMLElement | undefined>;
+declare function createExtensionElement(manifest: ManifestElement): Promise<PageComponent>;
 
 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
  */

package/extensions-registry.d.ts

@@ -1,17 +1,30 @@
-import { ClassConstructor } from './models';
 import { InterfaceLook, InterfaceColor } from '@umbraco-ui/uui-base/lib/types/index';
-import { UmbWorkspaceAction } from './workspace';
-import { UmbStoreBase, UmbTreeStoreBase } from './store';
-import { UmbExtensionRegistry } from './extensions-api';
-import { UmbControllerHostInterface } from './controller';
+import { ClassConstructor } from '@umbraco-cms/backoffice/models';
+import { UmbStoreBase, UmbTreeStore, UmbItemStore } from '@umbraco-cms/backoffice/store';
+import { UmbExtensionRegistry } from '@umbraco-cms/backoffice/extensions-api';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
 
 interface ManifestCollectionView extends ManifestElement, ManifestWithConditions<ConditionsCollectionView> {
     type: 'collectionView';
     meta: MetaCollectionView;
 }
 interface MetaCollectionView {
+    /**
+     * The friendly name of the collection view
+     */
     label: string;
+    /**
+     * An icon to represent the collection view
+     *
+     * @examples [
+     *   "umb:box",
+     *   "umb:grid"
+     * ]
+     */
     icon: string;
+    /**
+     * The URL pathname for this collection view that can be deep linked to by sharing the url
+     */
     pathName: string;
 }
 interface ConditionsCollectionView {
@@ -23,10 +36,33 @@ interface ManifestDashboard extends ManifestElement, ManifestWithConditions<Cond
     meta: MetaDashboard;
 }
 interface MetaDashboard {
+    /**
+     * This is the URL path for the dashboard which is used for navigating or deep linking directly to the dashboard
+     * https://yoursite.com/section/settings/dashboard/my-dashboard-path
+     *
+     * @example my-dashboard-path
+     * @examples [
+     *  "my-dashboard-path"
+     * ]
+     */
     pathname: string;
+    /**
+     * The displayed name (label) for the tab of the dashboard
+     */
     label?: string;
 }
 interface ConditionsDashboard {
+    /**
+     * An array of section aliases that the dashboard should be available in
+     *
+     * @uniqueItems true
+     * @minItems 1
+     * @items.examples [
+     *   "Umb.Section.Content",
+     *   "Umb.Section.Settings"
+     * ]
+     *
+     */
     sections: string[];
 }
 
@@ -45,28 +81,76 @@ interface ConditionsDashboardCollection {
     entityType: string;
 }
 
+/**
+ * An action to perform on an entity
+ * For example for content you may wish to create a new document etc
+ */
 interface ManifestEntityAction extends ManifestElement {
     type: 'entityAction';
     meta: MetaEntityAction;
     conditions: ConditionsEntityAction;
 }
 interface MetaEntityAction {
+    /**
+     * An icon to represent the action to be performed
+     *
+     * @examples [
+     *   "umb:box",
+     *   "umb:grid"
+     * ]
+     */
     icon?: string;
+    /**
+     * The friendly name of the action to perform
+     *
+     * @examples [
+     *   "Create",
+     *   "Create Content Template"
+     * ]
+     */
     label: string;
+    /**
+     * @TJS-ignore
+     */
     api: any;
+    /**
+     * The alias for the repsoitory of the entity type this action is for
+     * such as 'Umb.Repository.Documents'
+     * @examples [
+     *   "Umb.Repository.Documents"
+     * ]
+     */
     repositoryAlias: string;
 }
 interface ConditionsEntityAction {
     entityType: string;
 }
 
+/**
+ * An action to perform on multiple entities
+ * For example for content you may wish to move one or more documents in bulk
+ */
 interface ManifestEntityBulkAction extends ManifestElement, ManifestWithConditions<ConditionsEntityBulkAction> {
     type: 'entityBulkAction';
     meta: MetaEntityBulkAction;
 }
 interface MetaEntityBulkAction {
+    /**
+     * A friendly label for the action
+     */
     label: string;
+    /**
+     * @TJS-ignore
+     */
     api: any;
+    /**
+     * The alias for the repsoitory of the entity type this action is for
+     * such as 'Umb.Repository.Documents'
+     *
+     * @examples [
+     *   "Umb.Repository.Documents"
+     * ]
+     */
     repositoryAlias: string;
 }
 interface ConditionsEntityBulkAction {
@@ -82,6 +166,10 @@ interface MetaExternalLoginProvider {
     pathname: string;
 }
 
+/**
+ * Header apps are displayed in the top right corner of the backoffice
+ * The two provided header apps are the search and the user menu
+ */
 interface ManifestHeaderApp extends ManifestElement {
     type: 'headerApp';
 }
@@ -232,8 +320,16 @@ interface MetaMenuItemTreeKind {
     entityType?: string;
 }
 
+/**
+ * Theme manifest for styling the backoffice of Umbraco such as dark, high contrast etc
+ */
 interface ManifestTheme extends ManifestWithLoader<string> {
     type: 'theme';
+    /**
+     * File location of the CSS file of the theme
+     *
+     * @examples ["themes/dark.theme.css"]
+     */
     css?: string;
 }
 
@@ -242,15 +338,22 @@ interface ManifestTree extends ManifestBase {
     meta: MetaTree;
 }
 interface MetaTree {
-    storeAlias?: string;
-    repository?: ClassConstructor<unknown>;
+    repositoryAlias: string;
 }
 
-interface ManifestUserDashboard extends ManifestElement {
-    type: 'userDashboard';
-    meta: MetaUserDashboard;
+interface ManifestTreeItem extends ManifestElement {
+    type: 'treeItem';
+    conditions: ConditionsTreeItem;
+}
+interface ConditionsTreeItem {
+    entityType: string;
 }
-interface MetaUserDashboard {
+
+interface ManifestUserProfileApp extends ManifestElement {
+    type: 'userProfileApp';
+    meta: MetaUserProfileApp;
+}
+interface MetaUserProfileApp {
     label: string;
     pathname: string;
 }
@@ -272,7 +375,7 @@ interface MetaWorkspaceAction {
     label?: string;
     look?: InterfaceLook;
     color?: InterfaceColor;
-    api: ClassConstructor<UmbWorkspaceAction>;
+    api: ClassConstructor<any>;
 }
 interface ConditionsWorkspaceAction {
     workspaces: Array<string>;
@@ -319,21 +422,41 @@ interface ManifestModal extends ManifestElement {
 interface ManifestStore extends ManifestClass<UmbStoreBase> {
     type: 'store';
 }
-interface ManifestTreeStore extends ManifestClass<UmbTreeStoreBase> {
+interface ManifestTreeStore extends ManifestClass<UmbTreeStore> {
     type: 'treeStore';
 }
+interface ManifestItemStore extends ManifestClass<UmbItemStore> {
+    type: 'itemStore';
+}
 
-type ManifestTypes = ManifestCollectionView | ManifestDashboard | ManifestDashboardCollection | ManifestEntityAction | ManifestEntityBulkAction | ManifestEntrypoint | ManifestExternalLoginProvider | ManifestHeaderApp | ManifestHeaderAppButtonKind | ManifestHealthCheck | ManifestPackageView | ManifestPropertyAction | ManifestPropertyEditorModel | ManifestPropertyEditorUI | ManifestRepository | ManifestSection | ManifestSectionSidebarApp | ManifestSectionSidebarAppMenuKind | ManifestSectionView | ManifestMenu | ManifestMenuItem | ManifestMenuItemTreeKind | ManifestTheme | ManifestTree | ManifestUserDashboard | ManifestWorkspace | ManifestWorkspaceAction | ManifestWorkspaceView | ManifestWorkspaceViewCollection | ManifestModal | ManifestStore | ManifestTreeStore | ManifestBase;
+type ManifestTypes = ManifestCollectionView | ManifestDashboard | ManifestDashboardCollection | ManifestEntityAction | ManifestEntityBulkAction | ManifestEntrypoint | ManifestExternalLoginProvider | ManifestHeaderApp | ManifestHeaderAppButtonKind | ManifestHealthCheck | ManifestPackageView | ManifestPropertyAction | ManifestPropertyEditorModel | ManifestPropertyEditorUI | ManifestRepository | ManifestSection | ManifestSectionSidebarApp | ManifestSectionSidebarAppMenuKind | ManifestSectionView | ManifestMenu | ManifestMenuItem | ManifestMenuItemTreeKind | ManifestTheme | ManifestTree | ManifestTreeItem | ManifestUserProfileApp | ManifestWorkspace | ManifestWorkspaceAction | ManifestWorkspaceView | ManifestWorkspaceViewCollection | ManifestModal | ManifestStore | ManifestTreeStore | ManifestItemStore | ManifestBase;
 type ManifestStandardTypes = ManifestTypes['type'];
 type ManifestTypeMap = {
     [Manifest in ManifestTypes as Manifest['type']]: Manifest;
 };
 type SpecificManifestTypeOrManifestBase<T extends keyof ManifestTypeMap | string> = T extends keyof ManifestTypeMap ? ManifestTypeMap[T] : ManifestBase;
 interface ManifestBase {
+    /**
+     * The type of extension such as dashboard etc...
+     */
     type: string;
+    /**
+     * The alias of the extension, ensure it is unique
+     */
     alias: string;
-    kind?: any;
+    /**
+     * The kind of the extension, used to group extensions together
+     *
+     * @examples ["button"]
+     */
+    kind?: unknown;
+    /**
+     * The friendly name of the extension
+     */
     name: string;
+    /**
+     * Extensions such as dashboards are ordered by weight with lower numbers being first in the list
+     */
     weight?: number;
 }
 interface ManifestKind {
@@ -344,23 +467,54 @@ interface ManifestKind {
     manifest: Partial<ManifestTypes>;
 }
 interface ManifestWithConditions<ConditionsType> {
+    /**
+     * Set the conditions for when the extension should be loaded
+     */
     conditions: ConditionsType;
 }
 interface ManifestWithLoader<LoaderReturnType> extends ManifestBase {
+    /**
+     * @TJS-ignore
+     */
     loader?: () => Promise<LoaderReturnType>;
 }
+/**
+ * The type of extension such as dashboard etc...
+ */
 interface ManifestClass<T = unknown> extends ManifestWithLoader<object> {
+    /**
+     * The file location of the javascript file to load
+     * @TJS-required
+     */
     js?: string;
+    /**
+     * @TJS-ignore
+     */
     className?: string;
+    /**
+     * @TJS-ignore
+     */
     class?: ClassConstructor<T>;
 }
 interface ManifestClassWithClassConstructor extends ManifestClass {
     class: ClassConstructor<unknown>;
 }
 interface ManifestElement extends ManifestWithLoader<object | HTMLElement> {
+    /**
+     * The file location of the javascript file to load
+     *
+     * @TJS-require
+     */
     js?: string;
+    /**
+     * The HTML web component name to use such as 'my-dashboard'
+     * Note it is NOT <my-dashboard></my-dashboard> but just the name
+     */
     elementName?: string;
-    meta?: any;
+    /**
+     * This contains properties specific to the type of extension
+     */
+    meta?: unknown;
 }
 interface ManifestWithView extends ManifestElement {
     meta: MetaManifestWithView;
@@ -371,20 +525,34 @@ interface MetaManifestWithView {
     icon: string;
 }
 interface ManifestElementWithElementName extends ManifestElement {
+    /**
+     * The HTML web component name to use such as 'my-dashboard'
+     * Note it is NOT <my-dashboard></my-dashboard> but just the name
+     */
     elementName: string;
 }
 interface ManifestWithMeta extends ManifestBase {
+    /**
+     * This contains properties specific to the type of extension
+     */
     meta: unknown;
 }
+/**
+ * This type of extension gives full control and will simply load the specified JS file
+ * You could have custom logic to decide which extensions to load/register by using extensionRegistry
+ */
 interface ManifestEntrypoint extends ManifestBase {
-    type: 'entrypoint';
+    type: 'entryPoint';
+    /**
+     * The file location of the javascript file to load in the backoffice
+     */
     js: string;
 }
 
 declare class UmbEntryPointExtensionInitializer {
     #private;
-    constructor(rootHost: UmbControllerHostInterface, extensionRegistry: UmbExtensionRegistry);
-    instantiateEntryPoint(manifest: ManifestEntrypoint): void;
+    constructor(host: UmbControllerHostElement, extensionRegistry: UmbExtensionRegistry);
+    instantiateEntryPoint(manifest: ManifestEntrypoint): Promise<void>;
 }
 
-export { ConditionsCollectionView, ConditionsDashboard, ConditionsDashboardCollection, ConditionsEditorViewCollection, ConditionsEntityAction, ConditionsEntityBulkAction, ConditionsMenuItem, ConditionsPropertyAction, ConditionsSectionSidebarApp, ConditionsSectionView, ConditionsWorkspaceAction, ConditionsWorkspaceView, HealthCheck, ManifestBase, ManifestClass, ManifestClassWithClassConstructor, ManifestCollectionView, ManifestDashboard, ManifestDashboardCollection, ManifestElement, ManifestElementWithElementName, ManifestEntityAction, ManifestEntityBulkAction, ManifestEntrypoint, ManifestExternalLoginProvider, ManifestHeaderApp, ManifestHeaderAppButtonKind, ManifestHealthCheck, ManifestKind, ManifestMenu, ManifestMenuItem, ManifestMenuItemTreeKind, ManifestModal, ManifestPackageView, ManifestPropertyAction, ManifestPropertyEditorModel, ManifestPropertyEditorUI, ManifestRepository, ManifestSection, ManifestSectionSidebarApp, ManifestSectionSidebarAppMenuKind, ManifestSectionView, ManifestStandardTypes, ManifestStore, ManifestTheme, ManifestTree, ManifestTreeStore, ManifestTypeMap, ManifestTypes, ManifestUserDashboard, ManifestWithConditions, ManifestWithLoader, ManifestWithMeta, ManifestWithView, ManifestWorkspace, ManifestWorkspaceAction, ManifestWorkspaceView, ManifestWorkspaceViewCollection, MetaCollectionView, MetaDashboard, MetaDashboardCollection, MetaEditor, MetaEditorViewCollection, MetaEntityAction, MetaEntityBulkAction, MetaExternalLoginProvider, MetaHeaderApp, MetaHeaderAppButtonKind, MetaHealthCheck, MetaManifestWithView, MetaMenuItem, MetaMenuItemTreeKind, MetaPackageView, MetaPropertyEditorModel, MetaPropertyEditorUI, MetaSection, MetaSectionSidebarAppMenuKind, MetaSectionView, MetaTree, MetaUserDashboard, MetaWorkspaceAction, MetaWorkspaceView, PropertyEditorConfig, PropertyEditorConfigDefaultData, PropertyEditorConfigProperty, SpecificManifestTypeOrManifestBase, UmbEntryPointExtensionInitializer };
+export { ConditionsCollectionView, ConditionsDashboard, ConditionsDashboardCollection, ConditionsEditorViewCollection, ConditionsEntityAction, ConditionsEntityBulkAction, ConditionsMenuItem, ConditionsPropertyAction, ConditionsSectionSidebarApp, ConditionsSectionView, ConditionsTreeItem, ConditionsWorkspaceAction, ConditionsWorkspaceView, HealthCheck, ManifestBase, ManifestClass, ManifestClassWithClassConstructor, ManifestCollectionView, ManifestDashboard, ManifestDashboardCollection, ManifestElement, ManifestElementWithElementName, ManifestEntityAction, ManifestEntityBulkAction, ManifestEntrypoint, ManifestExternalLoginProvider, ManifestHeaderApp, ManifestHeaderAppButtonKind, ManifestHealthCheck, ManifestItemStore, ManifestKind, ManifestMenu, ManifestMenuItem, ManifestMenuItemTreeKind, ManifestModal, ManifestPackageView, ManifestPropertyAction, ManifestPropertyEditorModel, ManifestPropertyEditorUI, ManifestRepository, ManifestSection, ManifestSectionSidebarApp, ManifestSectionSidebarAppMenuKind, ManifestSectionView, ManifestStandardTypes, ManifestStore, ManifestTheme, ManifestTree, ManifestTreeItem, ManifestTreeStore, ManifestTypeMap, ManifestTypes, ManifestUserProfileApp, ManifestWithConditions, ManifestWithLoader, ManifestWithMeta, ManifestWithView, ManifestWorkspace, ManifestWorkspaceAction, ManifestWorkspaceView, ManifestWorkspaceViewCollection, MetaCollectionView, MetaDashboard, MetaDashboardCollection, MetaEditor, MetaEditorViewCollection, MetaEntityAction, MetaEntityBulkAction, MetaExternalLoginProvider, MetaHeaderApp, MetaHeaderAppButtonKind, MetaHealthCheck, MetaManifestWithView, MetaMenuItem, MetaMenuItemTreeKind, MetaPackageView, MetaPropertyEditorModel, MetaPropertyEditorUI, MetaSection, MetaSectionSidebarAppMenuKind, MetaSectionView, MetaTree, MetaUserProfileApp, MetaWorkspaceAction, MetaWorkspaceView, PropertyEditorConfig, PropertyEditorConfigDefaultData, PropertyEditorConfigProperty, SpecificManifestTypeOrManifestBase, UmbEntryPointExtensionInitializer };