@umbraco-cms/backoffice 14.0.0--preview004-cb305bc6 → 14.0.0--preview004-65c14774

package/dist-cms/apps/backoffice/components/backoffice-main.element.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { UMB_BACKOFFICE_CONTEXT_TOKEN } from '../backoffice.context.js';
 import { css, html, customElement, state } from '../../../external/lit/index.js';
 import { UmbSectionContext, UMB_SECTION_CONTEXT_TOKEN } from '../../../packages/core/section/index.js';
-import { createExtensionElementOrFallback, } from '../../../libs/extension-api/index.js';
+import { createExtensionElement, } from '../../../libs/extension-api/index.js';
 import { UmbLitElement } from '../../../shared/lit-element/index.js';
 export let UmbBackofficeMainElement = class UmbBackofficeMainElement extends UmbLitElement {
     constructor() {
@@ -41,8 +41,7 @@ export let UmbBackofficeMainElement = class UmbBackofficeMainElement extends Umb
             return;
         const oldValue = this._routes;
         // TODO: Refactor this for re-use across the app where the routes are re-generated at any time.
-        // TODO: remove section-routes that does not exist anymore.
-        this._routes = this._sections.map((section) => {
+        this._routes = this._sections.filter(x => x.manifest).map((section) => {
             const existingRoute = this._routes.find((r) => r.alias === section.alias);
             if (existingRoute) {
                 return existingRoute;
@@ -51,7 +50,7 @@ export let UmbBackofficeMainElement = class UmbBackofficeMainElement extends Umb
                 return {
                     alias: section.alias,
                     path: this._routePrefix + section.manifest.meta.pathname,
-                    component: () => createExtensionElementOrFallback(section.manifest, 'umb-section-default'),
+                    component: () => createExtensionElement(section.manifest, 'umb-section-default'),
                     setup: (component) => {
                         component.manifest = section.manifest;
                     },
@@ -86,7 +85,7 @@ export let UmbBackofficeMainElement = class UmbBackofficeMainElement extends Umb
 			:host {
 				background-color: var(--uui-color-background);
 				display: block;
-				height: calc(100% - 60px); // 60 => top header height
+				height: calc(100% - 60px); // 60 => top header height, TODO: Make sure this comes from somewhere so it is maintainable and eventually responsive.
 			}
 		`,
     ]; }

package/dist-cms/custom-elements.json

@@ -828,8 +828,7 @@
         },
         {
           "name": "default-element",
-          "type": "string",
-          "default": "\"\""
+          "type": "string | undefined"
         },
         {
           "name": "renderMethod",
@@ -856,8 +855,7 @@
         {
           "name": "defaultElement",
           "attribute": "default-element",
-          "type": "string",
-          "default": "\"\""
+          "type": "string | undefined"
         },
         {
           "name": "renderMethod",

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

@@ -1,5 +1,5 @@
 import { UmbBaseController } from '../../controller-api/index.js';
-import { createExtensionClass, } from '../index.js';
+import { createExtensionApi, } from '../index.js';
 export class UmbBaseExtensionController extends UmbBaseController {
     #promiseResolvers;
     #manifestObserver;
@@ -129,7 +129,7 @@ export class UmbBaseExtensionController extends UmbBaseController {
                         // 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, [
+                            const conditionController = await createExtensionApi(conditionManifest, [
                                 {
                                     host: this,
                                     manifest: conditionManifest,

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

@@ -1,4 +1,4 @@
-import { createExtensionElement } from '../create-extension-element.function.js';
+import { createExtensionElement } from '../functions/create-extension-element.function.js';
 import { isManifestElementableType } from '../type-guards/is-manifest-elementable-type.function.js';
 import { UmbBaseExtensionController } from './base-extension-controller.js';
 export class UmbExtensionElementController extends UmbBaseExtensionController {
@@ -48,8 +48,9 @@ export class UmbExtensionElementController extends UmbBaseExtensionController {
     };
     async _conditionsAreGood() {
         const manifest = this.manifest; // In this case we are sure its not undefined.
+        console.log("---defaultElement", this._defaultElement);
         if (isManifestElementableType(manifest)) {
-            const newComponent = await createExtensionElement(manifest);
+            const newComponent = await createExtensionElement(manifest, this._defaultElement);
             if (!this._positive) {
                 // We are not positive anymore, so we will back out of this creation.
                 return false;

package/dist-cms/libs/extension-api/functions/create-extension-api.function.d.ts

@@ -0,0 +1,2 @@
+import type { ManifestApi, ManifestElementAndApi } from '../types.js';
+export declare function createExtensionApi<ApiType = unknown>(manifest: ManifestApi<ApiType> | ManifestElementAndApi<any, ApiType>, constructorArguments: unknown[]): Promise<ApiType | undefined>;

package/dist-cms/libs/extension-api/functions/create-extension-api.function.js

@@ -0,0 +1,21 @@
+import { hasApiExport, hasDefaultExport, isManifestApiConstructorType } from '../type-guards/index.js';
+import { loadExtensionApi } from '../functions/load-extension-api.function.js';
+//TODO: Write tests for this method:
+export async function createExtensionApi(manifest, constructorArguments) {
+    const js = await loadExtensionApi(manifest);
+    if (isManifestApiConstructorType(manifest)) {
+        return new manifest.api(...constructorArguments);
+    }
+    if (js) {
+        if (hasApiExport(js)) {
+            return new js.api(...constructorArguments);
+        }
+        if (hasDefaultExport(js)) {
+            return new js.default(...constructorArguments);
+        }
+        console.error(`-- Extension of alias "${manifest.alias}" did not succeed creating an api class instance, missing a 'api' or 'default' export of the served JavaScript file`, manifest);
+        return undefined;
+    }
+    console.error(`-- Extension of alias "${manifest.alias}" did not succeed creating an api class instance, missing a JavaScript file via the 'apiJs' or 'js' property or a ClassConstructor in 'api' in the manifest.`, manifest);
+    return undefined;
+}

package/dist-cms/libs/extension-api/functions/create-extension-element.function.d.ts

@@ -0,0 +1,2 @@
+import type { ManifestElement } from '../types.js';
+export declare function createExtensionElement<ElementType extends HTMLElement>(manifest: ManifestElement<ElementType>, fallbackElementName?: string): Promise<ElementType | undefined>;

package/dist-cms/libs/extension-api/functions/create-extension-element.function.js

@@ -0,0 +1,31 @@
+import { hasDefaultExport, hasElementExport, isManifestElementNameType } from '../type-guards/index.js';
+import { loadExtensionElement } from '../functions/load-extension-element.function.js';
+export async function createExtensionElement(manifest, fallbackElementName) {
+    //TODO: Write tests for these extension options:
+    const js = await loadExtensionElement(manifest);
+    if (isManifestElementNameType(manifest)) {
+        // created by manifest method providing HTMLElement
+        return document.createElement(manifest.elementName);
+    }
+    // TODO: Do we need this except for the default() loader?
+    if (js) {
+        if (hasElementExport(js)) {
+            // Element will be created by default class
+            return new js.element();
+        }
+        if (hasDefaultExport(js)) {
+            // Element will be created by default class
+            return new js.default();
+        }
+        if (!fallbackElementName) {
+            console.error(`-- Extension of alias "${manifest.alias}" did not succeed creating an api class instance, missing a 'element' or 'default' export of the served JavaScript file`, manifest);
+            return undefined;
+        }
+    }
+    if (fallbackElementName) {
+        return document.createElement(fallbackElementName);
+    }
+    // If some JS was loaded and manifest did not have a elementName neither it the JS file contain a default export, so we will fail:
+    console.error(`-- Extension of alias "${manifest.alias}" did not succeed creating an element, missing a JavaScript file via the 'elementJs' or 'js' property or a Element Name in 'elementName' in the manifest.`, manifest);
+    return undefined;
+}

package/dist-cms/libs/extension-api/{has-init-export.function.d.ts → functions/has-init-export.function.d.ts}

@@ -1,4 +1,4 @@
-import type { UmbEntryPointModule } from './entry-point.interface.js';
+import type { UmbEntryPointModule } from '../models/entry-point.interface.js';
 /**
  * Validate if an ESModule exports a known init function called 'onInit'
  */

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

@@ -0,0 +1,6 @@
+export * from './create-extension-api.function.js';
+export * from './create-extension-element.function.js';
+export * from './has-init-export.function.js';
+export * from './load-extension-api.function.js';
+export * from './load-extension-element.function.js';
+export * from './load-extension.function.js';

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

@@ -0,0 +1,6 @@
+export * from './create-extension-api.function.js';
+export * from './create-extension-element.function.js';
+export * from './has-init-export.function.js';
+export * from './load-extension-api.function.js';
+export * from './load-extension-element.function.js';
+export * from './load-extension.function.js';

package/dist-cms/libs/extension-api/functions/load-extension-api.function.d.ts

@@ -0,0 +1,2 @@
+import type { ManifestWithLoader } from '../types.js';
+export declare function loadExtensionApi<T = unknown>(manifest: ManifestWithLoader<T>): Promise<T | null>;

package/dist-cms/libs/extension-api/functions/load-extension-api.function.js

@@ -0,0 +1,19 @@
+import { isManifestApiJSType, isManifestJSType, isManifestLoaderType } from '../type-guards/index.js';
+export async function loadExtensionApi(manifest) {
+    try {
+        if (isManifestLoaderType(manifest)) {
+            return manifest.loader();
+        }
+        if (isManifestApiJSType(manifest) && manifest.apiJs) {
+            return await import(/* @vite-ignore */ manifest.apiJs);
+        }
+        if (isManifestJSType(manifest) && manifest.js) {
+            return await import(/* @vite-ignore */ manifest.js);
+        }
+    }
+    catch (err) {
+        console.warn('-- Extension failed to load script', manifest, err);
+        return Promise.resolve(null);
+    }
+    return Promise.resolve(null);
+}

package/dist-cms/libs/extension-api/functions/load-extension-element.function.d.ts

@@ -0,0 +1,2 @@
+import type { ManifestWithLoader } from '../types.js';
+export declare function loadExtensionElement<T = unknown>(manifest: ManifestWithLoader<T>): Promise<T | null>;

package/dist-cms/libs/extension-api/functions/load-extension-element.function.js

@@ -0,0 +1,19 @@
+import { isManifestElementJSType, isManifestJSType, isManifestLoaderType } from '../type-guards/index.js';
+export async function loadExtensionElement(manifest) {
+    try {
+        if (isManifestLoaderType(manifest)) {
+            return manifest.loader();
+        }
+        if (isManifestElementJSType(manifest) && manifest.elementJs) {
+            return await import(/* @vite-ignore */ manifest.elementJs);
+        }
+        if (isManifestJSType(manifest) && manifest.js) {
+            return await import(/* @vite-ignore */ manifest.js);
+        }
+    }
+    catch (err) {
+        console.warn('-- Extension failed to load script', manifest, err);
+        return Promise.resolve(null);
+    }
+    return Promise.resolve(null);
+}

package/dist-cms/libs/extension-api/{load-extension.function.d.ts → functions/load-extension.function.d.ts}

@@ -1,2 +1,2 @@
-import type { ManifestWithLoader } from './types.js';
+import type { ManifestWithLoader } from '../types.js';
 export declare function loadExtension<T = unknown>(manifest: ManifestWithLoader<T>): Promise<T | null>;

package/dist-cms/libs/extension-api/{load-extension.function.js → functions/load-extension.function.js}

@@ -1,4 +1,4 @@
-import { isManifestJSType, isManifestLoaderType } from './type-guards/index.js';
+import { isManifestJSType, isManifestLoaderType } from '../type-guards/index.js';
 export async function loadExtension(manifest) {
     try {
         if (isManifestLoaderType(manifest)) {

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

@@ -1,14 +1,8 @@
-export * from './bundle-extension-initializer.js';
+export * from './initializers/index.js';
 export * from './condition/index.js';
 export * from './controller/index.js';
-export * from './create-extension-class.function.js';
-export * from './create-extension-element-or-fallback.function.js';
-export * from './create-extension-element.function.js';
-export * from './entry-point-extension-initializer.js';
-export * from './entry-point.interface.js';
-export * from './has-default-export.function.js';
-export * from './has-init-export.function.js';
-export * from './load-extension.function.js';
+export * from './functions/index.js';
+export * from './models/index.js';
 export * from './registry/extension.registry.js';
 export * from './type-guards/index.js';
 export * from './types.js';

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

@@ -1,14 +1,8 @@
-export * from './bundle-extension-initializer.js';
+export * from './initializers/index.js';
 export * from './condition/index.js';
 export * from './controller/index.js';
-export * from './create-extension-class.function.js';
-export * from './create-extension-element-or-fallback.function.js';
-export * from './create-extension-element.function.js';
-export * from './entry-point-extension-initializer.js';
-export * from './entry-point.interface.js';
-export * from './has-default-export.function.js';
-export * from './has-init-export.function.js';
-export * from './load-extension.function.js';
+export * from './functions/index.js';
+export * from './models/index.js';
 export * from './registry/extension.registry.js';
 export * from './type-guards/index.js';
 export * from './types.js';

package/dist-cms/libs/extension-api/{bundle-extension-initializer.d.ts → initializers/bundle-extension-initializer.d.ts}

@@ -1,6 +1,6 @@
-import type { ManifestBundle } from './types.js';
-import { UmbExtensionRegistry } from './registry/extension.registry.js';
-import { UmbBaseController, UmbControllerHostElement } from '../controller-api/index.js';
+import type { ManifestBundle } from '../types.js';
+import { UmbExtensionRegistry } from '../registry/extension.registry.js';
+import { UmbBaseController, UmbControllerHostElement } from '../../controller-api/index.js';
 export declare class UmbBundleExtensionInitializer extends UmbBaseController {
     #private;
     constructor(host: UmbControllerHostElement, extensionRegistry: UmbExtensionRegistry<ManifestBundle>);

package/dist-cms/libs/extension-api/{bundle-extension-initializer.js → initializers/bundle-extension-initializer.js}

@@ -1,5 +1,5 @@
-import { loadExtension } from './load-extension.function.js';
-import { UmbBaseController } from '../controller-api/index.js';
+import { loadExtension } from '../functions/load-extension.function.js';
+import { UmbBaseController } from '../../controller-api/index.js';
 export class UmbBundleExtensionInitializer extends UmbBaseController {
     #extensionRegistry;
     #bundleMap = new Map();

package/dist-cms/libs/extension-api/{entry-point-extension-initializer.d.ts → initializers/entry-point-extension-initializer.d.ts}

@@ -1,7 +1,7 @@
-import { UmbBaseController } from '../controller-api/controller.class.js';
-import type { ManifestEntryPoint } from './types.js';
-import { UmbExtensionRegistry } from './registry/extension.registry.js';
-import { UmbElement } from '../element-api/index.js';
+import { UmbBaseController } from '../../controller-api/controller.class.js';
+import type { ManifestEntryPoint } from '../types.js';
+import { UmbExtensionRegistry } from '../registry/extension.registry.js';
+import { UmbElement } from '../../element-api/index.js';
 export declare class UmbEntryPointExtensionInitializer extends UmbBaseController {
     #private;
     constructor(host: UmbElement, extensionRegistry: UmbExtensionRegistry<ManifestEntryPoint>);

package/dist-cms/libs/extension-api/{entry-point-extension-initializer.js → initializers/entry-point-extension-initializer.js}

@@ -1,6 +1,5 @@
-import { UmbBaseController } from '../controller-api/controller.class.js';
-import { hasInitExport } from './has-init-export.function.js';
-import { loadExtension } from './load-extension.function.js';
+import { UmbBaseController } from '../../controller-api/controller.class.js';
+import { hasInitExport, loadExtension } from '../functions/index.js';
 export class UmbEntryPointExtensionInitializer extends UmbBaseController {
     #host;
     #extensionRegistry;

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

@@ -0,0 +1,2 @@
+export * from './bundle-extension-initializer.js';
+export * from './entry-point-extension-initializer.js';

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

@@ -0,0 +1,2 @@
+export * from './bundle-extension-initializer.js';
+export * from './entry-point-extension-initializer.js';

package/dist-cms/libs/extension-api/{entry-point.interface.d.ts → models/entry-point.interface.d.ts}

@@ -1,6 +1,6 @@
-import type { UmbExtensionRegistry } from './registry/extension.registry.js';
-import { ManifestBase } from './types.js';
-import type { UmbElement } from '../element-api/index.js';
+import type { UmbExtensionRegistry } from '../registry/extension.registry.js';
+import { ManifestBase } from '../types.js';
+import type { UmbElement } from '../../element-api/index.js';
 export type UmbEntryPointOnInit = (host: UmbElement, extensionRegistry: UmbExtensionRegistry<ManifestBase>) => void;
 /**
  * Interface containing supported life-cycle functions for ESModule entry points

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

@@ -0,0 +1 @@
+export * from './entry-point.interface.js';

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

@@ -0,0 +1 @@
+export * from './entry-point.interface.js';

package/dist-cms/libs/extension-api/type-guards/has-api-export.function.d.ts

@@ -0,0 +1,3 @@
+export declare function hasApiExport<ConstructorType>(object: unknown): object is {
+    api: ConstructorType;
+};

package/dist-cms/libs/extension-api/type-guards/has-api-export.function.js

@@ -0,0 +1,3 @@
+export function hasApiExport(object) {
+    return typeof object === 'object' && object !== null && 'api' in object;
+}

package/dist-cms/libs/extension-api/type-guards/has-element-export.function.d.ts

@@ -0,0 +1,3 @@
+export declare function hasElementExport<ConstructorType>(object: unknown): object is {
+    element: ConstructorType;
+};

package/dist-cms/libs/extension-api/type-guards/has-element-export.function.js

@@ -0,0 +1,3 @@
+export function hasElementExport(object) {
+    return typeof object === 'object' && object !== null && 'element' in object;
+}

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

@@ -1,6 +1,11 @@
-export * from './is-manifest-class-instance-type.function.js';
-export * from './is-manifest-classable-type.function.js';
+export * from './is-manifest-api-instance-type.function.js';
+export * from './is-manifest-apiable-type.function.js';
 export * from './is-manifest-element-name-type.function.js';
 export * from './is-manifest-elementable-type.function.js';
 export * from './is-manifest-js-type.function.js';
+export * from './is-manifest-element-js-type.function.js';
+export * from './is-manifest-api-js-type.function.js';
 export * from './is-manifest-loader-type.function.js';
+export * from './has-default-export.function.js';
+export * from './has-element-export.function.js';
+export * from './has-api-export.function.js';

package/dist-cms/libs/extension-api/type-guards/index.js

@@ -1,6 +1,11 @@
-export * from './is-manifest-class-instance-type.function.js';
-export * from './is-manifest-classable-type.function.js';
+export * from './is-manifest-api-instance-type.function.js';
+export * from './is-manifest-apiable-type.function.js';
 export * from './is-manifest-element-name-type.function.js';
 export * from './is-manifest-elementable-type.function.js';
 export * from './is-manifest-js-type.function.js';
+export * from './is-manifest-element-js-type.function.js';
+export * from './is-manifest-api-js-type.function.js';
 export * from './is-manifest-loader-type.function.js';
+export * from './has-default-export.function.js';
+export * from './has-element-export.function.js';
+export * from './has-api-export.function.js';

package/dist-cms/libs/extension-api/type-guards/is-manifest-api-instance-type.function.d.ts

@@ -0,0 +1,5 @@
+import type { ClassConstructor, ManifestApi } from '../types.js';
+export declare function isManifestApiConstructorType<ApiType>(manifest: unknown): manifest is ManifestApiWithClassConstructor<ApiType>;
+export interface ManifestApiWithClassConstructor<T = unknown> extends ManifestApi<T> {
+    api: ClassConstructor<T>;
+}

package/dist-cms/libs/extension-api/type-guards/is-manifest-api-instance-type.function.js

@@ -0,0 +1,3 @@
+export function isManifestApiConstructorType(manifest) {
+    return typeof manifest === 'object' && manifest !== null && manifest.api !== undefined;
+}

package/dist-cms/libs/extension-api/type-guards/is-manifest-api-js-type.function.d.ts

@@ -0,0 +1,5 @@
+import type { ManifestBase, ManifestWithLoader } from '../types.js';
+export type ManifestApiJSType<T> = ManifestWithLoader<T> & {
+    apiJs: string;
+};
+export declare function isManifestApiJSType<T>(manifest: ManifestBase | unknown): manifest is ManifestApiJSType<T>;

package/dist-cms/libs/extension-api/type-guards/is-manifest-api-js-type.function.js

@@ -0,0 +1,3 @@
+export function isManifestApiJSType(manifest) {
+    return manifest.apiJs !== undefined;
+}

package/dist-cms/libs/extension-api/type-guards/is-manifest-apiable-type.function.d.ts

@@ -0,0 +1,2 @@
+import type { ManifestBase, ManifestApi } from '../types.js';
+export declare function isManifestApiType(manifest: ManifestBase): manifest is ManifestApi;

package/dist-cms/libs/extension-api/type-guards/is-manifest-apiable-type.function.js

@@ -0,0 +1,10 @@
+import { isManifestJSType } from './is-manifest-js-type.function.js';
+import { isManifestLoaderType } from './is-manifest-loader-type.function.js';
+import { isManifestApiConstructorType } from './is-manifest-api-instance-type.function.js';
+import { isManifestApiJSType } from './is-manifest-api-js-type.function.js';
+export function isManifestApiType(manifest) {
+    return (isManifestApiConstructorType(manifest) ||
+        isManifestLoaderType(manifest) ||
+        isManifestApiJSType(manifest) ||
+        isManifestJSType(manifest));
+}

package/dist-cms/libs/extension-api/type-guards/is-manifest-element-js-type.function.d.ts

@@ -0,0 +1,5 @@
+import type { ManifestBase, ManifestWithLoader } from '../types.js';
+export type ManifestElementJSType<T> = ManifestWithLoader<T> & {
+    elementJs: string;
+};
+export declare function isManifestElementJSType<T>(manifest: ManifestBase | unknown): manifest is ManifestElementJSType<T>;

package/dist-cms/libs/extension-api/type-guards/is-manifest-element-js-type.function.js

@@ -0,0 +1,3 @@
+export function isManifestElementJSType(manifest) {
+    return manifest.elementJs !== undefined;
+}

package/dist-cms/libs/extension-api/type-guards/is-manifest-elementable-type.function.js

@@ -1,8 +1,10 @@
+import { isManifestElementJSType } from './is-manifest-element-js-type.function.js';
 import { isManifestElementNameType } from './is-manifest-element-name-type.function.js';
 import { isManifestJSType } from './is-manifest-js-type.function.js';
 import { isManifestLoaderType } from './is-manifest-loader-type.function.js';
 export function isManifestElementableType(manifest) {
     return (isManifestElementNameType(manifest) ||
         isManifestLoaderType(manifest) ||
+        isManifestElementJSType(manifest) ||
         isManifestJSType(manifest));
 }

package/dist-cms/libs/extension-api/types.d.ts

@@ -1,5 +1,5 @@
 import type { UmbExtensionCondition } from './condition/index.js';
-import type { UmbEntryPointModule } from './entry-point.interface.js';
+import type { UmbEntryPointModule } from './models/index.js';
 export type HTMLElementConstructor<T = HTMLElement> = new (...args: any[]) => T;
 export type ClassConstructor<T = object> = new (...args: any[]) => T;
 export type ManifestTypeMap<ManifestTypes extends ManifestBase> = {
@@ -73,13 +73,15 @@ export interface ManifestWithLoader<LoaderReturnType> extends ManifestBase {
 /**
  * The type of extension such as dashboard etc...
  */
-export interface ManifestClass<ClassType = unknown> extends ManifestWithLoader<{
-    default: ClassConstructor<ClassType>;
+export interface ManifestApi<ApiType = unknown> extends ManifestWithLoader<{
+    default: ClassConstructor<ApiType>;
+} | {
+    api: ClassConstructor<ApiType>;
 }> {
     /**
      * @TJS-ignore
      */
-    readonly CLASS_TYPE?: ClassType;
+    readonly API_TYPE?: ApiType;
     /**
      * The file location of the javascript file to load
      * @TJS-required
@@ -88,23 +90,67 @@ export interface ManifestClass<ClassType = unknown> extends ManifestWithLoader<{
     /**
      * @TJS-ignore
      */
-    className?: string;
+    apiName?: string;
     /**
      * @TJS-ignore
      */
-    class?: ClassConstructor<ClassType>;
-}
-export interface ManifestClassWithClassConstructor<T = unknown> extends ManifestClass<T> {
-    class: ClassConstructor<T>;
+    api?: ClassConstructor<ApiType>;
 }
 export interface ManifestWithLoaderIncludingDefaultExport<T = unknown> extends ManifestWithLoader<{
     default: T;
+} | {
+    element: T;
 } | Omit<object, 'default'>> {
     /**
      * The file location of the javascript file to load
      */
     js?: string;
 }
+export interface ManifestWithLoaderIncludingApiExport<ApiType = unknown> extends ManifestWithLoader<{
+    api: ApiType;
+} | Omit<object, 'api'>> {
+    /**
+     * The file location of the javascript file to load
+     */
+    js?: string;
+    /**
+    * The file location of the API javascript file to load
+    */
+    apiJs?: string;
+}
+export interface ManifestWithLoaderIncludingElementExport<ElementType extends HTMLElement = HTMLElement> extends ManifestWithLoader<{
+    element: ElementType;
+} | Omit<object, 'element'>> {
+    /**
+     * The file location of the javascript file to load
+     */
+    js?: string;
+    /**
+    * The file location of the element javascript file to load
+    */
+    elementJs?: string;
+}
+export interface ManifestWithLoaderOptionalApiOrElementExport<ElementType extends HTMLElement = HTMLElement, ApiType = unknown, ClassType = {
+    element: ElementType;
+} | {
+    api: ApiType;
+} | {
+    element: ElementType;
+    api: ApiType;
+} | Omit<Omit<object, 'element'>, 'api'>> extends ManifestWithLoader<ClassType> {
+    /**
+     * The file location of the javascript file to load
+     */
+    js?: string;
+    /**
+    * The file location of the element javascript file to load
+    */
+    elementJs?: string;
+    /**
+     * The file location of the API javascript file to load
+     */
+    apiJs?: string;
+}
 export interface ManifestElement<ElementType extends HTMLElement = HTMLElement> extends ManifestWithLoader<{
     default: ClassConstructor<ElementType>;
 } | Omit<object, 'default'>> {
@@ -120,7 +166,7 @@ export interface ManifestElement<ElementType extends HTMLElement = HTMLElement>
     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
+     * Note it is NOT <my-dashboard></my-dashboard>, just the element name.
      */
     elementName?: string;
     /**
@@ -128,6 +174,29 @@ export interface ManifestElement<ElementType extends HTMLElement = HTMLElement>
      */
     meta?: unknown;
 }
+export interface ManifestElementAndApi<ElementType extends HTMLElement = HTMLElement, ApiType = unknown> extends ManifestWithLoaderOptionalApiOrElementExport<ElementType, ApiType> {
+    /**
+     * @TJS-ignore
+     */
+    readonly API_TYPE?: ApiType;
+    /**
+     * @TJS-ignore
+     */
+    readonly ELEMENT_TYPE?: ElementType;
+    /**
+     * @TJS-ignore
+     */
+    apiName?: string;
+    /**
+     * @TJS-ignore
+     */
+    api?: ClassConstructor<ApiType>;
+    /**
+     * The HTML web component name to use such as 'my-dashboard'
+     * Note it is NOT <my-dashboard></my-dashboard>, just the element name.
+     */
+    elementName?: string;
+}
 export interface ManifestWithView<ElementType extends HTMLElement = HTMLElement> extends ManifestElement<ElementType> {
     meta: MetaManifestWithView;
 }
@@ -175,7 +244,7 @@ export interface ManifestBundle<UmbManifestTypes extends ManifestBase = Manifest
 /**
  * This type of extension takes a JS module and registers all exported manifests from the pointed JS file.
  */
-export interface ManifestCondition extends ManifestClass<UmbExtensionCondition> {
+export interface ManifestCondition extends ManifestApi<UmbExtensionCondition> {
     type: 'condition';
     /**
      * The file location of the javascript file to load in the backoffice

package/dist-cms/packages/core/action/action.interface.d.ts

@@ -1,6 +1,6 @@
 import { UmbControllerHostElement } from '../../../libs/controller-api/index.js';
 export interface UmbAction<RepositoryType = unknown> {
     host: UmbControllerHostElement;
-    repository: RepositoryType;
+    repository?: RepositoryType;
     execute(): Promise<void>;
 }