@umbraco-cms/backoffice 17.2.2 → 17.3.0-rc

package/dist-cms/packages/content/content/audit-log/info-app/types.d.ts

@@ -0,0 +1,14 @@
+import type { ManifestWorkspaceInfoApp, MetaWorkspaceInfoApp } from '../../../../core/workspace/index.js';
+export type { UmbAuditLogTagData, UmbAuditLogTagLocalizeKeys, UmbAuditLogTagStyleMap, } from '../../../../core/audit-log/index.js';
+export interface MetaWorkspaceInfoAppAuditLogKind extends MetaWorkspaceInfoApp {
+    auditLogRepositoryAlias: string;
+}
+export interface ManifestWorkspaceInfoAppAuditLogKind extends ManifestWorkspaceInfoApp<MetaWorkspaceInfoAppAuditLogKind> {
+    type: 'workspaceInfoApp';
+    kind: 'auditLog';
+}
+declare global {
+    interface UmbExtensionManifestMap {
+        umbManifestWorkspaceInfoAppAuditLogKind: ManifestWorkspaceInfoAppAuditLogKind;
+    }
+}

package/dist-cms/packages/content/content/audit-log/info-app/types.js

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

package/dist-cms/packages/content/content/audit-log/manifests.d.ts

@@ -0,0 +1,2 @@
+import type { UmbExtensionManifestKind } from '../../../core/extension-registry/index.js';
+export declare const manifests: Array<UmbExtensionManifest | UmbExtensionManifestKind>;

package/dist-cms/packages/content/content/audit-log/manifests.js

@@ -0,0 +1,6 @@
+import { manifests as auditLogActionManifests } from './audit-log-action/manifests.js';
+import { manifests as infoAppManifests } from './info-app/manifests.js';
+export const manifests = [
+    ...auditLogActionManifests,
+    ...infoAppManifests,
+];

package/dist-cms/packages/content/content/collection/manager/content-collection-manager.controller.js

@@ -38,6 +38,7 @@ export class UmbContentCollectionManager extends UmbControllerBase {
         if (!dataType) {
             this.#collectionConfig.setValue(undefined);
             this.#manifestOverrides.setValue(undefined);
+            this.removeUmbControllerByAlias('_observeHostUnique');
             return;
         }
         const config = new UmbPropertyEditorConfigCollection(dataType.values);
@@ -50,6 +51,12 @@ export class UmbContentCollectionManager extends UmbControllerBase {
             pageSize: isNaN(pageSize) ? 50 : pageSize,
             userDefinedProperties: config?.getValueByAlias('includeProperties'),
         });
+        // Observe the workspace unique so the collection config stays in sync
+        // when unique is set after initial config creation (e.g. during createScaffold).
+        // Only observing when a config is set.
+        this.observe(this.#host.unique, (unique) => {
+            this.#collectionConfig.update({ unique });
+        }, '_observeHostUnique');
         const overrides = {
             alias: 'Umb.WorkspaceView.Content.Collection',
             meta: {},

package/dist-cms/packages/content/content/components/property-type-based-property/property-type-based-property.context.d.ts

@@ -3,9 +3,7 @@ import { UmbContextBase } from '../../../../../libs/class-api/index.js';
 import type { UmbPropertyTypeModel } from '../../../content-type/index.js';
 export declare class UmbPropertyTypeBasedPropertyContext extends UmbContextBase {
     #private;
-    dataType: import("rxjs").Observable<{
-        unique: string;
-    } | undefined>;
+    dataType: import("rxjs").Observable<import("../../../../core/models/index.js").UmbReferenceByUnique | undefined>;
     constructor(host: UmbControllerHost);
     setDataType(dataType: UmbPropertyTypeModel['dataType'] | undefined): void;
 }

package/dist-cms/packages/content/content/components/property-type-based-property/property-type-based-property.element.d.ts

@@ -1,10 +1,14 @@
 import { UmbLitElement } from '../../../../core/lit-element/index.js';
+import type { UmbDataTypeDetailModel } from '../../../../data-type/index.js';
 import type { UmbPropertyTypeModel } from '../../../content-type/index.js';
 export declare class UmbPropertyTypeBasedPropertyElement extends UmbLitElement {
     #private;
-    set property(value: UmbPropertyTypeModel | undefined);
-    get property(): UmbPropertyTypeModel | undefined;
-    private _property?;
+    property?: UmbPropertyTypeModel;
+    /**
+     * Optional pre-loaded data type detail. When provided, the element uses this directly instead of loading individually.
+     * @type {UmbDataTypeDetailModel}
+     */
+    dataTypeDetail?: UmbDataTypeDetailModel;
     dataPath?: string;
     get ownerEntityType(): string | undefined;
     set ownerEntityType(value: string | undefined);
@@ -23,7 +27,7 @@ export declare class UmbPropertyTypeBasedPropertyElement extends UmbLitElement {
     private _dataTypeDetailRepository;
     private _dataTypeObserver?;
     private _checkSchemaSupport;
-    private _observeDataType;
+    willUpdate(changedProperties: Map<string, unknown>): void;
     render(): import("lit-html").TemplateResult<1> | undefined;
     static styles: import("lit").CSSResult[];
 }

package/dist-cms/packages/content/content/components/property-type-based-property/property-type-based-property.element.js

@@ -23,16 +23,6 @@ let UmbPropertyTypeBasedPropertyElement = class UmbPropertyTypeBasedPropertyElem
         this._dataTypeDetailRepository = new UmbDataTypeDetailRepository(this);
         this.#context = new UmbPropertyTypeBasedPropertyContext(this);
     }
-    set property(value) {
-        const oldProperty = this._property;
-        this._property = value;
-        if (this._property?.dataType.unique !== oldProperty?.dataType.unique) {
-            this._observeDataType(this._property?.dataType.unique);
-        }
-    }
-    get property() {
-        return this._property;
-    }
     get ownerEntityType() {
         return this._ownerEntityType;
     }
@@ -41,6 +31,7 @@ let UmbPropertyTypeBasedPropertyElement = class UmbPropertyTypeBasedPropertyElem
         this._ownerEntityType = value;
     }
     #context;
+    #lastDataTypeUnique;
     async _checkSchemaSupport() {
         if (!this._ownerEntityType || !this._propertyEditorSchemaAlias)
             return;
@@ -49,55 +40,73 @@ let UmbPropertyTypeBasedPropertyElement = class UmbPropertyTypeBasedPropertyElem
             this._isUnsupported = UMB_UNSUPPORTED_EDITOR_SCHEMA_ALIASES[this._ownerEntityType].includes(this._propertyEditorSchemaAlias);
         }
     }
-    async _observeDataType(dataTypeUnique) {
-        this._dataTypeObserver?.destroy();
-        if (dataTypeUnique) {
-            // Its not technically needed to have await here, this is only to ensure that the data is loaded before we observe it, and thereby only updating the DOM with the latest data.
-            await this._dataTypeDetailRepository.requestByUnique(dataTypeUnique);
-            this._dataTypeObserver = this.observe(await this._dataTypeDetailRepository.byUnique(dataTypeUnique), (dataType) => {
-                const contextValue = dataType ? { unique: dataType.unique } : undefined;
-                this.#context.setDataType(contextValue);
-                this._dataTypeValues = dataType?.values;
-                this._propertyEditorUiAlias = dataType?.editorUiAlias || undefined;
-                this._propertyEditorSchemaAlias = dataType?.editorAlias || undefined;
-                this._propertyEditorDataSourceAlias = dataType?.editorDataSourceAlias || undefined;
-                this._checkSchemaSupport();
-                // If there is no UI, we will look up the Property editor model to find the default UI alias:
-                if (!this._propertyEditorUiAlias && dataType?.editorAlias) {
-                    //use 'dataType.editorAlias' to look up the extension in the registry:
-                    // TODO: lets implement a way to observe once. [NL]
-                    this.observe(umbExtensionsRegistry.byTypeAndAlias('propertyEditorSchema', dataType.editorAlias), (extension) => {
-                        if (!extension)
-                            return;
-                        this._propertyEditorUiAlias = extension?.meta.defaultPropertyEditorUiAlias;
-                        this.removeUmbControllerByAlias('_observePropertyEditorSchema');
-                    }, '_observePropertyEditorSchema');
+    willUpdate(changedProperties) {
+        super.willUpdate(changedProperties);
+        if (changedProperties.has('property') || changedProperties.has('dataTypeDetail')) {
+            const propertyDataTypeUnique = this.property?.dataType.unique;
+            if (propertyDataTypeUnique !== this.#lastDataTypeUnique || changedProperties.has('dataTypeDetail')) {
+                this.#lastDataTypeUnique = propertyDataTypeUnique;
+                if (this.dataTypeDetail && propertyDataTypeUnique && this.dataTypeDetail.unique === propertyDataTypeUnique) {
+                    // Use provided data type detail directly — no API call needed
+                    this._dataTypeObserver?.destroy();
+                    this.#applyDataType(this.dataTypeDetail);
                 }
-                else {
-                    this.removeUmbControllerByAlias('_observePropertyEditorSchema');
+                else if (propertyDataTypeUnique) {
+                    // Fall back to individual loading
+                    this.#observeDataType(propertyDataTypeUnique);
                 }
-            }, '_observeDataType');
+            }
+        }
+    }
+    async #observeDataType(dataTypeUnique) {
+        this._dataTypeObserver?.destroy();
+        await this._dataTypeDetailRepository.requestByUnique(dataTypeUnique);
+        this._dataTypeObserver = this.observe(await this._dataTypeDetailRepository.byUnique(dataTypeUnique), (dataTypeDetail) => {
+            this.#applyDataType(dataTypeDetail);
+        }, '_observeDataType');
+    }
+    #applyDataType(dataType) {
+        const contextValue = dataType ? { unique: dataType.unique } : undefined;
+        this.#context.setDataType(contextValue);
+        this._dataTypeValues = dataType?.values;
+        this._propertyEditorUiAlias = dataType?.editorUiAlias || undefined;
+        this._propertyEditorSchemaAlias = dataType?.editorAlias || undefined;
+        this._propertyEditorDataSourceAlias = dataType?.editorDataSourceAlias || undefined;
+        this._checkSchemaSupport();
+        // If there is no UI, we will look up the Property editor model to find the default UI alias:
+        if (!this._propertyEditorUiAlias && dataType?.editorAlias) {
+            //use 'dataType.editorAlias' to look up the extension in the registry:
+            // TODO: lets implement a way to observe once. [NL]
+            this.observe(umbExtensionsRegistry.byTypeAndAlias('propertyEditorSchema', dataType.editorAlias), (extension) => {
+                if (!extension)
+                    return;
+                this._propertyEditorUiAlias = extension?.meta.defaultPropertyEditorUiAlias;
+                this.removeUmbControllerByAlias('_observePropertyEditorSchema');
+            }, '_observePropertyEditorSchema');
+        }
+        else {
+            this.removeUmbControllerByAlias('_observePropertyEditorSchema');
         }
     }
     render() {
-        if (!this._propertyEditorUiAlias || !this._property?.alias)
+        if (!this._propertyEditorUiAlias || !this.property?.alias)
             return;
         if (this._isUnsupported) {
             return html `<umb-unsupported-property
-				.alias=${this._property.alias}
+				.alias=${this.property.alias}
 				.schema=${this._propertyEditorSchemaAlias}></umb-unsupported-property>`;
         }
         return html `
 			<umb-property
 				.dataPath=${this.dataPath}
-				.alias=${this._property.alias}
-				.label=${this._property.name}
-				.description=${this._property.description ?? undefined}
-				.appearance=${this._property.appearance}
+				.alias=${this.property.alias}
+				.label=${this.property.name}
+				.description=${this.property.description ?? undefined}
+				.appearance=${this.property.appearance}
 				property-editor-ui-alias=${ifDefined(this._propertyEditorUiAlias)}
 				property-editor-data-source-alias=${ifDefined(this._propertyEditorDataSourceAlias)}
 				.config=${this._dataTypeValues}
-				.validation=${this._property.validation}
+				.validation=${this.property.validation}
 				?readonly=${this.readonly}>
 			</umb-property>
 		`;
@@ -113,7 +122,10 @@ let UmbPropertyTypeBasedPropertyElement = class UmbPropertyTypeBasedPropertyElem
 };
 __decorate([
     property({ type: Object, attribute: false })
-], UmbPropertyTypeBasedPropertyElement.prototype, "property", null);
+], UmbPropertyTypeBasedPropertyElement.prototype, "property", void 0);
+__decorate([
+    property({ attribute: false })
+], UmbPropertyTypeBasedPropertyElement.prototype, "dataTypeDetail", void 0);
 __decorate([
     property({ type: String, attribute: 'data-path' })
 ], UmbPropertyTypeBasedPropertyElement.prototype, "dataPath", void 0);

package/dist-cms/packages/content/content/global-components/content-workspace-property.element.d.ts

@@ -11,6 +11,7 @@ export declare class UmbContentWorkspacePropertyElement extends UmbLitElement {
     private _writeable?;
     private _workspaceContext?;
     private _propertyType?;
+    private _dataTypeDetail?;
     private _hasAccessToSensitiveData;
     constructor();
     willUpdate(changedProperties: Map<string, any>): void;

package/dist-cms/packages/content/content/global-components/content-workspace-property.element.js

@@ -48,6 +48,14 @@ let UmbContentWorkspacePropertyElement = class UmbContentWorkspacePropertyElemen
     }
     willUpdate(changedProperties) {
         super.willUpdate(changedProperties);
+        if (changedProperties.has('_propertyType') || changedProperties.has('_workspaceContext')) {
+            const dataTypeUnique = this._propertyType?.dataType.unique;
+            if (dataTypeUnique && this._workspaceContext) {
+                this.observe(this._workspaceContext.structure.contentTypeDataTypeDetailOf(dataTypeUnique), (detail) => {
+                    this._dataTypeDetail = detail;
+                }, 'observeDataTypeDetail');
+            }
+        }
         if (changedProperties.has('_propertyType') ||
             changedProperties.has('_datasetVariantId') ||
             changedProperties.has('_workspaceContext')) {
@@ -77,6 +85,7 @@ let UmbContentWorkspacePropertyElement = class UmbContentWorkspacePropertyElemen
         return html `<umb-property-type-based-property
 			data-path=${this._dataPath}
 			.property=${this._propertyType}
+			.dataTypeDetail=${this._dataTypeDetail}
 			?readonly=${!this._writeable}></umb-property-type-based-property>`;
     }
 };
@@ -101,6 +110,9 @@ __decorate([
 __decorate([
     state()
 ], UmbContentWorkspacePropertyElement.prototype, "_propertyType", void 0);
+__decorate([
+    state()
+], UmbContentWorkspacePropertyElement.prototype, "_dataTypeDetail", void 0);
 __decorate([
     state()
 ], UmbContentWorkspacePropertyElement.prototype, "_hasAccessToSensitiveData", void 0);

package/dist-cms/packages/content/content/index.d.ts

@@ -1,3 +1,4 @@
+export * from './audit-log/index.js';
 export * from './collection/index.js';
 export * from './components/index.js';
 export * from './constants.js';
@@ -5,6 +6,7 @@ export * from './controller/merge-content-variant-data.controller.js';
 export * from './global-components/index.js';
 export * from './manager/index.js';
 export * from './property-dataset-context/index.js';
+export * from './rollback/index.js';
 export * from './workspace/index.js';
 export type * from './repository/index.js';
 export type * from './types.js';

package/dist-cms/packages/content/content/index.js

@@ -1,3 +1,4 @@
+export * from './audit-log/index.js';
 export * from './collection/index.js';
 export * from './components/index.js';
 export * from './constants.js';
@@ -5,4 +6,5 @@ export * from './controller/merge-content-variant-data.controller.js';
 export * from './global-components/index.js';
 export * from './manager/index.js';
 export * from './property-dataset-context/index.js';
+export * from './rollback/index.js';
 export * from './workspace/index.js';

package/dist-cms/packages/content/content/manifests.js

@@ -1,10 +1,14 @@
+import { manifests as auditLogManifests } from './audit-log/manifests.js';
 import { manifests as collectionManifests } from './collection/manifests.js';
 import { manifests as conditionManifests } from './conditions/manifests.js';
+import { manifests as rollbackManifests } from './rollback/manifests.js';
 import { manifests as contentTreeManifests } from './tree/manifests.js';
 import { manifests as workspaceManifests } from './workspace/manifests.js';
 export const manifests = [
+    ...auditLogManifests,
     ...collectionManifests,
     ...conditionManifests,
+    ...rollbackManifests,
     ...contentTreeManifests,
     ...workspaceManifests,
 ];

package/dist-cms/packages/content/content/rollback/entity-action/content-rollback.action.d.ts

@@ -0,0 +1,7 @@
+import type { MetaEntityActionContentRollbackKind } from './types.js';
+import { UmbEntityActionBase } from '../../../../core/entity-action/index.js';
+export declare class UmbContentRollbackEntityAction extends UmbEntityActionBase<MetaEntityActionContentRollbackKind> {
+    #private;
+    execute(): Promise<void>;
+}
+export { UmbContentRollbackEntityAction as api };

package/dist-cms/packages/content/content/rollback/entity-action/content-rollback.action.js

@@ -0,0 +1,26 @@
+import { UMB_CONTENT_ROLLBACK_MODAL } from '../modal/constants.js';
+import { UmbEntityActionBase } from '../../../../core/entity-action/index.js';
+import { umbOpenModal } from '../../../../core/modal/index.js';
+import { UMB_NOTIFICATION_CONTEXT } from '../../../../core/notification/index.js';
+import { UmbLocalizationController } from '../../../../../libs/localization-api/index.js';
+export class UmbContentRollbackEntityAction extends UmbEntityActionBase {
+    #localize = new UmbLocalizationController(this);
+    async execute() {
+        const result = await umbOpenModal(this, UMB_CONTENT_ROLLBACK_MODAL, {
+            data: {
+                rollbackRepositoryAlias: this.args.meta.rollbackRepositoryAlias,
+                detailRepositoryAlias: this.args.meta.detailRepositoryAlias,
+            },
+        }).catch(() => undefined);
+        if (!result)
+            return;
+        const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
+        if (!notificationContext) {
+            throw new Error('Notification context not found');
+        }
+        notificationContext.peek('positive', {
+            data: { message: this.#localize.term('rollback_documentRolledBack') },
+        });
+    }
+}
+export { UmbContentRollbackEntityAction as api };

package/dist-cms/packages/content/content/rollback/entity-action/content-rollback.action.kind.d.ts

@@ -0,0 +1,3 @@
+import type { UmbExtensionManifestKind } from '../../../../core/extension-registry/index.js';
+export declare const UMB_ENTITY_ACTION_CONTENT_ROLLBACK_KIND_MANIFEST: UmbExtensionManifestKind;
+export declare const manifest: UmbExtensionManifestKind;

package/dist-cms/packages/content/content/rollback/entity-action/content-rollback.action.kind.js

@@ -0,0 +1,23 @@
+import { UMB_ENTITY_ACTION_DEFAULT_KIND_MANIFEST } from '../../../../core/entity-action/index.js';
+export const UMB_ENTITY_ACTION_CONTENT_ROLLBACK_KIND_MANIFEST = {
+    type: 'kind',
+    alias: 'Umb.Kind.EntityAction.ContentRollback',
+    matchKind: 'contentRollback',
+    matchType: 'entityAction',
+    manifest: {
+        ...UMB_ENTITY_ACTION_DEFAULT_KIND_MANIFEST.manifest,
+        type: 'entityAction',
+        kind: 'contentRollback',
+        api: () => import('./content-rollback.action.js'),
+        weight: 450,
+        forEntityTypes: [],
+        meta: {
+            icon: 'icon-history',
+            label: '#actions_rollback',
+            additionalOptions: true,
+            rollbackRepositoryAlias: '',
+            detailRepositoryAlias: '',
+        },
+    },
+};
+export const manifest = UMB_ENTITY_ACTION_CONTENT_ROLLBACK_KIND_MANIFEST;

package/dist-cms/packages/content/content/rollback/entity-action/manifests.d.ts

@@ -0,0 +1 @@
+export declare const manifests: import("../../../../core/extension-registry/index.js").UmbExtensionManifestKind[];

package/dist-cms/packages/content/content/rollback/entity-action/manifests.js

@@ -0,0 +1,2 @@
+import { manifest as rollbackKindManifest } from './content-rollback.action.kind.js';
+export const manifests = [rollbackKindManifest];

package/dist-cms/packages/content/content/rollback/entity-action/types.d.ts

@@ -0,0 +1,14 @@
+import type { ManifestEntityAction, MetaEntityActionDefaultKind } from '../../../../core/entity-action/index.js';
+export interface ManifestEntityActionContentRollbackKind extends ManifestEntityAction<MetaEntityActionContentRollbackKind> {
+    type: 'entityAction';
+    kind: 'contentRollback';
+}
+export interface MetaEntityActionContentRollbackKind extends MetaEntityActionDefaultKind {
+    rollbackRepositoryAlias: string;
+    detailRepositoryAlias: string;
+}
+declare global {
+    interface UmbExtensionManifestMap {
+        umbEntityActionContentRollbackKind: ManifestEntityActionContentRollbackKind;
+    }
+}

package/dist-cms/packages/content/content/rollback/entity-action/types.js

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

package/dist-cms/packages/content/content/rollback/index.d.ts

@@ -0,0 +1,6 @@
+export { UMB_ENTITY_ACTION_CONTENT_ROLLBACK_KIND_MANIFEST } from './entity-action/content-rollback.action.kind.js';
+export { UMB_CONTENT_ROLLBACK_MODAL_ALIAS, UMB_CONTENT_ROLLBACK_MODAL } from './modal/constants.js';
+export type * from './types.js';
+export type * from './rollback-repository.interface.js';
+export type * from './entity-action/types.js';
+export type * from './modal/types.js';

package/dist-cms/packages/content/content/rollback/index.js

@@ -0,0 +1,2 @@
+export { UMB_ENTITY_ACTION_CONTENT_ROLLBACK_KIND_MANIFEST } from './entity-action/content-rollback.action.kind.js';
+export { UMB_CONTENT_ROLLBACK_MODAL_ALIAS, UMB_CONTENT_ROLLBACK_MODAL } from './modal/constants.js';

package/dist-cms/packages/content/content/rollback/manifests.d.ts

@@ -0,0 +1 @@
+export declare const manifests: (import("../../../../libs/extension-api/index.js").ManifestBase | import("../../../core/extension-registry/index.js").UmbExtensionManifestKind)[];

package/dist-cms/packages/content/content/rollback/manifests.js

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

package/dist-cms/packages/content/content/rollback/modal/constants.d.ts

@@ -0,0 +1,4 @@
+import type { UmbContentRollbackModalData, UmbContentRollbackModalValue } from './types.js';
+import { UmbModalToken } from '../../../../core/modal/index.js';
+export declare const UMB_CONTENT_ROLLBACK_MODAL_ALIAS = "Umb.Modal.Content.Rollback";
+export declare const UMB_CONTENT_ROLLBACK_MODAL: UmbModalToken<UmbContentRollbackModalData, UmbContentRollbackModalValue>;

package/dist-cms/packages/content/content/rollback/modal/constants.js

@@ -0,0 +1,8 @@
+import { UmbModalToken } from '../../../../core/modal/index.js';
+export const UMB_CONTENT_ROLLBACK_MODAL_ALIAS = 'Umb.Modal.Content.Rollback';
+export const UMB_CONTENT_ROLLBACK_MODAL = new UmbModalToken(UMB_CONTENT_ROLLBACK_MODAL_ALIAS, {
+    modal: {
+        type: 'sidebar',
+        size: 'full',
+    },
+});

package/dist-cms/packages/content/content/rollback/modal/content-rollback-modal.element.d.ts

@@ -0,0 +1,22 @@
+import type { UmbContentRollbackModalData, UmbContentRollbackModalValue } from './types.js';
+import { UmbModalBaseElement } from '../../../../core/modal/index.js';
+export declare class UmbContentRollbackModalElement extends UmbModalBaseElement<UmbContentRollbackModalData, UmbContentRollbackModalValue> {
+    #private;
+    private _versions;
+    private _selectedVersion?;
+    private _selectedCulture;
+    private _isInvariant;
+    private _availableVariants;
+    private _diffs;
+    private _showDiff;
+    constructor();
+    get currentVersionHeader(): string;
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+export default UmbContentRollbackModalElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-content-rollback-modal': UmbContentRollbackModalElement;
+    }
+}