@umbraco-cms/backoffice 14.0.0-8a5fc0ad → 14.0.0-8d2a75e2

package/dist-cms/libs/class-api/class.mixin.js

@@ -22,7 +22,7 @@ export const UmbClassMixin = (superClass) => {
          * @memberof UmbElementMixin
          */
         observe(source, callback, controllerAlias) {
-            return new UmbObserverController(this, source.asObservable ? source.asObservable() : source, callback, controllerAlias);
+            return new UmbObserverController(this, source, callback, controllerAlias);
         }
         /**
          * @description Provide a context API for this or child elements.

package/dist-cms/libs/context-api/consume/context-consumer.controller.js

@@ -12,8 +12,6 @@ export class UmbContextConsumerController extends UmbContextConsumer {
     }
     destroy() {
         super.destroy();
-        if (this.#host) {
-            this.#host.removeController(this);
-        }
+        this.#host.removeController(this);
     }
 }

package/dist-cms/libs/context-api/consume/context-consumer.d.ts

@@ -24,6 +24,5 @@ export declare class UmbContextConsumer<T = unknown> {
     request(): void;
     hostConnected(): void;
     hostDisconnected(): void;
-    private _handleNewProvider;
     destroy(): void;
 }

package/dist-cms/libs/context-api/consume/context-consumer.js

@@ -1,4 +1,8 @@
-import { isUmbContextProvideEventType, umbContextProvideEventType } from '../provide/context-provide.event.js';
+import { isUmbContextProvideEventType, 
+//isUmbContextUnprovidedEventType,
+umbContextProvideEventType,
+//umbContextUnprovidedEventType,
+ } from '../provide/context-provide.event.js';
 import { UmbContextRequestEventImplementation } from './context-request.event.js';
 /**
  * @export
@@ -22,15 +26,20 @@ export class UmbContextConsumer {
      */
     constructor(hostElement, contextAlias, callback) {
         this.hostElement = hostElement;
+        /* Idea: Niels: If we need to filter for specific contexts, we could make the response method return true/false. If false, the event should then then not be stopped. Alternatively parse the event it self on to the response-callback. This will enable the event to continue to bubble up finding a context that matches. The reason for such would be to have some who are more specific than others. For example, some might just need the current workspace-context, others might need the closest handling a certain entityType. As I'm writting this is not relevant, but I wanted to keep the idea as we have had some circumstance that might be solved with this approach.*/
         this._onResponse = (instance) => {
             if (this.#instance === instance) {
                 return;
             }
             this.#instance = instance;
             this.#callback?.(instance);
-            this.#promiseResolver?.(instance);
+            if (instance !== undefined) {
+                this.#promiseResolver?.(instance);
+                this.#promise = undefined;
+            }
         };
-        this._handleNewProvider = (event) => {
+        this.#handleNewProvider = (event) => {
+            // Does seem a bit unnecessary, we could just assume the type via type casting...
             if (!isUmbContextProvideEventType(event))
                 return;
             if (this.#contextAlias === event.contextAlias) {
@@ -41,7 +50,7 @@ export class UmbContextConsumer {
         this.#callback = callback;
     }
     asPromise() {
-        return (this.#promise ||
+        return (this.#promise ??
             (this.#promise = new Promise((resolve) => {
                 this.#instance ? resolve(this.#instance) : (this.#promiseResolver = resolve);
             })));
@@ -55,13 +64,34 @@ export class UmbContextConsumer {
     }
     hostConnected() {
         // TODO: We need to use closets application element. We need this in order to have separate Backoffice running within or next to each other.
-        window.addEventListener(umbContextProvideEventType, this._handleNewProvider);
+        window.addEventListener(umbContextProvideEventType, this.#handleNewProvider);
+        //window.addEventListener(umbContextUnprovidedEventType, this.#handleRemovedProvider);
         this.request();
     }
     hostDisconnected() {
         // TODO: We need to use closets application element. We need this in order to have separate Backoffice running within or next to each other.
-        window.removeEventListener(umbContextProvideEventType, this._handleNewProvider);
+        window.removeEventListener(umbContextProvideEventType, this.#handleNewProvider);
+        //window.removeEventListener(umbContextUnprovidedEventType, this.#handleRemovedProvider);
+    }
+    #handleNewProvider;
+    //Niels: I'm keeping this code around as it might be relevant, but I wanted to try to see if leaving this feature out for now could work for us.
+    /*
+    #handleRemovedProvider = (event: Event) => {
+        // Does seem a bit unnecessary, we could just assume the type via type casting...
+        if (!isUmbContextUnprovidedEventType(event)) return;
+
+        if (this.#contextAlias === event.contextAlias && event.instance === this.#instance) {
+            this.#unProvide();
+        }
+    };
+
+    #unProvide() {
+        if (this.#instance !== undefined) {
+            this.#instance = undefined;
+            this.#callback?.(undefined);
+        }
     }
+    */
     // TODO: Test destroy scenarios:
     destroy() {
         this.hostDisconnected();

package/dist-cms/libs/context-api/provide/context-provide.event.d.ts

@@ -18,3 +18,24 @@ export declare class UmbContextProvideEventImplementation extends Event implemen
     constructor(contextAlias: string | UmbContextToken);
 }
 export declare const isUmbContextProvideEventType: (event: Event) => event is UmbContextProvideEventImplementation;
+export declare const umbContextUnprovidedEventType = "umb:context-unprovided";
+/**
+ * @export
+ * @interface UmbContextProvideEvent
+ */
+export interface UmbContextUnprovidedEvent extends Event {
+    readonly contextAlias: string | UmbContextToken;
+    readonly instance: unknown;
+}
+/**
+ * @export
+ * @class UmbContextUnprovidedEventImplementation
+ * @extends {Event}
+ * @implements {UmbContextUnprovidedEvent}
+ */
+export declare class UmbContextUnprovidedEventImplementation extends Event implements UmbContextUnprovidedEvent {
+    readonly contextAlias: string | UmbContextToken;
+    readonly instance: unknown;
+    constructor(contextAlias: string | UmbContextToken, instance: unknown);
+}
+export declare const isUmbContextUnprovidedEventType: (event: Event) => event is UmbContextUnprovidedEventImplementation;

package/dist-cms/libs/context-api/provide/context-provide.event.js

@@ -14,3 +14,20 @@ export class UmbContextProvideEventImplementation extends Event {
 export const isUmbContextProvideEventType = (event) => {
     return event.type === umbContextProvideEventType;
 };
+export const umbContextUnprovidedEventType = 'umb:context-unprovided';
+/**
+ * @export
+ * @class UmbContextUnprovidedEventImplementation
+ * @extends {Event}
+ * @implements {UmbContextUnprovidedEvent}
+ */
+export class UmbContextUnprovidedEventImplementation extends Event {
+    constructor(contextAlias, instance) {
+        super(umbContextUnprovidedEventType, { bubbles: true, composed: true });
+        this.contextAlias = contextAlias;
+        this.instance = instance;
+    }
+}
+export const isUmbContextUnprovidedEventType = (event) => {
+    return event.type === umbContextUnprovidedEventType;
+};

package/dist-cms/libs/context-api/provide/context-provider.controller.js

@@ -19,9 +19,9 @@ export class UmbContextProviderController extends UmbContextProvider {
         }
     }
     destroy() {
-        super.destroy();
         if (this.#host) {
             this.#host.removeController(this);
         }
+        super.destroy();
     }
 }

package/dist-cms/libs/context-api/provide/context-provider.d.ts

@@ -29,12 +29,6 @@ export declare class UmbContextProvider {
      * @memberof UmbContextProvider
      */
     hostDisconnected(): void;
-    /**
-     * @private
-     * @param {UmbContextRequestEvent} event
-     * @memberof UmbContextProvider
-     */
-    private _handleContextRequest;
     private _handleDebugContextRequest;
     destroy(): void;
 }

package/dist-cms/libs/context-api/provide/context-provider.js

@@ -1,5 +1,7 @@
 import { umbContextRequestEventType, isUmbContextRequestEvent, umbDebugContextEventType, } from '../consume/context-request.event.js';
-import { UmbContextProvideEventImplementation } from './context-provide.event.js';
+import { UmbContextProvideEventImplementation,
+//UmbContextUnprovidedEventImplementation,
+ } from './context-provide.event.js';
 /**
  * @export
  * @class UmbContextProvider
@@ -27,7 +29,7 @@ export class UmbContextProvider {
          * @param {UmbContextRequestEvent} event
          * @memberof UmbContextProvider
          */
-        this._handleContextRequest = (event) => {
+        this.#handleContextRequest = (event) => {
             if (!isUmbContextRequestEvent(event))
                 return;
             if (event.contextAlias !== this._contextAlias)
@@ -51,11 +53,17 @@ export class UmbContextProvider {
         this._contextAlias = contextAlias.toString();
         this.#instance = instance;
     }
+    /**
+     * @private
+     * @param {UmbContextRequestEvent} event
+     * @memberof UmbContextProvider
+     */
+    #handleContextRequest;
     /**
      * @memberof UmbContextProvider
      */
     hostConnected() {
-        this.hostElement.addEventListener(umbContextRequestEventType, this._handleContextRequest);
+        this.hostElement.addEventListener(umbContextRequestEventType, this.#handleContextRequest);
         this.hostElement.dispatchEvent(new UmbContextProvideEventImplementation(this._contextAlias));
         // Listen to our debug event 'umb:debug-contexts'
         this.hostElement.addEventListener(umbDebugContextEventType, this._handleDebugContextRequest);
@@ -64,11 +72,15 @@ export class UmbContextProvider {
      * @memberof UmbContextProvider
      */
     hostDisconnected() {
-        this.hostElement.removeEventListener(umbContextRequestEventType, this._handleContextRequest);
-        // TODO: fire unprovided event.
+        this.hostElement.removeEventListener(umbContextRequestEventType, this.#handleContextRequest);
+        // Out-commented for now, but kept if we like to reintroduce this:
+        //window.dispatchEvent(new UmbContextUnprovidedEventImplementation(this._contextAlias, this.#instance));
+        // Stop listen to our debug event 'umb:debug-contexts'
+        this.hostElement.removeEventListener(umbDebugContextEventType, this._handleDebugContextRequest);
     }
     destroy() {
-        // I want to make sure to call this, but for now it was too overwhelming to require the destroy method on context instances.
+        // We want to call a destroy method on the instance, if it has one.
         this.#instance?.destroy?.();
+        this.#instance = undefined;
     }
 }

package/dist-cms/libs/controller-api/controller-host-base.mixin.js

@@ -80,6 +80,7 @@ export const UmbControllerHostBaseMixin = (superClass) => {
         }
         destroy() {
             this.#controllers.forEach((ctrl) => ctrl.destroy());
+            this.#controllers.length = 0;
         }
     }
     return UmbControllerHostBaseClass;

package/dist-cms/libs/controller-api/controller-host-element.mixin.d.ts

@@ -1,8 +1,14 @@
-import { HTMLElementConstructor } from '../extension-api/types.js';
-import { UmbControllerAlias } from './controller-alias.type.js';
-import { UmbControllerHost } from './controller-host.interface.js';
+import type { HTMLElementConstructor } from '../extension-api/types.js';
+import type { UmbControllerAlias } from './controller-alias.type.js';
+import type { UmbControllerHost } from './controller-host.interface.js';
 import type { UmbController } from './controller.interface.js';
+import type { UmbLocalizeController } from '../localization-api/index.js';
 export declare class UmbControllerHostElement extends HTMLElement implements UmbControllerHost {
+    /**
+     * Use the UmbLocalizeController to localize your element.
+     * @see UmbLocalizeController
+     */
+    localize: UmbLocalizeController;
     hasController(controller: UmbController): boolean;
     getControllers(filterMethod: (ctrl: UmbController) => boolean): UmbController[];
     addController(controller: UmbController): void;

package/dist-cms/libs/element-api/element.mixin.d.ts

@@ -2,11 +2,18 @@ import type { Observable } from '../../external/rxjs/index.js';
 import type { HTMLElementConstructor } from '../extension-api/index.js';
 import type { UmbControllerHostElement } from '../controller-api/index.js';
 import { UmbContextToken, UmbContextCallback, UmbContextConsumerController, UmbContextProviderController } from '../context-api/index.js';
-import { UmbObserverController } from '../observable-api/index.js';
+import { ObserverCallback, UmbObserverController } from '../observable-api/index.js';
 export declare class UmbElement extends UmbControllerHostElement {
+    /**
+     * @description Observe a RxJS source of choice.
+     * @param {Observable<T>} source RxJS source
+     * @param {method} callback Callback method called when data is changed.
+     * @return {UmbObserverController} Reference to a Observer Controller instance
+     * @memberof UmbElementMixin
+     */
     observe<T>(source: Observable<T> | {
         asObservable: () => Observable<T>;
-    }, callback: (_value: T) => void, unique?: string): UmbObserverController<T>;
+    }, callback: ObserverCallback<T>, 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>;
 }

package/dist-cms/libs/element-api/element.mixin.js

@@ -1,8 +1,13 @@
+import { UmbLocalizeController } from '../localization-api/index.js';
 import { UmbControllerHostElementMixin } from '../controller-api/index.js';
 import { UmbContextConsumerController, UmbContextProviderController, } from '../context-api/index.js';
 import { UmbObserverController } from '../observable-api/index.js';
 export const UmbElementMixin = (superClass) => {
     class UmbElementMixinClass extends UmbControllerHostElementMixin(superClass) {
+        constructor() {
+            super(...arguments);
+            this.localize = new UmbLocalizeController(this);
+        }
         /**
          * @description Observe a RxJS source of choice.
          * @param {Observable<T>} source RxJS source
@@ -11,7 +16,7 @@ export const UmbElementMixin = (superClass) => {
          * @memberof UmbElementMixin
          */
         observe(source, callback, unique) {
-            return new UmbObserverController(this, source.asObservable ? source.asObservable() : source, callback, unique);
+            return new UmbObserverController(this, source, callback, unique);
         }
         /**
          * @description Provide a context API for this or child elements.

package/dist-cms/libs/extension-api/condition/condition-controller-arguments.type.d.ts

@@ -0,0 +1,7 @@
+import type { UmbConditionConfigBase } from '../types.js';
+import type { UmbControllerHost } from '../../controller-api/index.js';
+export type UmbConditionControllerArguments<ConditionConfigType extends UmbConditionConfigBase = UmbConditionConfigBase> = {
+    host: UmbControllerHost;
+    config: ConditionConfigType;
+    onChange: () => void;
+};

package/dist-cms/libs/extension-api/condition/condition-controller-arguments.type.js

@@ -0,0 +1 @@
+export {};

package/dist-cms/libs/extension-api/condition/extension-condition.interface.d.ts

@@ -0,0 +1,6 @@
+import type { UmbConditionConfigBase } from '../types.js';
+import { UmbController } from '../../controller-api/index.js';
+export interface UmbExtensionCondition extends UmbController {
+    readonly permitted: boolean;
+    readonly config: UmbConditionConfigBase;
+}

package/dist-cms/libs/extension-api/condition/extension-condition.interface.js

@@ -0,0 +1 @@
+export {};

package/dist-cms/libs/extension-api/condition/index.d.ts

@@ -0,0 +1,2 @@
+export * from './extension-condition.interface.js';
+export * from './condition-controller-arguments.type.js';

package/dist-cms/libs/extension-api/condition/index.js

@@ -0,0 +1,2 @@
+export * from './extension-condition.interface.js';
+export * from './condition-controller-arguments.type.js';

package/dist-cms/libs/extension-api/controller/base-extension-controller.d.ts

@@ -0,0 +1,19 @@
+import { UmbBaseController, type UmbControllerHost } from '../../controller-api/index.js';
+import { type ManifestCondition, type ManifestWithDynamicConditions, type UmbExtensionRegistry } from '../index.js';
+export declare abstract class UmbBaseExtensionController<ManifestType extends ManifestWithDynamicConditions = ManifestWithDynamicConditions, SubClassType = never> extends UmbBaseController {
+    #private;
+    protected _positive?: boolean;
+    get weight(): number;
+    get permitted(): boolean;
+    get manifest(): ManifestType | undefined;
+    get alias(): string;
+    get overwrites(): string[];
+    hasConditions: () => Promise<boolean>;
+    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestCondition>, alias: string, onPermissionChanged: (isPermitted: boolean, controller: SubClassType) => void);
+    protected _init(): void;
+    asPromise(): Promise<void>;
+    protected abstract _conditionsAreGood(): Promise<boolean>;
+    protected abstract _conditionsAreBad(): Promise<void>;
+    equal(otherClass: UmbBaseExtensionController | undefined): boolean;
+    destroy(): void;
+}

package/dist-cms/libs/extension-api/controller/base-extension-controller.js

@@ -0,0 +1,178 @@
+import { UmbBaseController } from '../../controller-api/index.js';
+import { createExtensionClass, } from '../index.js';
+export class UmbBaseExtensionController extends UmbBaseController {
+    #promiseResolvers;
+    #manifestObserver;
+    #extensionRegistry;
+    #alias;
+    #overwrites;
+    #manifest;
+    #conditionControllers;
+    #onPermissionChanged;
+    #isPermitted;
+    get weight() {
+        return this.#manifest?.weight ?? 0;
+    }
+    get permitted() {
+        return this.#isPermitted ?? false;
+    }
+    get manifest() {
+        return this.#manifest;
+    }
+    get alias() {
+        return this.#alias;
+    }
+    get overwrites() {
+        return this.#overwrites;
+    }
+    constructor(host, extensionRegistry, alias, onPermissionChanged) {
+        super(host, alias);
+        this.#promiseResolvers = [];
+        this.#overwrites = [];
+        this.#conditionControllers = [];
+        this.hasConditions = async () => {
+            await this.#manifestObserver.asPromise();
+            return (this.#manifest?.conditions ?? []).length > 0;
+        };
+        this.#onConditionsChangedCallback = async () => {
+            const oldValue = this.#isPermitted ?? false;
+            // Find a condition that is not permitted (Notice how no conditions, means that this extension is permitted)
+            const isPositive = this.#conditionsAreInitialized() &&
+                this.#conditionControllers.find((condition) => condition.permitted === false) === undefined;
+            this._positive = isPositive;
+            if (isPositive) {
+                if (this.#isPermitted !== true) {
+                    this.#isPermitted = await this._conditionsAreGood();
+                }
+            }
+            else if (this.#isPermitted !== false) {
+                await this._conditionsAreBad();
+                this.#isPermitted = false;
+            }
+            if (oldValue !== this.#isPermitted) {
+                if (this.#isPermitted) {
+                    this.#promiseResolvers.forEach((x) => x());
+                    this.#promiseResolvers = [];
+                }
+                this.#onPermissionChanged(this.#isPermitted, this);
+            }
+        };
+        this.#extensionRegistry = extensionRegistry;
+        this.#alias = alias;
+        this.#onPermissionChanged = onPermissionChanged;
+    }
+    _init() {
+        this.#manifestObserver = this.observe(this.#extensionRegistry.getByAlias(this.#alias), async (extensionManifest) => {
+            this.#isPermitted = undefined;
+            this.#manifest = extensionManifest;
+            if (extensionManifest) {
+                if (extensionManifest.overwrites) {
+                    if (typeof extensionManifest.overwrites === 'string') {
+                        this.#overwrites = [extensionManifest.overwrites];
+                    }
+                    else if (Array.isArray(extensionManifest.overwrites)) {
+                        this.#overwrites = extensionManifest.overwrites;
+                    }
+                }
+                this.#gotConditions();
+            }
+            else {
+                this.#overwrites = [];
+                this.#cleanConditions();
+            }
+        });
+    }
+    asPromise() {
+        return new Promise((resolve) => {
+            this.#isPermitted === true ? resolve() : this.#promiseResolvers.push(resolve);
+        });
+    }
+    #cleanConditions() {
+        this.#conditionControllers.forEach((controller) => controller.destroy());
+        this.#conditionControllers = [];
+        this.removeControllerByAlias('_observeConditions');
+    }
+    #gotConditions() {
+        const conditionConfigs = this.#manifest?.conditions ?? [];
+        // As conditionConfigs might have been configured as something else than an array, then we ignorer them.
+        if (conditionConfigs.length === undefined || conditionConfigs.length === 0) {
+            this.#cleanConditions();
+            this.#onConditionsChangedCallback();
+            return;
+        }
+        const conditionAliases = conditionConfigs
+            .map((condition) => condition.alias)
+            .filter((value, index, array) => array.indexOf(value) === index);
+        const oldAmountOfControllers = this.#conditionControllers.length;
+        // Clean up conditions controllers based on keepers:
+        this.#conditionControllers = this.#conditionControllers.filter((current) => {
+            const continueExistence = conditionConfigs.find((config) => config === current.config);
+            if (!continueExistence) {
+                // Destroy condition that is no longer needed.
+                current.destroy();
+            }
+            return continueExistence;
+        });
+        // Check if there was no change in conditions:
+        // First check if any got removed(old amount equal controllers after clean-up)
+        // && check if any new is about to be added(old equal new amount):
+        const noChangeInConditions = oldAmountOfControllers === this.#conditionControllers.length &&
+            oldAmountOfControllers === conditionConfigs.length;
+        if (conditionConfigs.length > 0) {
+            // Observes the conditions and initialize as they come in.
+            this.observe(this.#extensionRegistry.getByTypeAndAliases('condition', conditionAliases), async (manifests) => {
+                // New comers:
+                manifests.forEach((conditionManifest) => {
+                    const configsOfThisType = conditionConfigs.filter((conditionConfig) => conditionConfig.alias === conditionManifest.alias);
+                    // Spin up conditions, based of condition configs:
+                    configsOfThisType.forEach(async (conditionConfig) => {
+                        // Check if we already have a controller for this config:
+                        const existing = this.#conditionControllers.find((controller) => controller.config === conditionConfig);
+                        if (!existing) {
+                            const conditionController = await createExtensionClass(conditionManifest, [
+                                {
+                                    host: this,
+                                    manifest: conditionManifest,
+                                    config: conditionConfig,
+                                    onChange: this.#onConditionsChangedCallback,
+                                },
+                            ]);
+                            if (conditionController) {
+                                // Some how listen to it? callback/event/onChange something.
+                                // then call this one: this.#onConditionsChanged();
+                                this.#conditionControllers.push(conditionController);
+                                this.#onConditionsChangedCallback();
+                            }
+                        }
+                    });
+                });
+            }, '_observeConditions');
+        }
+        else {
+            this.removeControllerByAlias('_observeConditions');
+        }
+        if (noChangeInConditions) {
+            // There was not change in the amount of conditions, but the manifest was changed, this means this.#isPermitted is set to undefined and this will always fire the callback:
+            this.#onConditionsChangedCallback();
+        }
+    }
+    #conditionsAreInitialized() {
+        // Not good if we don't have a manifest.
+        // Only good if conditions of manifest is equal to the amount of condition controllers (one for each condition).
+        return (this.#manifest !== undefined && this.#conditionControllers.length === (this.#manifest.conditions ?? []).length);
+    }
+    #onConditionsChangedCallback;
+    equal(otherClass) {
+        return otherClass?.manifest === this.manifest;
+    }
+    destroy() {
+        this.#promiseResolvers = [];
+        if (this.#isPermitted === true) {
+            this.#isPermitted = undefined;
+            this._conditionsAreBad();
+            this.#onPermissionChanged(false, this);
+        }
+        super.destroy();
+        // Destroy the conditions controllers, are begin destroyed cause they are controllers.
+    }
+}

package/dist-cms/libs/extension-api/controller/base-extensions-controller.d.ts

@@ -0,0 +1,19 @@
+import type { ManifestBase, ManifestTypeMap, SpecificManifestTypeOrManifestBase, UmbBaseExtensionController, UmbExtensionRegistry } from '../index.js';
+import { UmbBaseController, UmbControllerHost } from '../../controller-api/index.js';
+export type PermittedControllerType<ControllerType extends {
+    manifest: any;
+}> = ControllerType & {
+    manifest: Required<Pick<ControllerType, 'manifest'>>;
+};
+/**
+ */
+export declare abstract class UmbBaseExtensionsController<ManifestTypes extends ManifestBase, ManifestTypeName extends keyof ManifestTypeMap<ManifestTypes> | string, ManifestType extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, ManifestTypeName>, ControllerType extends UmbBaseExtensionController<ManifestType> = UmbBaseExtensionController<ManifestType>, MyPermittedControllerType extends ControllerType = PermittedControllerType<ControllerType>> extends UmbBaseController {
+    #private;
+    protected _extensions: Array<ControllerType>;
+    private _permittedExts;
+    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestType>, type: ManifestTypeName | Array<ManifestTypeName>, filter: undefined | null | ((manifest: ManifestType) => boolean), onChange: (permittedManifests: Array<MyPermittedControllerType>, controller: MyPermittedControllerType) => void);
+    protected _init(): void;
+    protected abstract _createController(manifest: ManifestType): ControllerType;
+    protected _extensionChanged: (isPermitted: boolean, controller: UmbBaseExtensionController<ManifestType>) => void;
+    destroy(): void;
+}