@umbraco-cms/backoffice 17.2.2 → 17.3.0-rc

package/dist-cms/packages/core/extension/global-components/input-extension.element.js

@@ -0,0 +1,73 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { UmbExtensionPickerDataSource } from '../picker-data-source/extension.picker-data-source.js';
+import { html, customElement, property } from '../../../../external/lit/index.js';
+import { UmbLitElement } from '../../lit-element/index.js';
+import { UmbFormControlMixin } from '../../validation/index.js';
+import { UmbChangeEvent } from '../../event/index.js';
+let UmbInputExtensionElement = class UmbInputExtensionElement extends UmbFormControlMixin(UmbLitElement) {
+    constructor() {
+        super(...arguments);
+        this.#dataSource = new UmbExtensionPickerDataSource(this);
+        this.#dataSourceConfig = [];
+        this.min = 0;
+        this.max = Infinity;
+        this.selection = [];
+        this.readonly = false;
+    }
+    #dataSource;
+    #dataSourceConfig;
+    #allowedExtensionTypes;
+    set allowedExtensionTypes(value) {
+        this.#allowedExtensionTypes = value;
+        this.#dataSourceConfig = value?.length ? [{ alias: 'allowedExtensionTypes', value }] : [];
+    }
+    get allowedExtensionTypes() {
+        return this.#allowedExtensionTypes;
+    }
+    getFormElement() {
+        return undefined;
+    }
+    #onChange(event) {
+        event.stopPropagation();
+        // TODO: import correct type for UmbInputEntityDataElement when exported
+        const target = event.target;
+        this.selection = target.selection;
+        this.value = target.value;
+        this.dispatchEvent(new UmbChangeEvent());
+    }
+    render() {
+        return html `<umb-input-entity-data
+			.dataSourceApi=${this.#dataSource}
+			.dataSourceConfig=${this.#dataSourceConfig}
+			.value=${this.value}
+			.selection=${this.selection}
+			.min=${this.min}
+			.max=${this.max}
+			?readonly=${this.readonly}
+			@change=${this.#onChange}></umb-input-entity-data>`;
+    }
+};
+__decorate([
+    property({ type: Array, attribute: false })
+], UmbInputExtensionElement.prototype, "allowedExtensionTypes", null);
+__decorate([
+    property({ type: Number })
+], UmbInputExtensionElement.prototype, "min", void 0);
+__decorate([
+    property({ type: Number })
+], UmbInputExtensionElement.prototype, "max", void 0);
+__decorate([
+    property({ type: Array })
+], UmbInputExtensionElement.prototype, "selection", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], UmbInputExtensionElement.prototype, "readonly", void 0);
+UmbInputExtensionElement = __decorate([
+    customElement('umb-input-extension')
+], UmbInputExtensionElement);
+export { UmbInputExtensionElement };

package/dist-cms/packages/core/extension/index.d.ts

@@ -0,0 +1,5 @@
+export * from './collection/index.js';
+export * from './global-components/index.js';
+export * from './entity.js';
+export * from './item/index.js';
+export type * from './types.js';

package/dist-cms/packages/core/extension/index.js

@@ -0,0 +1,4 @@
+export * from './collection/index.js';
+export * from './global-components/index.js';
+export * from './entity.js';
+export * from './item/index.js';

package/dist-cms/packages/core/extension/item/data/index.d.ts

@@ -0,0 +1,2 @@
+export { UMB_EXTENSION_ITEM_STORE_CONTEXT } from './item.store.context-token.js';
+export { UmbExtensionItemRepository } from './item.repository.js';

package/dist-cms/packages/core/extension/item/data/index.js

@@ -0,0 +1,2 @@
+export { UMB_EXTENSION_ITEM_STORE_CONTEXT } from './item.store.context-token.js';
+export { UmbExtensionItemRepository } from './item.repository.js';

package/dist-cms/packages/core/extension/item/data/item.data-source.d.ts

@@ -0,0 +1,7 @@
+import type { UmbExtensionItemModel } from './types.js';
+import type { UmbItemDataSource } from '../../../repository/index.js';
+export declare class UmbExtensionItemDataSource implements UmbItemDataSource<UmbExtensionItemModel> {
+    getItems(uniques: Array<string>): Promise<{
+        data: UmbExtensionItemModel[];
+    }>;
+}

package/dist-cms/packages/core/extension/item/data/item.data-source.js

@@ -0,0 +1,24 @@
+import { UMB_EXTENSION_ENTITY_TYPE } from '../../entity.js';
+import { umbExtensionsRegistry } from '../../../extension-registry/index.js';
+export class UmbExtensionItemDataSource {
+    async getItems(uniques) {
+        const extensions = umbExtensionsRegistry.getAllExtensions();
+        const data = extensions
+            .filter((manifest) => uniques.includes(manifest.alias))
+            .map((manifest) => ({
+            entityType: UMB_EXTENSION_ENTITY_TYPE,
+            unique: manifest.alias,
+            name: manifest.name,
+            description: manifest.alias,
+            icon: 'icon-plugin',
+            manifest: {
+                type: manifest.type,
+                alias: manifest.alias,
+                name: manifest.name,
+                weight: manifest.weight,
+                kind: manifest.kind,
+            },
+        }));
+        return { data };
+    }
+}

package/dist-cms/packages/core/extension/item/data/item.repository.d.ts

@@ -0,0 +1,7 @@
+import type { UmbExtensionItemModel } from './types.js';
+import type { UmbControllerHost } from '../../../../../libs/controller-api/index.js';
+import { UmbItemRepositoryBase } from '../../../repository/index.js';
+export declare class UmbExtensionItemRepository extends UmbItemRepositoryBase<UmbExtensionItemModel> {
+    constructor(host: UmbControllerHost);
+}
+export { UmbExtensionItemRepository as api };

package/dist-cms/packages/core/extension/item/data/item.repository.js

@@ -0,0 +1,9 @@
+import { UmbExtensionItemDataSource } from './item.data-source.js';
+import { UMB_EXTENSION_ITEM_STORE_CONTEXT } from './item.store.context-token.js';
+import { UmbItemRepositoryBase } from '../../../repository/index.js';
+export class UmbExtensionItemRepository extends UmbItemRepositoryBase {
+    constructor(host) {
+        super(host, UmbExtensionItemDataSource, UMB_EXTENSION_ITEM_STORE_CONTEXT);
+    }
+}
+export { UmbExtensionItemRepository as api };

package/dist-cms/packages/core/extension/item/data/item.store.context-token.d.ts

@@ -0,0 +1,3 @@
+import type { UmbExtensionItemStore } from './item.store.js';
+import { UmbContextToken } from '../../../../../libs/context-api/index.js';
+export declare const UMB_EXTENSION_ITEM_STORE_CONTEXT: UmbContextToken<UmbExtensionItemStore, UmbExtensionItemStore>;

package/dist-cms/packages/core/extension/item/data/item.store.context-token.js

@@ -0,0 +1,2 @@
+import { UmbContextToken } from '../../../../../libs/context-api/index.js';
+export const UMB_EXTENSION_ITEM_STORE_CONTEXT = new UmbContextToken('UmbExtensionItemStore');

package/dist-cms/packages/core/extension/item/data/item.store.d.ts

@@ -0,0 +1,17 @@
+import type { UmbExtensionItemModel } from './types.js';
+import type { UmbControllerHost } from '../../../../../libs/controller-api/index.js';
+import { UmbItemStoreBase } from '../../../store/index.js';
+/**
+ * @class UmbExtensionItemStore
+ * @augments {UmbStoreBase}
+ * @description - Data Store for Extension items
+ */
+export declare class UmbExtensionItemStore extends UmbItemStoreBase<UmbExtensionItemModel> {
+    /**
+     * Creates an instance of UmbExtensionItemStore.
+     * @param {UmbControllerHost} host - The controller host for this controller to be appended to
+     * @memberof UmbExtensionItemStore
+     */
+    constructor(host: UmbControllerHost);
+}
+export { UmbExtensionItemStore as api };

package/dist-cms/packages/core/extension/item/data/item.store.js

@@ -0,0 +1,18 @@
+import { UMB_EXTENSION_ITEM_STORE_CONTEXT } from './item.store.context-token.js';
+import { UmbItemStoreBase } from '../../../store/index.js';
+/**
+ * @class UmbExtensionItemStore
+ * @augments {UmbStoreBase}
+ * @description - Data Store for Extension items
+ */
+export class UmbExtensionItemStore extends UmbItemStoreBase {
+    /**
+     * Creates an instance of UmbExtensionItemStore.
+     * @param {UmbControllerHost} host - The controller host for this controller to be appended to
+     * @memberof UmbExtensionItemStore
+     */
+    constructor(host) {
+        super(host, UMB_EXTENSION_ITEM_STORE_CONTEXT.toString());
+    }
+}
+export { UmbExtensionItemStore as api };

package/dist-cms/packages/core/extension/item/data/manifests.d.ts

@@ -0,0 +1 @@
+export declare const manifests: Array<UmbExtensionManifest>;

package/dist-cms/packages/core/extension/item/data/manifests.js

@@ -0,0 +1,15 @@
+import { UmbExtensionItemStore } from './item.store.js';
+export const manifests = [
+    {
+        type: 'repository',
+        alias: 'Umb.Repository.ExtensionItem',
+        name: 'Extension Item Repository',
+        api: () => import('./item.repository.js'),
+    },
+    {
+        type: 'itemStore',
+        alias: 'Umb.Store.ExtensionItem',
+        name: 'Extension Item Store',
+        api: UmbExtensionItemStore,
+    },
+];

package/dist-cms/packages/core/extension/item/data/types.d.ts

@@ -0,0 +1,6 @@
+import type { UmbItemModel } from '../../../entity-item/index.js';
+import type { ManifestBase } from '../../../../../libs/extension-api/index.js';
+import type { UmbWithDescriptionModel } from '../../../models/index.js';
+export interface UmbExtensionItemModel extends UmbItemModel, UmbWithDescriptionModel {
+    manifest: ManifestBase;
+}

package/dist-cms/packages/core/extension/item/data/types.js

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

package/dist-cms/packages/core/extension/item/index.d.ts

@@ -0,0 +1 @@
+export * from './data/index.js';

package/dist-cms/packages/core/extension/item/index.js

@@ -0,0 +1 @@
+export * from './data/index.js';

package/dist-cms/packages/core/extension/item/manifests.d.ts

@@ -0,0 +1 @@
+export declare const manifests: Array<UmbExtensionManifest>;

package/dist-cms/packages/core/extension/item/manifests.js

@@ -0,0 +1,2 @@
+import { manifests as dataManifests } from './data/manifests.js';
+export const manifests = [...dataManifests];

package/dist-cms/packages/core/extension/item/types.d.ts

@@ -0,0 +1 @@
+export type * from './data/types.js';

package/dist-cms/packages/core/extension/item/types.js

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

package/dist-cms/packages/core/extension/manifests.d.ts

@@ -0,0 +1 @@
+export declare const manifests: Array<UmbExtensionManifest>;

package/dist-cms/packages/core/extension/manifests.js

@@ -0,0 +1,8 @@
+import { manifests as collectionManifests } from './collection/manifests.js';
+import { manifests as unregisterManifests } from './unregister/manifests.js';
+import { manifests as itemManifests } from './item/manifests.js';
+export const manifests = [
+    ...collectionManifests,
+    ...unregisterManifests,
+    ...itemManifests,
+];

package/dist-cms/packages/core/extension/picker-data-source/extension.picker-data-source.d.ts

@@ -0,0 +1,29 @@
+import type { UmbExtensionCollectionFilterModel, UmbExtensionCollectionItemModel } from '../collection/types.js';
+import type { UmbExtensionPickerDataSourceConfigCollectionModel } from './types.js';
+import type { UmbPickerCollectionDataSource, UmbPickerCollectionDataSourceTextFilterFeature } from '../../picker-data-source/index.js';
+import { UmbControllerBase } from '../../../../libs/class-api/index.js';
+import { type UmbConfigCollectionModel } from '../../utils/index.js';
+export declare class UmbExtensionPickerDataSource extends UmbControllerBase implements UmbPickerCollectionDataSource<UmbExtensionCollectionItemModel> {
+    #private;
+    readonly features: {
+        supportsTextFilter: import("rxjs").Observable<UmbPickerCollectionDataSourceTextFilterFeature>;
+    };
+    setConfig(config: UmbExtensionPickerDataSourceConfigCollectionModel | undefined): void;
+    getConfig(): UmbConfigCollectionModel | undefined;
+    requestCollection(args: UmbExtensionCollectionFilterModel): Promise<{
+        data: {
+            items: UmbExtensionCollectionItemModel[];
+            total: number;
+        };
+    }>;
+    requestItems(uniques: Array<string>): Promise<{
+        asObservable: () => undefined;
+        data?: undefined;
+        error?: undefined;
+    } | {
+        data: import("../types.js").UmbExtensionItemModel[] | undefined;
+        error: Error | import("../../resources/umb-error.js").UmbApiError | import("../../resources/umb-error.js").UmbCancelError | import("../../resources/umb-error.js").UmbError | undefined;
+        asObservable: () => import("rxjs").Observable<import("../types.js").UmbExtensionItemModel[]> | undefined;
+    }>;
+}
+export { UmbExtensionPickerDataSource as api };

package/dist-cms/packages/core/extension/picker-data-source/extension.picker-data-source.js

@@ -0,0 +1,54 @@
+import { UmbExtensionCollectionRepository } from '../collection/repository/extension-collection.repository.js';
+import { UmbExtensionItemRepository } from '../item/data/item.repository.js';
+import { UmbControllerBase } from '../../../../libs/class-api/index.js';
+import { UmbObjectState } from '../../../../libs/observable-api/index.js';
+import { getConfigValue } from '../../utils/index.js';
+export class UmbExtensionPickerDataSource extends UmbControllerBase {
+    constructor() {
+        super(...arguments);
+        this.#collectionRepository = new UmbExtensionCollectionRepository(this);
+        this.#itemRepository = new UmbExtensionItemRepository(this);
+        this.#supportsTextFilter = new UmbObjectState({ enabled: true });
+        this.features = {
+            supportsTextFilter: this.#supportsTextFilter.asObservable(),
+        };
+    }
+    #collectionRepository;
+    #itemRepository;
+    #config;
+    #supportsTextFilter;
+    setConfig(config) {
+        this.#config = config;
+    }
+    getConfig() {
+        return this.#config;
+    }
+    async requestCollection(args) {
+        const configAllowedExtensionTypes = getConfigValue(this.#config, 'allowedExtensionTypes');
+        const requestedTypes = args.extensionTypes;
+        let extensionTypes;
+        if (configAllowedExtensionTypes?.length) {
+            if (requestedTypes?.length) {
+                // If the UI requests specific types, only use those that are in the allowed list
+                extensionTypes = requestedTypes.filter((t) => configAllowedExtensionTypes.includes(t));
+            }
+            else {
+                // No specific types requested — use all allowed types
+                extensionTypes = configAllowedExtensionTypes;
+            }
+        }
+        else {
+            // No config restriction — pass through whatever the caller requested
+            extensionTypes = requestedTypes;
+        }
+        const extendedArgs = {
+            ...args,
+            extensionTypes,
+        };
+        return this.#collectionRepository.requestCollection(extendedArgs);
+    }
+    async requestItems(uniques) {
+        return this.#itemRepository.requestItems(uniques);
+    }
+}
+export { UmbExtensionPickerDataSource as api };

package/dist-cms/packages/core/extension/picker-data-source/index.d.ts

@@ -0,0 +1 @@
+export { UmbExtensionPickerDataSource } from './extension.picker-data-source.js';

package/dist-cms/packages/core/extension/picker-data-source/index.js

@@ -0,0 +1 @@
+export { UmbExtensionPickerDataSource } from './extension.picker-data-source.js';

package/dist-cms/packages/core/extension/picker-data-source/types.d.ts

@@ -0,0 +1,4 @@
+export type UmbExtensionPickerDataSourceConfigCollectionModel = Array<{
+    alias: 'allowedExtensionTypes';
+    value: Array<string>;
+}>;

package/dist-cms/packages/core/extension/picker-data-source/types.js

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

package/dist-cms/packages/core/extension/types.d.ts

@@ -0,0 +1,2 @@
+export type * from './collection/types.js';
+export type * from './item/types.js';

package/dist-cms/packages/core/extension/types.js

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

package/dist-cms/packages/{extension-insights/entity-actions/unregister → core/extension/unregister/entity-action}/unregister-extension.action.d.ts

@@ -1,4 +1,4 @@
-import { UmbEntityActionBase } from '../../../core/entity-action/index.js';
+import { UmbEntityActionBase } from '../../../entity-action/index.js';
 export declare class UmbUnregisterExtensionEntityAction extends UmbEntityActionBase<unknown> {
     execute(): Promise<void>;
 }

package/dist-cms/packages/{extension-insights/entity-actions/unregister → core/extension/unregister/entity-action}/unregister-extension.action.js

@@ -1,8 +1,8 @@
-import { umbExtensionsRegistry } from '../../../core/extension-registry/index.js';
-import { UMB_ACTION_EVENT_CONTEXT } from '../../../core/action/index.js';
-import { UmbEntityActionBase, UmbRequestReloadStructureForEntityEvent } from '../../../core/entity-action/index.js';
-import { umbConfirmModal } from '../../../core/modal/index.js';
-import { html } from '../../../../external/lit/index.js';
+import { umbExtensionsRegistry } from '../../../extension-registry/index.js';
+import { UMB_ACTION_EVENT_CONTEXT } from '../../../action/index.js';
+import { UmbEntityActionBase, UmbRequestReloadStructureForEntityEvent } from '../../../entity-action/index.js';
+import { umbConfirmModal } from '../../../modal/index.js';
+import { html } from '../../../../../external/lit/index.js';
 export class UmbUnregisterExtensionEntityAction extends UmbEntityActionBase {
     async execute() {
         if (!this.args.unique)

package/dist-cms/packages/{extension-insights/entity-actions → core/extension/unregister}/manifests.d.ts

@@ -3,7 +3,7 @@ export declare const manifests: {
     kind: string;
     alias: string;
     name: string;
-    api: () => Promise<typeof import("./unregister/unregister-extension.action.js")>;
+    api: () => Promise<typeof import("./entity-action/unregister-extension.action.js")>;
     forEntityTypes: string[];
     meta: {
         label: string;

package/dist-cms/packages/core/extension/unregister/manifests.js

@@ -0,0 +1,2 @@
+import { manifests as entityActionManifests } from './entity-action/manifests.js';
+export const manifests = [...entityActionManifests];

package/dist-cms/packages/core/extension-registry/components/extension-slot/extension-slot.element.d.ts

@@ -3,51 +3,201 @@ import { nothing } from '../../../../../external/lit/index.js';
 import { type UmbExtensionElementInitializer } from '../../../../../libs/extension-api/index.js';
 import { UmbLitElement } from '../../../lit-element/index.js';
 /**
+ * A custom element that dynamically renders extensions registered in the extension registry.
+ *
+ * This element observes the extension registry and renders all permitted extensions matching the specified type(s).
+ * Extensions are automatically filtered by their conditions and can be further filtered using the `filter` property.
+ * The element handles extension lifecycle, property passing, and event binding.
  * @element umb-extension-slot
- * @description A element which renderers the extensions of a given type or types.
- * @slot default - slot for inserting additional things into this slot.
- * @class UmbExtensionSlot
- * @augments {UmbLitElement}
+ * @slot default - Fallback content shown when no extensions are permitted (unless `fallbackRenderMethod` is provided).
+ * @example Basic usage - Render all extensions of a type
+ * ```html
+ * <umb-extension-slot type="workspaceFooterApp"></umb-extension-slot>
+ * ```
+ * @example Multiple types - Render extensions from multiple types
+ * ```html
+ * <umb-extension-slot .type=${['headerApp', 'headerAppButton']}></umb-extension-slot>
+ * ```
+ * @example Single extension - Only render the first matching extension
+ * ```html
+ * <umb-extension-slot type="menu" single></umb-extension-slot>
+ * ```
+ * @example With filter - Filter extensions by manifest properties
+ * ```html
+ * <umb-extension-slot
+ *     type="menu"
+ *     .filter=${(manifest) => manifest.alias === 'My.Menu.Alias'}>
+ * </umb-extension-slot>
+ * ```
+ * @example With props - Pass data to extension elements
+ * ```html
+ * <umb-extension-slot
+ *     type="searchResultItem"
+ *     .props=${{ item: searchResult }}>
+ * </umb-extension-slot>
+ * ```
+ * @example With default element - Specify fallback element for extensions without one
+ * ```html
+ * <umb-extension-slot
+ *     type="menu"
+ *     default-element="umb-menu">
+ * </umb-extension-slot>
+ * ```
+ * @example Combined usage - Filter, props, default element, and single
+ * ```html
+ * <umb-extension-slot
+ *     type="searchResultItem"
+ *     single
+ *     .filter=${(manifest) => manifest.forEntityTypes.includes(item.entityType)}
+ *     .props=${{ item }}
+ *     default-element="umb-search-result-item">
+ * </umb-extension-slot>
+ * ```
+ * @example Custom render method - Control how extensions are rendered
+ * ```html
+ * <umb-extension-slot
+ *     type="blockEditorCustomView"
+ *     single
+ *     .filter=${this.#extensionSlotFilterMethod}
+ *     .renderMethod=${(ext, index) => html`<div class="wrapper">${ext.component}</div>`}
+ *     .props=${this._blockViewProps}>
+ * </umb-extension-slot>
+ * ```
+ * @example Fallback content - Shows the slotted content when no extensions match
+ * ```html
+ * <umb-extension-slot type="myExtensionType">
+ *     <p>No extensions available</p>
+ * </umb-extension-slot>
+ * ```
+ * @example Fallback render method - Shows the result of the fallbackRenderMethod when no extensions match
+ * ```html
+ * <umb-extension-slot type="myExtensionType">
+ *     .fallbackRenderMethod=${() => html`<p>No extensions available</p>`}
+ * </umb-extension-slot>
+ * ```
  */
 export declare class UmbExtensionSlotElement extends UmbLitElement {
     #private;
     private _permitted?;
-    single?: boolean;
     /**
-     * The type or types of extensions to render.
-     * @type {string | string[]}
-     * @memberof UmbExtensionSlot
+     * When true, only renders the highest weighted permitted extension.
+     * Useful for extension types where only one instance should be displayed (e.g., menus).
      * @example
-     * <umb-extension-slot type="my-extension-type"></umb-extension-slot>
-     * or multiple:
+     * ```html
+     * <umb-extension-slot type="menu" single></umb-extension-slot>
+     * ```
+     */
+    single?: boolean;
+    /**
+     * The type or types of extensions to render. Required for the slot to display anything.
+     * Can be a single type string or an array of type strings to render extensions from multiple types.
+     * @example Single type
+     * ```html
+     * <umb-extension-slot type="workspaceFooterApp"></umb-extension-slot>
+     * ```
+     * @example Multiple types
+     * ```html
      * <umb-extension-slot .type=${['my-extension-type','another-extension-type']}></umb-extension-slot>
+     * ```
      */
     set type(value: string | string[] | undefined);
     get type(): string | string[] | undefined;
     /**
-     * Filter method for extension manifests.
-     * This is an initial filter taking effect before conditions or overwrites, the extensions will still be filtered by the conditions defined in the manifest.
-     * @type {(manifest: any) => boolean}
-     * @memberof UmbExtensionSlot
-     * @example
-     * <umb-extension-slot type="my-extension-type" .filter=${(ext) => ext.meta.anyPropToFilter === 'foo'}></umb-extension-slot>
+     * Filter function for extension manifests.
+     * This is an initial filter taking effect before conditions or overwrites are applied.
+     * Extensions will still be filtered by their manifest-defined conditions after this filter.
+     * The filter function receives the extension manifest and should return true to include it.
+     * @example Filter by manifest alias
+     * ```html
+     * <umb-extension-slot
+     *     type="menu"
+     *     .filter=${(manifest) => manifest.alias === 'My.Menu.Alias'}>
+     * </umb-extension-slot>
+     * ```
+     * @example Filter by meta properties
+     * ```html
+     * <umb-extension-slot
+     *     type="searchResultItem"
+     *     .filter=${(manifest) => manifest.forEntityTypes.includes(entityType)}>
+     * </umb-extension-slot>
+     * ```
      */
     set filter(value: (manifest: any) => boolean);
     get filter(): (manifest: any) => boolean;
     /**
-     * Properties to pass to the extensions elements.
-     * Notice: The individual manifest of the extension is parsed to each extension element no matter if this is set or not.
-     * @type {Record<string, any>}
-     * @memberof UmbExtensionSlot
-     * @example
-     * <umb-extension-slot type="my-extension-type" .props=${{foo: 'bar'}}></umb-extension-slot>
+     * Properties to pass to all rendered extension elements.
+     * These properties are spread onto each extension element instance.
+     * Note: The extension's manifest is always passed automatically regardless of this setting.
+     * @example Pass data to extension elements
+     * ```html
+     * <umb-extension-slot
+     *     type="searchResultItem"
+     *     .props=${{ item: searchResult, showDetails: true }}>
+     * </umb-extension-slot>
+     * ```
      */
     set props(newVal: Record<string, unknown> | undefined);
     get props(): Record<string, unknown> | undefined;
+    /**
+     * Event listeners to attach to all rendered extension elements.
+     * The key is the event name, and the value is the event handler function.
+     * Listeners are automatically added when extensions are rendered and removed on disconnect.
+     * @example Listen for custom events from extensions
+     * ```html
+     * <umb-extension-slot
+     *     type="myExtensionType"
+     *     .events=${{
+     *         'item-selected': (e) => this.#handleItemSelected(e),
+     *         'action-clicked': (e) => this.#handleAction(e)
+     *     }}>
+     * </umb-extension-slot>
+     * ```
+     */
     set events(newVal: Record<string, (event: Event) => void> | undefined);
     get events(): Record<string, (event: Event) => void> | undefined;
+    /**
+     * Fallback element tag name to use when an extension manifest doesn't specify its own element.
+     * This allows extensions to rely on a default UI implementation while still being registered.
+     * @example Provide a default menu element
+     * ```html
+     * <umb-extension-slot
+     *     type="menu"
+     *     default-element="umb-menu">
+     * </umb-extension-slot>
+     * ```
+     */
     defaultElement?: string;
+    /**
+     * Custom render function for controlling how each extension is rendered.
+     * When provided, this function is called for each permitted extension instead of the default rendering.
+     * The function receives the extension initializer (with `component` and `manifest` properties) and the index,
+     * and should return a TemplateResult, HTMLElement, null, or nothing.
+     * @example Wrap extensions in custom markup
+     * ```html
+     * <umb-extension-slot
+     *     type="blockEditorCustomView"
+     *     .renderMethod=${(ext, index) => html`
+     *         <div class="block-wrapper" data-index=${index}>
+     *             ${ext.component}
+     *         </div>
+     *     `}>
+     * </umb-extension-slot>
+     * ```
+     */
     renderMethod?: (extension: UmbExtensionElementInitializer, index: number) => TemplateResult | TemplateResult<1> | HTMLElement | null | undefined | typeof nothing;
+    /**
+     * Render function called when no extensions are permitted.
+     * When provided, this function is called instead of rendering the default slot content.
+     * Useful for providing custom empty states or fallback UI.
+     * The function should return a TemplateResult, HTMLElement, null, or nothing.
+     * @example Custom empty state
+     * ```html
+     * <umb-extension-slot
+     *     type="blockEditorCustomView"
+     *     .fallbackRenderMethod=${() => html`<div class="default-view">Default block view</div>`}>
+     * </umb-extension-slot>
+     * ```
+     */
     fallbackRenderMethod?: () => TemplateResult | TemplateResult<1> | HTMLElement | null | undefined | typeof nothing;
     connectedCallback(): void;
     disconnectedCallback(): void;