@umbraco-cms/backoffice 14.0.0-rc3 → 14.0.0-rc4

package/dist-cms/packages/media/media/components/input-media/input-media.element.js

@@ -65,6 +65,8 @@ let UmbInputMediaElement = class UmbInputMediaElement extends UUIFormControlMixi
             identifier: 'Umb.SorterIdentifier.InputMedia',
             itemSelector: 'uui-card-media',
             containerSelector: '.container',
+            /** TODO: This component probably needs some grid-like logic for resolve placement... [LI] */
+            resolvePlacement: () => false,
             onChange: ({ model }) => {
                 this.selection = model;
                 this.dispatchEvent(new UmbChangeEvent());
@@ -84,7 +86,9 @@ let UmbInputMediaElement = class UmbInputMediaElement extends UUIFormControlMixi
          * @default
          */
         this.maxMessage = 'This field exceeds the allowed amount of items';
-        this._editMediaPath = '';
+        this.startNode = '';
+        this.multiple = false;
+        this.editMediaPath = '';
         this.#pickerContext = new UmbMediaPickerContext(this);
         this.#pickableFilter = (item) => {
             if (this.allowedContentTypeIds && this.allowedContentTypeIds.length > 0) {
@@ -98,10 +102,12 @@ let UmbInputMediaElement = class UmbInputMediaElement extends UUIFormControlMixi
             return { data: { entityType: 'media', preset: {} } };
         })
             .observeRouteBuilder((routeBuilder) => {
-            this._editMediaPath = routeBuilder({});
+            this.editMediaPath = routeBuilder({});
         });
         this.observe(this.#pickerContext.selection, (selection) => (this.value = selection.join(',')));
-        this.observe(this.#pickerContext.selectedItems, (selectedItems) => (this._items = selectedItems));
+        this.observe(this.#pickerContext.cardItems, (cardItems) => {
+            this.items = cardItems;
+        });
         this.addValidator('rangeUnderflow', () => this.minMessage, () => !!this.min && this.#pickerContext.getSelection().length < this.min);
         this.addValidator('rangeOverflow', () => this.maxMessage, () => !!this.max && this.#pickerContext.getSelection().length > this.max);
     }
@@ -110,22 +116,25 @@ let UmbInputMediaElement = class UmbInputMediaElement extends UUIFormControlMixi
     }
     #pickableFilter;
     #openPicker() {
-        // TODO: Configure the media picker, with `ignoreUserStartNodes` [LK]
         this.#pickerContext.openPicker({
-            hideTreeRoot: true,
+            multiple: this.multiple,
+            startNode: this.startNode,
             pickableFilter: this.#pickableFilter,
         });
     }
+    onRemove(item) {
+        this.#pickerContext.requestRemoveItem(item.unique);
+    }
     render() {
         return html `<div class="container">${this.#renderItems()} ${this.#renderAddButton()}</div>`;
     }
     #renderItems() {
-        if (!this._items)
+        if (!this.items?.length)
             return;
-        return html `${repeat(this._items, (item) => item.unique, (item) => this.#renderItem(item))}`;
+        return html `${repeat(this.items, (item) => item.unique, (item) => this.renderItem(item))}`;
     }
     #renderAddButton() {
-        if (this._items && this.max && this._items.length >= this.max)
+        if ((this.items && this.max && this.items.length >= this.max) || (this.items?.length && !this.multiple))
             return;
         return html `
 			<uui-button
@@ -138,29 +147,28 @@ let UmbInputMediaElement = class UmbInputMediaElement extends UUIFormControlMixi
 			</uui-button>
 		`;
     }
-    #renderItem(item) {
-        // TODO: `file-ext` value has been hardcoded here. Find out if API model has value for it. [LK]
+    renderItem(item) {
         return html `
 			<uui-card-media
 				name=${ifDefined(item.name === null ? undefined : item.name)}
 				detail=${ifDefined(item.unique)}
-				file-ext="jpg">
-				${this.#renderIsTrashed(item)}
+				href="${this.editMediaPath}edit/${item.unique}">
+				${item.url
+            ? html `<img src=${item.url} alt=${item.name} />`
+            : html `<umb-icon name=${ifDefined(item.mediaType.icon)}></umb-icon>`}
+				${this.renderIsTrashed(item)}
 				<uui-action-bar slot="actions">
-					${this.#renderOpenButton(item)}
-					<uui-button label="Copy media">
-						<uui-icon name="icon-documents"></uui-icon>
-					</uui-button>
 					<uui-button
-						@click=${() => this.#pickerContext.requestRemoveItem(item.unique)}
-						label="Remove media ${item.name}">
+						label=${this.localize.term('general_remove')}
+						look="secondary"
+						@click=${() => this.onRemove(item)}>
 						<uui-icon name="icon-trash"></uui-icon>
 					</uui-button>
 				</uui-action-bar>
 			</uui-card-media>
 		`;
     }
-    #renderIsTrashed(item) {
+    renderIsTrashed(item) {
         if (!item.isTrashed)
             return;
         return html `
@@ -169,25 +177,16 @@ let UmbInputMediaElement = class UmbInputMediaElement extends UUIFormControlMixi
 			</uui-tag>
 		`;
     }
-    #renderOpenButton(item) {
-        if (!this.showOpenButton)
-            return;
-        return html `
-			<uui-button
-				compact
-				href="${this._editMediaPath}edit/${item.unique}"
-				label=${this.localize.term('general_edit') + ` ${item.name}`}>
-				<uui-icon name="icon-edit"></uui-icon>
-			</uui-button>
-		`;
-    }
     static { this.styles = [
         css `
+			:host {
+				position: relative;
+			}
 			.container {
 				display: grid;
 				gap: var(--uui-size-space-3);
-				grid-template-columns: repeat(auto-fill, minmax(160px, 1fr));
-				grid-template-rows: repeat(auto-fill, minmax(160px, 1fr));
+				grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
+				grid-auto-rows: 150px;
 			}
 
 			#btn-add {
@@ -200,6 +199,10 @@ let UmbInputMediaElement = class UmbInputMediaElement extends UUIFormControlMixi
 				margin: 0 auto;
 			}
 
+			uui-card-media umb-icon {
+				font-size: var(--uui-size-8);
+			}
+
 			uui-card-media[drag-placeholder] {
 				opacity: 0.2;
 			}
@@ -224,18 +227,21 @@ __decorate([
 __decorate([
     property({ type: Boolean })
 ], UmbInputMediaElement.prototype, "showOpenButton", void 0);
+__decorate([
+    property({ type: String })
+], UmbInputMediaElement.prototype, "startNode", void 0);
 __decorate([
     property({ type: Boolean })
-], UmbInputMediaElement.prototype, "ignoreUserStartNodes", void 0);
+], UmbInputMediaElement.prototype, "multiple", void 0);
 __decorate([
     property()
 ], UmbInputMediaElement.prototype, "value", null);
 __decorate([
     state()
-], UmbInputMediaElement.prototype, "_editMediaPath", void 0);
+], UmbInputMediaElement.prototype, "editMediaPath", void 0);
 __decorate([
     state()
-], UmbInputMediaElement.prototype, "_items", void 0);
+], UmbInputMediaElement.prototype, "items", void 0);
 UmbInputMediaElement = __decorate([
     customElement('umb-input-media')
 ], UmbInputMediaElement);

package/dist-cms/packages/media/media/dropzone/dropzone-manager.class.d.ts

@@ -0,0 +1,38 @@
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+import { UmbControllerBase } from '../../../../libs/class-api/index.js';
+import { type UmbAllowedMediaTypeModel } from '../../media-types/index.js';
+import { type UmbTemporaryFileModel } from '../../../core/temporary-file/index.js';
+export interface UmbUploadableFileModel extends UmbTemporaryFileModel {
+    unique: string;
+    mediaTypeUnique: string;
+}
+export interface UmbUploadableExtensionModel {
+    fileExtension: string;
+    mediaTypes: Array<UmbAllowedMediaTypeModel>;
+}
+/**
+ * Manages the dropzone and uploads files to the server.
+ * @method createFilesAsMedia - Upload files to the server and creates the items using corresponding media type.
+ * @method createFilesAsTemporary - Upload the files as temporary files and returns the data.
+ * @observable completed - Emits an array of completed uploads.
+ */
+export declare class UmbDropzoneManager extends UmbControllerBase {
+    #private;
+    readonly completed: import("rxjs/internal/Observable").Observable<(UmbTemporaryFileModel | UmbUploadableFileModel)[]>;
+    constructor(host: UmbControllerHost);
+    /**
+     * Uploads the files as temporary files and returns the data.
+     * @param files
+     * @returns Promise<Array<UmbUploadableFileModel>>
+     */
+    createFilesAsTemporary(files: Array<File>): Promise<Array<UmbTemporaryFileModel>>;
+    /**
+     * Uploads files to the server and creates the items with corresponding media type.
+     * Allows the user to pick a media type option if multiple types are allowed.
+     * @param files
+     * @param parentUnique
+     */
+    createFilesAsMedia(files: Array<File>, parentUnique: string | null): Promise<void>;
+    private _reset;
+    destroy(): void;
+}

package/dist-cms/packages/media/media/dropzone/dropzone-manager.class.js

@@ -0,0 +1,214 @@
+import { UmbMediaDetailRepository } from '../repository/index.js';
+import { UMB_DROPZONE_MEDIA_TYPE_PICKER_MODAL } from './modals/dropzone-media-type-picker/dropzone-media-type-picker-modal.token.js';
+import { UmbControllerBase } from '../../../../libs/class-api/index.js';
+import { UmbMediaTypeStructureRepository } from '../../media-types/index.js';
+import { TemporaryFileStatus, UmbTemporaryFileManager, } from '../../../core/temporary-file/index.js';
+import { UmbId } from '../../../core/id/index.js';
+import { UMB_MODAL_MANAGER_CONTEXT } from '../../../core/modal/index.js';
+import { UmbArrayState } from '../../../../libs/observable-api/index.js';
+/**
+ * Manages the dropzone and uploads files to the server.
+ * @method createFilesAsMedia - Upload files to the server and creates the items using corresponding media type.
+ * @method createFilesAsTemporary - Upload the files as temporary files and returns the data.
+ * @observable completed - Emits an array of completed uploads.
+ */
+export class UmbDropzoneManager extends UmbControllerBase {
+    #host;
+    #tempFileManager;
+    #mediaTypeStructure;
+    #mediaDetailRepository;
+    #completed;
+    constructor(host) {
+        super(host);
+        this.#tempFileManager = new UmbTemporaryFileManager(this);
+        this.#mediaTypeStructure = new UmbMediaTypeStructureRepository(this);
+        this.#mediaDetailRepository = new UmbMediaDetailRepository(this);
+        this.#completed = new UmbArrayState([], (upload) => upload.temporaryUnique);
+        this.completed = this.#completed.asObservable();
+        this.#host = host;
+    }
+    /**
+     * Uploads the files as temporary files and returns the data.
+     * @param files
+     * @returns Promise<Array<UmbUploadableFileModel>>
+     */
+    async createFilesAsTemporary(files) {
+        this.#completed.setValue([]);
+        const temporaryFiles = [];
+        for (const file of files) {
+            const uploaded = await this.#tempFileManager.uploadOne({ temporaryUnique: UmbId.new(), file });
+            this.#completed.setValue([...this.#completed.getValue(), uploaded]);
+            temporaryFiles.push(uploaded);
+        }
+        return temporaryFiles;
+    }
+    /**
+     * Uploads files to the server and creates the items with corresponding media type.
+     * Allows the user to pick a media type option if multiple types are allowed.
+     * @param files
+     * @param parentUnique
+     */
+    async createFilesAsMedia(files, parentUnique) {
+        if (!files.length)
+            return;
+        if (files.length === 1)
+            return this.#handleOneOneFile(files[0], parentUnique);
+        // Handler for multiple files dropped
+        this.#completed.setValue([]);
+        // removes duplicate file types so we don't call endpoints unnecessarily when building options.
+        const mimeTypes = [...new Set(files.map((file) => file.type))];
+        const optionsArray = await this.#buildOptionsArrayFrom(mimeTypes.map((mimetype) => this.#getExtensionFromMime(mimetype)), parentUnique);
+        if (!optionsArray.length)
+            return; // None of the files are allowed in current dropzone.
+        // Building an array of uploadable files. Do we want to build an array of failed files to let the user know which ones?
+        const uploadableFiles = [];
+        const notAllowedFiles = [];
+        for (const file of files) {
+            const extension = this.#getExtensionFromMime(file.type);
+            if (!extension) {
+                // Folders have no extension on file drop. We assume it is a folder being uploaded.
+                continue;
+            }
+            const options = optionsArray.find((option) => option.fileExtension === extension)?.mediaTypes;
+            if (!options || !options.length) {
+                // TODO Current dropped file not allowed in this area. Find a good way to show this to the user after we finish uploading the rest of the files.
+                notAllowedFiles.push(file);
+                continue;
+            }
+            // Since we are uploading multiple files, we will pick first allowed option.
+            // Consider a way we can handle this differently in the future to let the user choose. Maybe a list of all files with an allowed media type dropdown?
+            const mediaType = options[0];
+            uploadableFiles.push({
+                temporaryUnique: UmbId.new(),
+                file,
+                mediaTypeUnique: mediaType.unique,
+                unique: UmbId.new(),
+            });
+        }
+        notAllowedFiles.forEach((file) => {
+            try {
+                throw new Error(`File ${file.name} of type ${file.type} is not allowed here.`);
+            }
+            catch (e) {
+                undefined;
+            }
+        });
+        if (!uploadableFiles.length)
+            return;
+        await this.#handleUpload(uploadableFiles, parentUnique);
+    }
+    async #handleOneOneFile(file, parentUnique) {
+        this.#completed.setValue([]);
+        const extension = this.#getExtensionFromMime(file.type);
+        if (!extension) {
+            // TODO Folders have no extension on file drop. Assume it is a folder being uploaded.
+            return;
+        }
+        const optionsArray = await this.#buildOptionsArrayFrom([extension], parentUnique);
+        if (!optionsArray.length || !optionsArray[0].mediaTypes.length) {
+            throw new Error(`File ${file.name} of type ${file.type} is not allowed here.`); // Parent does not allow this file type here.
+        }
+        const mediaTypes = optionsArray[0].mediaTypes;
+        if (mediaTypes.length === 1) {
+            // Only one allowed option, upload file using that option.
+            const uploadableFile = {
+                unique: UmbId.new(),
+                temporaryUnique: UmbId.new(),
+                file,
+                mediaTypeUnique: mediaTypes[0].unique,
+            };
+            await this.#handleUpload([uploadableFile], parentUnique);
+            return;
+        }
+        // Multiple options, show a dialog for the user to pick one.
+        const mediaType = await this.#showDialogMediaTypePicker(mediaTypes);
+        if (!mediaType)
+            return; // Upload cancelled.
+        const uploadableFile = {
+            unique: UmbId.new(),
+            temporaryUnique: UmbId.new(),
+            file,
+            mediaTypeUnique: mediaType.unique,
+        };
+        await this.#handleUpload([uploadableFile], parentUnique);
+    }
+    #getExtensionFromMime(mime) {
+        //TODO Temporary solution.
+        if (!mime)
+            return ''; //folders
+        const extension = mime.split('/')[1];
+        switch (extension) {
+            case 'svg+xml':
+                return 'svg';
+            default:
+                return extension;
+        }
+    }
+    async #buildOptionsArrayFrom(fileExtensions, parentUnique) {
+        // Getting all media types allowed in our current position based on parent unique.
+        const { data: allAllowedMediaTypes } = await this.#mediaTypeStructure.requestAllowedChildrenOf(parentUnique);
+        if (!allAllowedMediaTypes?.items.length)
+            return [];
+        const allowedByParent = allAllowedMediaTypes.items;
+        // Building an array of options the files can be uploaded as.
+        const options = [];
+        for (const fileExtension of fileExtensions) {
+            const extensionOptions = await this.#mediaTypeStructure.requestMediaTypesOf({ fileExtension });
+            const mediaTypes = extensionOptions.filter((option) => {
+                return allowedByParent.find((allowed) => option.unique === allowed.unique);
+            });
+            options.push({ fileExtension, mediaTypes });
+        }
+        return options;
+    }
+    async #showDialogMediaTypePicker(options) {
+        const modalManager = await this.getContext(UMB_MODAL_MANAGER_CONTEXT);
+        const modalContext = modalManager.open(this.#host, UMB_DROPZONE_MEDIA_TYPE_PICKER_MODAL, { data: { options } });
+        const value = await modalContext.onSubmit().catch(() => undefined);
+        return value ? { unique: value.mediaTypeUnique ?? options[0].unique } : null;
+    }
+    async #handleUpload(files, parentUnique) {
+        for (const file of files) {
+            const upload = (await this.#tempFileManager.uploadOne(file));
+            if (upload.status === TemporaryFileStatus.SUCCESS) {
+                // Upload successful. Create media item.
+                const preset = {
+                    unique: file.unique,
+                    mediaType: {
+                        unique: upload.mediaTypeUnique,
+                        collection: null,
+                    },
+                    variants: [
+                        {
+                            culture: null,
+                            segment: null,
+                            name: upload.file.name,
+                            createDate: null,
+                            updateDate: null,
+                        },
+                    ],
+                    values: [
+                        {
+                            alias: 'umbracoFile',
+                            value: { temporaryFileId: upload.temporaryUnique },
+                            culture: null,
+                            segment: null,
+                        },
+                    ],
+                };
+                const { data } = await this.#mediaDetailRepository.createScaffold(preset);
+                await this.#mediaDetailRepository.create(data, parentUnique);
+            }
+            // TODO Find a good way to show files that ended up as TemporaryFileStatus.ERROR. Notice that they were allowed in current area
+            this.#completed.setValue([...this.#completed.getValue(), upload]);
+        }
+    }
+    _reset() {
+        //
+    }
+    destroy() {
+        this.#tempFileManager.destroy();
+        this.#completed.destroy();
+        super.destroy();
+    }
+}

package/dist-cms/packages/media/media/dropzone/dropzone.element.d.ts

@@ -0,0 +1,22 @@
+import { type UmbUploadableFileModel } from './dropzone-manager.class.js';
+import { UmbLitElement } from '../../../core/lit-element/index.js';
+import type { UmbTemporaryFileModel } from '../../../core/temporary-file/index.js';
+export declare class UmbDropzoneElement extends UmbLitElement {
+    #private;
+    parentUnique: string | null;
+    multiple: boolean;
+    createAsTemporary: boolean;
+    accept: Array<string>;
+    getFiles(): (UmbTemporaryFileModel | UmbUploadableFileModel)[];
+    browse(): void;
+    constructor();
+    disconnectedCallback(): void;
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("@lit/reactive-element/css-tag.js").CSSResult[];
+}
+export default UmbDropzoneElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-dropzone': UmbDropzoneElement;
+    }
+}

package/dist-cms/packages/media/media/dropzone/dropzone.element.js

@@ -0,0 +1,138 @@
+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 { UmbDropzoneManager } from './dropzone-manager.class.js';
+import { UmbProgressEvent } from '../../../core/event/index.js';
+import { css, html, customElement, property } from '../../../../external/lit/index.js';
+import { UmbLitElement } from '../../../core/lit-element/index.js';
+let UmbDropzoneElement = class UmbDropzoneElement extends UmbLitElement {
+    //TODO: logic to disable the dropzone?
+    #files;
+    getFiles() {
+        return this.#files;
+    }
+    browse() {
+        const element = this.shadowRoot?.querySelector('#dropzone');
+        return element.browse();
+    }
+    constructor() {
+        super();
+        this.parentUnique = null;
+        this.multiple = true;
+        this.createAsTemporary = false;
+        this.accept = [];
+        //TODO: logic to disable the dropzone?
+        this.#files = [];
+        document.addEventListener('dragenter', this.#handleDragEnter.bind(this));
+        document.addEventListener('dragleave', this.#handleDragLeave.bind(this));
+        document.addEventListener('drop', this.#handleDrop.bind(this));
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        document.removeEventListener('dragenter', this.#handleDragEnter.bind(this));
+        document.removeEventListener('dragleave', this.#handleDragLeave.bind(this));
+        document.removeEventListener('drop', this.#handleDrop.bind(this));
+    }
+    #handleDragEnter(e) {
+        // Avoid collision with UmbSorterController
+        if (!e.dataTransfer?.types?.length)
+            return;
+        this.toggleAttribute('dragging', true);
+    }
+    #handleDragLeave() {
+        this.toggleAttribute('dragging', false);
+    }
+    #handleDrop(event) {
+        event.preventDefault();
+        this.toggleAttribute('dragging', false);
+    }
+    async #onDropFiles(event) {
+        // TODO Handle of folder uploads.
+        const files = event.detail.files;
+        if (!files.length)
+            return;
+        const dropzoneManager = new UmbDropzoneManager(this);
+        this.observe(dropzoneManager.completed, (completed) => {
+            if (!completed.length)
+                return;
+            const progress = Math.floor(completed.length / files.length);
+            this.dispatchEvent(new UmbProgressEvent(progress));
+            if (completed.length === files.length) {
+                this.#files = completed;
+                this.dispatchEvent(new CustomEvent('change', { detail: { completed } }));
+                dropzoneManager.destroy();
+            }
+        }, '_observeCompleted');
+        //TODO Create some placeholder items while files are being uploaded? Could update them as they get completed.
+        if (this.createAsTemporary) {
+            await dropzoneManager.createFilesAsTemporary(files);
+        }
+        else {
+            await dropzoneManager.createFilesAsMedia(files, this.parentUnique);
+        }
+    }
+    render() {
+        return html `<uui-file-dropzone
+			id="dropzone"
+			.accept=${this.accept?.join(',')}
+			?multiple=${this.multiple}
+			@change=${this.#onDropFiles}
+			label="${this.localize.term('media_dragAndDropYourFilesIntoTheArea')}"></uui-file-dropzone>`;
+    }
+    static { this.styles = [
+        css `
+			:host([dragging]) #dropzone {
+				opacity: 1;
+				pointer-events: all;
+			}
+
+			[dropzone] {
+				opacity: 0;
+			}
+
+			#dropzone {
+				opacity: 0;
+				pointer-events: none;
+				display: flex;
+				align-items: center;
+				justify-content: center;
+				position: absolute;
+				inset: 0px;
+				z-index: 100;
+				backdrop-filter: opacity(1); /* Removes the built in blur effect */
+				border-radius: var(--uui-border-radius);
+				overflow: clip;
+				border: 1px solid var(--uui-color-focus);
+			}
+			#dropzone:after {
+				content: '';
+				display: block;
+				position: absolute;
+				inset: 0;
+				border-radius: var(--uui-border-radius);
+				background-color: var(--uui-color-focus);
+				opacity: 0.2;
+			}
+		`,
+    ]; }
+};
+__decorate([
+    property({ attribute: false })
+], UmbDropzoneElement.prototype, "parentUnique", void 0);
+__decorate([
+    property({ type: Boolean })
+], UmbDropzoneElement.prototype, "multiple", void 0);
+__decorate([
+    property({ type: Boolean })
+], UmbDropzoneElement.prototype, "createAsTemporary", void 0);
+__decorate([
+    property({ type: Array, attribute: false })
+], UmbDropzoneElement.prototype, "accept", void 0);
+UmbDropzoneElement = __decorate([
+    customElement('umb-dropzone')
+], UmbDropzoneElement);
+export { UmbDropzoneElement };
+export default UmbDropzoneElement;

package/dist-cms/packages/media/media/dropzone/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dropzone.element.js';
+export * from './dropzone-manager.class.js';

package/dist-cms/packages/media/media/dropzone/index.js

@@ -0,0 +1,2 @@
+export * from './dropzone.element.js';
+export * from './dropzone-manager.class.js';

package/dist-cms/packages/media/media/dropzone/manifests.d.ts

@@ -0,0 +1 @@
+export * from './modals/manifests.js';

package/dist-cms/packages/media/media/dropzone/manifests.js

@@ -0,0 +1 @@
+export * from './modals/manifests.js';

package/dist-cms/packages/media/media/dropzone/modals/dropzone-media-type-picker/dropzone-media-type-picker-modal.element.d.ts

@@ -0,0 +1,16 @@
+import type { UmbDropzoneMediaTypePickerModalData, UmbDropzoneMediaTypePickerModalValue } from './dropzone-media-type-picker-modal.token.js';
+import { UmbModalBaseElement } from '../../../../../core/modal/index.js';
+export declare class UmbDropzoneMediaTypePickerModalElement extends UmbModalBaseElement<UmbDropzoneMediaTypePickerModalData, UmbDropzoneMediaTypePickerModalValue> {
+    #private;
+    private _options;
+    private _buttonAuto;
+    connectedCallback(): void;
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("@lit/reactive-element/css-tag.js").CSSResult[];
+}
+export default UmbDropzoneMediaTypePickerModalElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-dropzone-media-type-picker-modal': UmbDropzoneMediaTypePickerModalElement;
+    }
+}