@umbraco-cms/backoffice 1.0.0-next.93a8a0e4 → 1.0.0-next.93ffdc6a

package/data-type.d.ts

@@ -0,0 +1,13 @@
+import { DataTypePropertyPresentationModel } from '@umbraco-cms/backoffice/backend-api';
+
+/**
+ * Extends Array to add utility functions for accessing data type properties
+ * by alias, returning either the value or the complete DataTypePropertyPresentationModel object
+ */
+declare class UmbDataTypePropertyCollection extends Array<DataTypePropertyPresentationModel> {
+    constructor(args?: Array<DataTypePropertyPresentationModel>);
+    getValueByAlias<T>(alias: string): T | undefined;
+    getByAlias(alias: string): DataTypePropertyPresentationModel | undefined;
+}
+
+export { UmbDataTypePropertyCollection };

package/{element.d.ts → element-api.d.ts}

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
-import { HTMLElementConstructor } from '@umbraco-cms/backoffice/models';
-import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { HTMLElementConstructor } from '@umbraco-cms/backoffice/extension-api';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller-api';
 import { UmbContextToken, UmbContextProviderController, UmbContextCallback, UmbContextConsumerController } from '@umbraco-cms/backoffice/context-api';
 import { UmbObserverController } from '@umbraco-cms/backoffice/observable-api';
 
@@ -8,7 +8,9 @@ interface ResolvedContexts {
     [key: string]: any;
 }
 declare class UmbElementMixinInterface extends UmbControllerHostElement {
-    observe<T>(source: Observable<T>, callback: (_value: T) => void, unique?: string): UmbObserverController<T>;
+    observe<T>(source: Observable<T> | {
+        asObservable: () => 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;

package/entity-action.d.ts

@@ -1,4 +1,4 @@
-import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller-api';
 import { UmbEntityActionBase as UmbEntityActionBase$1 } from '@umbraco-cms/backoffice/entity-action';
 import { UmbDetailRepository, UmbItemRepository, UmbFolderRepository } from '@umbraco-cms/backoffice/repository';
 

package/extension-api.d.ts

@@ -0,0 +1,657 @@
+import { Observable } from 'rxjs';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller-api';
+import { ManifestElement as ManifestElement$1, ManifestWithConditions as ManifestWithConditions$1, ManifestBase as ManifestBase$1, ManifestClass as ManifestClass$1, ManifestWithLoader as ManifestWithLoader$1, ClassConstructor as ClassConstructor$1, ManifestWithView as ManifestWithView$1, MetaManifestWithView as MetaManifestWithView$1, ManifestEntryPoint as ManifestEntryPoint$1 } from '@umbraco-cms/backoffice/extension-api';
+import { UmbDataTypePropertyCollection } from '@umbraco-cms/backoffice/data-type';
+import { UmbStoreBase, UmbTreeStore, UmbItemStore } from '@umbraco-cms/backoffice/store';
+import { TreeItemPresentationModel } from '@umbraco-cms/backoffice/backend-api';
+import { InterfaceLook, InterfaceColor } from '@umbraco-ui/uui-base/lib/types/index';
+import { UmbWorkspaceAction } from '@umbraco-cms/backoffice/workspace';
+
+type HTMLElementConstructor<T = HTMLElement> = new (...args: any[]) => T;
+type ClassConstructor<T> = new (...args: any[]) => T;
+type ManifestTypeMap<ManifestTypes extends ManifestBase> = {
+    [Manifest in ManifestTypes as Manifest['type']]: Manifest;
+} & {
+    [key: string]: ManifestBase;
+};
+type SpecificManifestTypeOrManifestBase<ManifestTypes extends ManifestBase, T extends keyof ManifestTypeMap<ManifestTypes> | string> = T extends keyof ManifestTypeMap<ManifestTypes> ? ManifestTypeMap<ManifestTypes>[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;
+    /**
+     * 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<ManifestTypes> {
+    type: 'kind';
+    alias: string;
+    matchType: string;
+    matchKind: string;
+    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<ClassType = unknown> extends ManifestWithLoader<{
+    default: ClassConstructor<ClassType>;
+}> {
+    readonly CLASS_TYPE?: ClassType;
+    /**
+     * The file location of the javascript file to load
+     * @TJS-required
+     */
+    js?: string;
+    /**
+     * @TJS-ignore
+     */
+    className?: string;
+    /**
+     * @TJS-ignore
+     */
+    class?: ClassConstructor<ClassType>;
+}
+interface ManifestClassWithClassConstructor<T = unknown> extends ManifestClass<T> {
+    class: ClassConstructor<T>;
+}
+interface ManifestElement<ElementType extends HTMLElement = HTMLElement> extends ManifestWithLoader<{
+    default: ClassConstructor<ElementType>;
+} | Omit<object, 'default'>> {
+    readonly ELEMENT_TYPE?: ElementType;
+    /**
+     * 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;
+    /**
+     * This contains properties specific to the type of extension
+     */
+    meta?: unknown;
+}
+interface ManifestWithView<ElementType extends HTMLElement = HTMLElement> extends ManifestElement<ElementType> {
+    meta: MetaManifestWithView;
+}
+interface MetaManifestWithView {
+    pathname: string;
+    label: string;
+    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';
+    /**
+     * The file location of the javascript file to load in the backoffice
+     */
+    js: string;
+}
+
+declare class UmbExtensionRegistry<IncomingManifestTypes extends ManifestBase, ManifestTypes extends ManifestBase = IncomingManifestTypes | ManifestBase> {
+    readonly MANIFEST_TYPES: ManifestTypes;
+    private _extensions;
+    readonly extensions: Observable<ManifestTypes[]>;
+    private _kinds;
+    readonly kinds: Observable<ManifestKind<ManifestTypes>[]>;
+    defineKind(kind: ManifestKind<ManifestTypes>): void;
+    register(manifest: ManifestTypes | ManifestKind<ManifestTypes>): void;
+    registerMany(manifests: Array<ManifestTypes | ManifestKind<ManifestTypes>>): void;
+    unregister(alias: string): void;
+    isRegistered(alias: string): boolean;
+    private _kindsOfType;
+    private _extensionsOfType;
+    private _kindsOfTypes;
+    private _extensionsOfTypes;
+    getByTypeAndAlias<Key extends keyof ManifestTypeMap<ManifestTypes> | string, T extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, Key>>(type: Key, alias: string): Observable<T | undefined>;
+    extensionsOfType<Key extends keyof ManifestTypeMap<ManifestTypes> | string, T extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, Key>>(type: Key): Observable<T[]>;
+    extensionsOfTypes<ExtensionTypes extends ManifestBase = ManifestBase>(types: string[]): Observable<Array<ExtensionTypes>>;
+}
+
+declare function isManifestClassConstructorType(manifest: unknown): manifest is ManifestClassWithClassConstructor;
+
+declare function isManifestClassableType(manifest: ManifestBase): manifest is ManifestClass;
+
+declare function isManifestElementNameType(manifest: unknown): manifest is ManifestElementWithElementName;
+
+declare function isManifestElementableType<ElementType extends HTMLElement = HTMLElement>(manifest: ManifestBase): manifest is ManifestElement;
+
+type ManifestJSType<T> = ManifestWithLoader<T> & {
+    js: string;
+};
+declare function isManifestJSType<T>(manifest: ManifestBase | unknown): manifest is ManifestJSType<T>;
+
+type ManifestLoaderType<T> = ManifestWithLoader<T> & {
+    loader: () => Promise<T>;
+};
+declare function isManifestLoaderType<T>(manifest: ManifestBase): manifest is ManifestLoaderType<T>;
+
+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: UmbControllerHostElement, extensionRegistry: UmbExtensionRegistry<ManifestBase>) => void;
+/**
+ * Interface containing supported life-cycle functions for ESModule entry points
+ */
+interface UmbEntryPointModule {
+    onInit: UmbEntryPointOnInit;
+}
+
+/**
+ * Validate if an ESModule exports a known init function called 'onInit'
+ */
+declare function hasInitExport(obj: unknown): obj is Pick<UmbEntryPointModule, 'onInit'>;
+
+declare function loadExtension<T = unknown>(manifest: ManifestWithLoader<T>): Promise<T | null>;
+
+declare function createExtensionElementOrFallback(manifest: any, fallbackElementName: string): Promise<HTMLElement | undefined>;
+
+declare function createExtensionClass<T = unknown>(manifest: ManifestClass, constructorArguments: unknown[]): Promise<T | undefined>;
+
+declare class UmbEntryPointExtensionInitializer {
+    #private;
+    constructor(host: UmbControllerHostElement, extensionRegistry: UmbExtensionRegistry<ManifestEntryPoint>);
+    instantiateEntryPoint(manifest: ManifestEntryPoint): Promise<void>;
+}
+
+interface ManifestCollectionView extends ManifestElement$1, ManifestWithConditions$1<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 {
+    entityType: string;
+}
+
+interface ManifestDashboard extends ManifestElement$1<UmbDashboardExtensionElement>, ManifestWithConditions$1<ConditionsDashboard> {
+    type: 'dashboard';
+    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[];
+}
+
+interface ManifestDashboardCollection extends ManifestBase$1 {
+    type: 'dashboardCollection';
+    meta: MetaDashboardCollection;
+    conditions: ConditionsDashboardCollection;
+}
+interface MetaDashboardCollection {
+    pathname: string;
+    label?: string;
+    repositoryAlias: string;
+}
+interface ConditionsDashboardCollection {
+    sections: string[];
+    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$1 {
+    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 {
+    entityTypes: Array<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$1, ManifestWithConditions$1<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 {
+    entityType: string;
+}
+
+interface UmbExternalLoginProviderExtensionElement extends HTMLElement {
+    manifest?: ManifestExternalLoginProvider;
+}
+
+interface ManifestExternalLoginProvider extends ManifestElement$1<UmbExternalLoginProviderExtensionElement> {
+    type: 'externalLoginProvider';
+    meta: MetaExternalLoginProvider;
+}
+interface MetaExternalLoginProvider {
+    label: string;
+    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$1 {
+    type: 'headerApp';
+}
+interface ManifestHeaderAppButtonKind extends ManifestHeaderApp {
+    type: 'headerApp';
+    kind: 'button';
+    meta: MetaHeaderAppButtonKind;
+}
+interface MetaHeaderAppButtonKind {
+    href: string;
+    label: string;
+    icon: string;
+}
+
+interface ManifestHealthCheck extends ManifestElement$1 {
+    type: 'healthCheck';
+    meta: MetaHealthCheck;
+}
+interface MetaHealthCheck {
+    label: string;
+    api: any;
+}
+
+interface ManifestMenu extends ManifestElement$1 {
+    type: 'menu';
+}
+
+interface UmbMenuItemExtensionElement extends HTMLElement {
+    manifest?: ManifestMenuItem;
+}
+
+interface ManifestMenuItem extends ManifestElement$1<UmbMenuItemExtensionElement> {
+    type: 'menuItem';
+    meta: MetaMenuItem;
+    conditions: ConditionsMenuItem;
+}
+interface MetaMenuItem {
+    label: string;
+    icon: string;
+    entityType?: string;
+}
+interface ConditionsMenuItem {
+    menus: Array<string>;
+}
+interface ManifestMenuItemTreeKind extends ManifestMenuItem {
+    type: 'menuItem';
+    kind: 'tree';
+    meta: MetaMenuItemTreeKind;
+}
+interface MetaMenuItemTreeKind {
+    treeAlias: string;
+    label: string;
+    icon: string;
+    entityType?: string;
+}
+
+interface ManifestModal extends ManifestElement$1 {
+    type: 'modal';
+}
+
+interface ManifestPackageView extends ManifestElement$1 {
+    type: 'packageView';
+    meta: MetaPackageView;
+}
+interface MetaPackageView {
+    packageName: string;
+}
+
+interface ManifestPropertyAction extends ManifestElement$1, ManifestWithConditions$1<ConditionsPropertyAction> {
+    type: 'propertyAction';
+}
+interface ConditionsPropertyAction {
+    propertyEditors: string[];
+}
+
+interface ManifestPropertyEditorUI extends ManifestElement$1<UmbPropertyEditorExtensionElement> {
+    type: 'propertyEditorUI';
+    meta: MetaPropertyEditorUI;
+}
+interface MetaPropertyEditorUI {
+    label: string;
+    propertyEditorModel: string;
+    icon: string;
+    group: string;
+    config?: PropertyEditorConfig;
+    supportsReadOnly?: boolean;
+}
+interface ManifestPropertyEditorModel extends ManifestBase$1 {
+    type: 'propertyEditorModel';
+    meta: MetaPropertyEditorModel;
+}
+interface MetaPropertyEditorModel {
+    config?: PropertyEditorConfig;
+}
+interface PropertyEditorConfig {
+    properties: PropertyEditorConfigProperty[];
+    defaultData?: PropertyEditorConfigDefaultData[];
+}
+interface PropertyEditorConfigProperty {
+    label: string;
+    description?: string;
+    alias: string;
+    propertyEditorUI: string;
+}
+interface PropertyEditorConfigDefaultData {
+    alias: string;
+    value: any;
+}
+
+interface ManifestRepository extends ManifestClass$1<unknown> {
+    type: 'repository';
+}
+
+interface ManifestSection extends ManifestElement$1<UmbSectionExtensionElement> {
+    type: 'section';
+    meta: MetaSection;
+}
+interface MetaSection {
+    label: string;
+    pathname: string;
+}
+
+interface UmbSectionSidebarAppExtensionElement extends HTMLElement {
+    manifest?: ManifestSectionSidebarApp;
+}
+
+interface ManifestSectionSidebarApp extends ManifestElement$1<UmbSectionSidebarAppExtensionElement> {
+    type: 'sectionSidebarApp';
+    conditions: ConditionsSectionSidebarApp;
+}
+interface ConditionsSectionSidebarApp {
+    sections: Array<string>;
+}
+interface ManifestSectionSidebarAppMenuKind extends ManifestSectionSidebarApp {
+    type: 'sectionSidebarApp';
+    kind: 'menu';
+    meta: MetaSectionSidebarAppMenuKind;
+}
+interface MetaSectionSidebarAppMenuKind {
+    label: string;
+    menu: string;
+}
+
+interface UmbSectionViewExtensionElement extends HTMLElement {
+    manifest?: ManifestSectionView;
+}
+
+interface ManifestSectionView extends ManifestElement$1<UmbSectionViewExtensionElement>, ManifestWithConditions$1<ConditionsSectionView> {
+    type: 'sectionView';
+    meta: MetaSectionView;
+}
+interface MetaSectionView {
+    label: string;
+    pathname: string;
+    icon: string;
+}
+interface ConditionsSectionView {
+    sections: Array<string>;
+}
+
+interface ManifestStore extends ManifestClass$1<UmbStoreBase> {
+    type: 'store';
+}
+interface ManifestTreeStore extends ManifestClass$1<UmbTreeStore> {
+    type: 'treeStore';
+}
+interface ManifestItemStore extends ManifestClass$1<UmbItemStore> {
+    type: 'itemStore';
+}
+
+/**
+ * Theme manifest for styling the backoffice of Umbraco such as dark, high contrast etc
+ */
+interface ManifestTheme extends ManifestWithLoader$1<string> {
+    type: 'theme';
+    /**
+     * File location of the CSS file of the theme
+     *
+     * @examples ["themes/dark.theme.css"]
+     */
+    css?: string;
+}
+
+interface ManifestTree extends ManifestBase$1 {
+    type: 'tree';
+    meta: MetaTree;
+}
+interface MetaTree {
+    repositoryAlias: string;
+}
+
+interface ManifestTreeItem extends ManifestElement$1<UmbTreeItemExtensionElement> {
+    type: 'treeItem';
+    conditions: ConditionsTreeItem;
+}
+interface ConditionsTreeItem {
+    entityTypes: Array<string>;
+}
+
+interface ManifestUserProfileApp extends ManifestElement$1 {
+    type: 'userProfileApp';
+    meta: MetaUserProfileApp;
+}
+interface MetaUserProfileApp {
+    label: string;
+    pathname: string;
+}
+
+interface ManifestWorkspace extends ManifestElement$1 {
+    type: 'workspace';
+    meta: MetaEditor;
+}
+interface MetaEditor {
+    entityType: string;
+}
+
+interface ManifestWorkspaceAction extends ManifestElement$1 {
+    type: 'workspaceAction';
+    meta: MetaWorkspaceAction;
+    conditions: ConditionsWorkspaceAction;
+}
+interface MetaWorkspaceAction {
+    label?: string;
+    look?: InterfaceLook;
+    color?: InterfaceColor;
+    api: ClassConstructor$1<UmbWorkspaceAction>;
+}
+interface ConditionsWorkspaceAction {
+    workspaces: Array<string>;
+}
+
+interface UmbWorkspaceEditorViewExtensionElement extends HTMLElement {
+    manifest?: ManifestWorkspaceEditorView;
+}
+
+interface ManifestWorkspaceEditorView extends ManifestWithView$1<UmbWorkspaceEditorViewExtensionElement> {
+    type: 'workspaceEditorView';
+    conditions: ConditionsWorkspaceView;
+}
+interface ConditionsWorkspaceView {
+    workspaces: string[];
+}
+
+interface ManifestWorkspaceViewCollection extends ManifestWithView$1, ManifestWithConditions$1<ConditionsEditorViewCollection> {
+    type: 'workspaceViewCollection';
+    meta: MetaEditorViewCollection;
+}
+interface MetaEditorViewCollection extends MetaManifestWithView$1 {
+    entityType: string;
+    repositoryAlias: string;
+}
+interface ConditionsEditorViewCollection {
+    workspaces: string[];
+}
+
+type ManifestTypes = ManifestCollectionView | ManifestDashboard | ManifestDashboardCollection | ManifestEntityAction | ManifestEntityBulkAction | ManifestEntryPoint$1 | ManifestExternalLoginProvider | ManifestHeaderApp | ManifestHeaderAppButtonKind | ManifestHealthCheck | ManifestItemStore | ManifestMenu | ManifestMenuItem | ManifestMenuItemTreeKind | ManifestModal | ManifestPackageView | ManifestPropertyAction | ManifestPropertyEditorModel | ManifestPropertyEditorUI | ManifestRepository | ManifestSection | ManifestSectionSidebarApp | ManifestSectionSidebarAppMenuKind | ManifestSectionView | ManifestStore | ManifestTheme | ManifestTree | ManifestTreeItem | ManifestTreeStore | ManifestUserProfileApp | ManifestWorkspace | ManifestWorkspaceAction | ManifestWorkspaceEditorView | ManifestWorkspaceViewCollection | ManifestBase$1;
+
+interface UmbDashboardExtensionElement extends HTMLElement {
+    manifest?: ManifestDashboard;
+}
+
+interface UmbPropertyEditorExtensionElement extends HTMLElement {
+    value: unknown;
+    config?: UmbDataTypePropertyCollection;
+}
+
+interface UmbSectionExtensionElement extends HTMLElement {
+    manifest?: ManifestSection;
+}
+
+interface UmbTreeItemExtensionElement extends HTMLElement {
+    item?: TreeItemPresentationModel;
+}
+
+declare class UmbExtensionClassInitializer<ExtensionType extends string = string, ExtensionManifest extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, ExtensionType>, ExtensionClassInterface = ExtensionManifest extends ManifestClass ? ExtensionManifest['CLASS_TYPE'] : unknown> {
+    #private;
+    constructor(host: UmbControllerHostElement, extensionType: ExtensionType, extensionAlias: string, callback: (extensionClass: ExtensionClassInterface | undefined) => void);
+    asPromise(): Promise<ExtensionClassInterface | undefined>;
+}
+
+export { ClassConstructor, HTMLElementConstructor, ManifestBase, ManifestClass, ManifestClassWithClassConstructor, ManifestElement, ManifestElementWithElementName, ManifestEntryPoint, ManifestJSType, ManifestKind, ManifestLoaderType, ManifestTypeMap, ManifestWithConditions, ManifestWithLoader, ManifestWithMeta, ManifestWithView, MetaManifestWithView, SpecificManifestTypeOrManifestBase, UmbEntryPointExtensionInitializer, UmbEntryPointModule, UmbEntryPointOnInit, UmbExtensionClassInitializer, UmbExtensionRegistry, createExtensionClass, createExtensionElement, createExtensionElementOrFallback, hasDefaultExport, hasInitExport, isManifestClassConstructorType, isManifestClassableType, isManifestElementNameType, isManifestElementableType, isManifestJSType, isManifestLoaderType, loadExtension };