@pitcher/js-api 1.25.0-beta.2 → 1.25.0-beta.3

package/lib/apps/collection-player/composables/laser-pointer-marker.use.d.ts

@@ -0,0 +1,166 @@
+import { MarkerBaseState, MarkerEditorProperties, IPoint } from '@markerjs/markerjs3';
+/**
+ * Types only - safe for SSR
+ */
+interface TimedPoint extends IPoint {
+    timestamp: number;
+}
+/**
+ * Represents laser pointer marker's state.
+ */
+export interface LaserPointerMarkerState extends MarkerBaseState {
+    /**
+     * Points of the laser path.
+     */
+    points: Array<IPoint>;
+    /**
+     * Whether the laser pointer is active.
+     */
+    isActive: boolean;
+    /**
+     * Size of the laser dot
+     */
+    dotSize: number;
+}
+declare const FreehandMarker: typeof import('@markerjs/markerjs3').FreehandMarker, FreehandMarkerEditor: typeof import('@markerjs/markerjs3').FreehandMarkerEditor;
+/**
+ * A smooth laser pointer similar to Slack's huddle drawing tool
+ * @summary Laser pointer marker
+ * @group Markers
+ */
+export declare class LaserPointerMarker extends FreehandMarker {
+    static typeName: string;
+    static title: string;
+    static applyDefaultFilter: boolean;
+    /**
+     * Points with timestamps for fade effect
+     */
+    protected timedPoints: TimedPoint[];
+    /**
+     * The main dot element - made public for editor access
+     */
+    laserDot?: SVGCircleElement;
+    /**
+     * The trail element
+     */
+    protected laserTrail?: SVGPathElement;
+    /**
+     * Duration in milliseconds that trail points remain visible
+     */
+    protected trailDuration: number;
+    /**
+     * Animation frame ID
+     */
+    protected animationFrameId: number | null;
+    /**
+     * Current pointer position
+     */
+    protected currentPosition: IPoint;
+    /**
+     * Whether the pointer is currently active/visible
+     */
+    protected isActive: boolean;
+    /**
+     * Size of the laser dot
+     */
+    protected dotSize: number;
+    constructor(container: SVGGElement);
+    /**
+     * Get current dot size
+     */
+    get getDotSize(): number;
+    /**
+     * Set dot size
+     */
+    set setDotSize(value: number);
+    /**
+     * Updates the current position
+     */
+    updatePosition(point: IPoint): void;
+    /**
+     * Generates trail path based on recent points
+     */
+    getTrailPath(): string;
+    /**
+     * Starts animation loop
+     */
+    startAnimation(): void;
+    /**
+     * Stops animation loop
+     */
+    stopAnimation(): void;
+    /**
+     * Creates the visual elements for the laser pointer
+     */
+    createVisual(): void;
+    /**
+     * Updates visual elements
+     */
+    adjustVisual(): void;
+    /**
+     * Sets active state of the laser pointer
+     */
+    setActive(active: boolean): void;
+    /**
+     * Completely removes the visual elements when the tool is no longer in use
+     */
+    clearVisuals(): void;
+    /**
+     * Disposes the marker and cleans up.
+     */
+    dispose(): void;
+    /**
+     * Returns marker's state that can be restored in the future.
+     */
+    getState(): LaserPointerMarkerState;
+    /**
+     * Restores previously saved marker state.
+     *
+     * @param state - previously saved state.
+     */
+    restoreState(state: MarkerBaseState): void;
+}
+/**
+ * Editor for laser pointer markers.
+ *
+ * @summary Laser pointer marker editor.
+ * @group Editors
+ */
+export declare class LaserPointerMarkerEditor extends FreehandMarkerEditor<LaserPointerMarker> {
+    private lastPointerPosition;
+    private isPointerDown;
+    constructor(properties: MarkerEditorProperties<LaserPointerMarker>);
+    /**
+     * Sets up the custom cursor for the laser pointer tool
+     */
+    private setupCustomCursor;
+    /**
+     * Update laser pointer on mouse move
+     */
+    manipulate(point: IPoint): void;
+    /**
+     * Updates cursor visibility and position
+     */
+    private updateCursorVisibility;
+    /**
+     * Show on mouse down
+     */
+    pointerDown(point: IPoint, target?: EventTarget, ev?: PointerEvent): void;
+    /**
+     * Hide on mouse up
+     */
+    pointerUp(point: IPoint, ev?: PointerEvent): void;
+    /**
+     * Override select to ensure cursor is set correctly
+     */
+    select(): void;
+    /**
+     * Override deselect to restore default cursor
+     */
+    deselect(): void;
+    /**
+     * When user switches to a different tool or finishes using this tool
+     */
+    dispose(): void;
+}
+export {};

package/lib/apps/collection-player/composables/markerjs.use.d.ts

@@ -0,0 +1,8 @@
+import { MarkerBaseEditor, MarkerBase } from '@markerjs/markerjs3';
+export declare const useMarkerjs3: () => Promise<{
+    markerjs3: typeof import("@markerjs/markerjs3");
+    laserPointer: {
+        LaserPointerMarkerEditor: typeof MarkerBaseEditor<MarkerBase>;
+        LaserPointerMarker: typeof MarkerBase;
+    };
+}>;

package/lib/apps/collection-player/composables/new-zoom.use.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+import { CollectionSlide } from '../types/collection-player.type';
+import { useAnnotationLayer } from './annotation-layer.use.ts';
+declare const _default: (annotationLayer: ReturnType<typeof useAnnotationLayer>, activeSlide: Ref<CollectionSlide | null>) => {
+    zoom: Ref<number, number>;
+    isZoomEnabled: import('vue').ComputedRef<boolean | null>;
+    resetZoom: () => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    onZoomChangeEvent: () => void;
+};
+export default _default;

package/lib/apps/collection-player/stores/app.store.d.ts

@@ -3,11 +3,13 @@ import { CollectionGroup, CollectionPlayer, CollectionSlide } from '../types/col
 import { default as Swiper } from 'swiper';
 import { File } from '../../../../types/openapi';
 import { default as useZoom } from '../composables/zoom.use';
+import { default as useNewZoom } from '../composables/new-zoom.use';
 import { default as useFullscreen } from '../composables/fullscreen.use';
 import { CollectionFileEntity, NodeInfo } from '../../canvas-builder/types/canvas';
 import { ActionCallback, default as useKeyboardBindings } from '../composables/keyboard-bindings.use';
 import { default as useSlideDirection } from '../composables/slide-direction.use';
 import { useCacheNavigation } from '../composables/navigation-cache.use';
+import { useAnnotationLayer } from '../composables/annotation-layer.use';
 export type RenderPageAsImage = (payload: {
     fileId: File['id'];
     documentId?: File['id'];
@@ -52,7 +54,7 @@ type StoreData = {
     swiperElement: Ref<(HTMLElement & {
         swiper: Swiper;
     }) | null>;
-    zoom: ReturnType<typeof useZoom>;
+    zoom: ReturnType<typeof useZoom | typeof useNewZoom>;
     fullscreen: ReturnType<typeof useFullscreen>;
     data: Ref<CollectionPlayer>;
     visibleGroups: ComputedRef<CollectionGroup[]>;
@@ -76,6 +78,7 @@ type StoreData = {
     cacheNavigation: ReturnType<typeof useCacheNavigation>;
     nodeId?: string;
     handleKeyAction: ActionCallback;
+    annotationLayer: ReturnType<typeof useAnnotationLayer>;
 };
 export declare function provideAppStore({ data, isEditMode, rootElement, api, emit, options, isLoading, nodeId, inModal, }: StorePayload): StoreData;
 export declare function useAppStore(): StoreData;

package/lib/apps/collection-selector/App.vue.d.ts

@@ -0,0 +1,33 @@
+import { CollectionPlayer, CollectionSlide } from '../collection-player/types/collection-player.type';
+import { CollectionSelectorProps } from './types/collection-selector.type';
+export type Emit = {
+    close: [CollectionPlayer];
+    settings: [CollectionPlayer];
+    cancel: [];
+    contentChange: [CollectionSlide];
+};
+declare const _default: import('vue').DefineComponent<CollectionSelectorProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    settings: (args_0: CollectionPlayer) => any;
+    cancel: () => any;
+    close: (args_0: CollectionPlayer) => any;
+    contentChange: (args_0: CollectionSlide) => any;
+}, string, import('vue').PublicProps, Readonly<CollectionSelectorProps> & Readonly<{
+    onSettings?: ((args_0: CollectionPlayer) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+    onClose?: ((args_0: CollectionPlayer) => any) | undefined;
+    onContentChange?: ((args_0: CollectionSlide) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    contentRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<import('vue-draggable-plus').VueDraggableProps>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        [x: string]: any;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<import('vue-draggable-plus').VueDraggableProps>>, {}, {}, import('vue').ComputedOptions, import('vue').MethodOptions, {
+        [x: string]: any;
+    }> | null;
+}, any>;
+export default _default;

package/lib/apps/content-selector/appTypes.d.ts

@@ -11,6 +11,7 @@ export type AppProps = {
     allowedAssetContentTypes?: FileContentTypeEnum[];
     allowedIds?: File['id'][];
     allowedOriginalExtensions?: string[];
+    allowMultimediaSelectorApp?: boolean;
     contentType: 'file' | 'slide' | 'content';
     initialMetadataFilters?: Record<string, any>;
     zIndex?: number;

package/lib/apps/content-selector/components/Content/AllContent/List/FoldersFilesList.vue.d.ts

@@ -1,42 +1,194 @@
 declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     wrapperRef: HTMLDivElement;
     toolbarWrapperRef: HTMLDivElement;
-    searchFiltersRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
-        disabled?: boolean;
-        engagingIds?: string[];
-        entity: import('../../../../../../main.lib').MetadataFilterRequest["entity"];
-        includeDraftValues?: boolean;
-        isSection?: import('../../../../../../main.lib').MetadataFilterRequest["is_section"];
-        isTemplate?: import('../../../../../../main.lib').MetadataFilterRequest["is_template"];
-        searchInOptions?: import('../../../../../../components/CSearchFilters/CSearchFilters.types').SearchInOption[];
-        filters?: Record<string, any>;
-        initialSearchValue?: string;
-        ownerId?: number | null;
-        placeholder?: string;
-        popularIds?: string[];
-        recommendedIds?: string[];
-        showLatestFilter?: boolean;
-        hideMetadataFilters?: boolean;
-        hideFilters?: boolean;
-        customFilterComponents?: {
-            type: import('../../../../../../../types/openapi').MetadataTemplateFieldTypeEnum;
-            name: string;
-            label: string;
-            options?: [];
-        }[];
-        enableDependentFilters?: boolean;
-        dependentFiltersEntity?: "file" | "canvas";
-    }> & Readonly<{
-        "onUpdate:search"?: ((search: string, filters?: Record<string, any> | undefined) => any) | undefined;
-        "onUpdate:filters"?: ((filters: Record<string, any>) => any) | undefined;
-        "onUpdate:searchIn"?: ((searchIn: string) => any) | undefined;
-    }>, {
-        clearSearch: () => void;
-    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-        "update:search": (search: string, filters?: Record<string, any> | undefined) => any;
-        "update:filters": (filters: Record<string, any>) => any;
-        "update:searchIn": (searchIn: string) => any;
-    }, import('vue').PublicProps, {
+    searchFiltersRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly disabled?: boolean | undefined;
+            readonly engagingIds?: string[] | undefined;
+            readonly entity: import('../../../../../../main.lib').MetadataFilterRequest["entity"];
+            readonly includeDraftValues?: boolean | undefined;
+            readonly isSection?: boolean | undefined;
+            readonly isTemplate?: boolean | undefined;
+            readonly searchInOptions?: import('../../../../../../components/CSearchFilters/CSearchFilters.types').SearchInOption[] | undefined;
+            readonly filters?: Record<string, any> | undefined;
+            readonly initialSearchValue?: string | undefined;
+            readonly ownerId?: number | null | undefined;
+            readonly placeholder?: string | undefined;
+            readonly popularIds?: string[] | undefined;
+            readonly recommendedIds?: string[] | undefined;
+            readonly showLatestFilter?: boolean | undefined;
+            readonly hideMetadataFilters?: boolean | undefined;
+            readonly hideFilters?: boolean | undefined;
+            readonly customFilterComponents?: {
+                type: import('../../../../../../../types/openapi').MetadataTemplateFieldTypeEnum;
+                name: string;
+                label: string;
+                options?: [];
+            }[] | undefined;
+            readonly enableDependentFilters?: boolean | undefined;
+            readonly dependentFiltersEntity?: "file" | "canvas" | undefined;
+            readonly "onUpdate:search"?: ((search: string, filters?: Record<string, any> | undefined) => any) | undefined;
+            readonly "onUpdate:filters"?: ((filters: Record<string, any>) => any) | undefined;
+            readonly "onUpdate:searchIn"?: ((searchIn: string) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            searchOnClickRef: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: {
+                    readonly disabled?: boolean | undefined;
+                    readonly placeholder?: string | undefined;
+                    readonly fullWidth?: boolean | undefined;
+                    readonly initialSearchValue?: string | undefined;
+                    readonly onSearch?: ((s: string) => any) | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: "search", s: string) => void;
+                $el: HTMLDivElement;
+                $options: import('vue').ComponentOptionsBase<Readonly<{
+                    disabled?: boolean;
+                    placeholder?: string;
+                    fullWidth?: boolean;
+                    initialSearchValue?: string;
+                }> & Readonly<{
+                    onSearch?: ((s: string) => any) | undefined;
+                }>, {
+                    clear: () => Promise<void>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    search: (s: string) => any;
+                }, string, {
+                    initialSearchValue: string;
+                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                    beforeCreate?: (() => void) | (() => void)[];
+                    created?: (() => void) | (() => void)[];
+                    beforeMount?: (() => void) | (() => void)[];
+                    mounted?: (() => void) | (() => void)[];
+                    beforeUpdate?: (() => void) | (() => void)[];
+                    updated?: (() => void) | (() => void)[];
+                    activated?: (() => void) | (() => void)[];
+                    deactivated?: (() => void) | (() => void)[];
+                    beforeDestroy?: (() => void) | (() => void)[];
+                    beforeUnmount?: (() => void) | (() => void)[];
+                    destroyed?: (() => void) | (() => void)[];
+                    unmounted?: (() => void) | (() => void)[];
+                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof import('vue').nextTick;
+                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+            } & Readonly<{
+                initialSearchValue: string;
+            }> & Omit<Readonly<{
+                disabled?: boolean;
+                placeholder?: string;
+                fullWidth?: boolean;
+                initialSearchValue?: string;
+            }> & Readonly<{
+                onSearch?: ((s: string) => any) | undefined;
+            }>, "clear" | "initialSearchValue"> & import('vue').ShallowUnwrapRef<{
+                clear: () => Promise<void>;
+            }> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    options?(_: {}): any;
+                };
+            }) | null;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "update:search", search: string, filters?: Record<string, any> | undefined) => void) & ((event: "update:filters", filters: Record<string, any>) => void) & ((event: "update:searchIn", searchIn: string) => void);
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            disabled?: boolean;
+            engagingIds?: string[];
+            entity: import('../../../../../../main.lib').MetadataFilterRequest["entity"];
+            includeDraftValues?: boolean;
+            isSection?: import('../../../../../../main.lib').MetadataFilterRequest["is_section"];
+            isTemplate?: import('../../../../../../main.lib').MetadataFilterRequest["is_template"];
+            searchInOptions?: import('../../../../../../components/CSearchFilters/CSearchFilters.types').SearchInOption[];
+            filters?: Record<string, any>;
+            initialSearchValue?: string;
+            ownerId?: number | null;
+            placeholder?: string;
+            popularIds?: string[];
+            recommendedIds?: string[];
+            showLatestFilter?: boolean;
+            hideMetadataFilters?: boolean;
+            hideFilters?: boolean;
+            customFilterComponents?: {
+                type: import('../../../../../../../types/openapi').MetadataTemplateFieldTypeEnum;
+                name: string;
+                label: string;
+                options?: [];
+            }[];
+            enableDependentFilters?: boolean;
+            dependentFiltersEntity?: "file" | "canvas";
+        }> & Readonly<{
+            "onUpdate:search"?: ((search: string, filters?: Record<string, any> | undefined) => any) | undefined;
+            "onUpdate:filters"?: ((filters: Record<string, any>) => any) | undefined;
+            "onUpdate:searchIn"?: ((searchIn: string) => any) | undefined;
+        }>, {
+            clearSearch: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:search": (search: string, filters?: Record<string, any> | undefined) => any;
+            "update:filters": (filters: Record<string, any>) => any;
+            "update:searchIn": (searchIn: string) => any;
+        }, string, {
+            filters: Record<string, any>;
+            placeholder: string;
+            initialSearchValue: string;
+            includeDraftValues: boolean;
+            engagingIds: string[];
+            popularIds: string[];
+            recommendedIds: string[];
+            showLatestFilter: boolean;
+            hideMetadataFilters: boolean;
+            hideFilters: boolean;
+            dependentFiltersEntity: "file" | "canvas";
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
         filters: Record<string, any>;
         placeholder: string;
         initialSearchValue: string;
@@ -48,88 +200,7 @@ declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import
         hideMetadataFilters: boolean;
         hideFilters: boolean;
         dependentFiltersEntity: "file" | "canvas";
-    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
-        searchOnClickRef: ({
-            $: import('vue').ComponentInternalInstance;
-            $data: {};
-            $props: {
-                readonly disabled?: boolean | undefined;
-                readonly placeholder?: string | undefined;
-                readonly fullWidth?: boolean | undefined;
-                readonly initialSearchValue?: string | undefined;
-                readonly onSearch?: ((s: string) => any) | undefined;
-            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
-            $attrs: {
-                [x: string]: unknown;
-            };
-            $refs: {
-                [x: string]: unknown;
-            };
-            $slots: Readonly<{
-                [name: string]: import('vue').Slot<any> | undefined;
-            }>;
-            $root: import('vue').ComponentPublicInstance | null;
-            $parent: import('vue').ComponentPublicInstance | null;
-            $host: Element | null;
-            $emit: (event: "search", s: string) => void;
-            $el: HTMLDivElement;
-            $options: import('vue').ComponentOptionsBase<Readonly<{
-                disabled?: boolean;
-                placeholder?: string;
-                fullWidth?: boolean;
-                initialSearchValue?: string;
-            }> & Readonly<{
-                onSearch?: ((s: string) => any) | undefined;
-            }>, {
-                clear: () => Promise<void>;
-            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-                search: (s: string) => any;
-            }, string, {
-                initialSearchValue: string;
-            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
-                beforeCreate?: (() => void) | (() => void)[];
-                created?: (() => void) | (() => void)[];
-                beforeMount?: (() => void) | (() => void)[];
-                mounted?: (() => void) | (() => void)[];
-                beforeUpdate?: (() => void) | (() => void)[];
-                updated?: (() => void) | (() => void)[];
-                activated?: (() => void) | (() => void)[];
-                deactivated?: (() => void) | (() => void)[];
-                beforeDestroy?: (() => void) | (() => void)[];
-                beforeUnmount?: (() => void) | (() => void)[];
-                destroyed?: (() => void) | (() => void)[];
-                unmounted?: (() => void) | (() => void)[];
-                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
-            };
-            $forceUpdate: () => void;
-            $nextTick: typeof import('vue').nextTick;
-            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
-        } & Readonly<{
-            initialSearchValue: string;
-        }> & Omit<Readonly<{
-            disabled?: boolean;
-            placeholder?: string;
-            fullWidth?: boolean;
-            initialSearchValue?: string;
-        }> & Readonly<{
-            onSearch?: ((s: string) => any) | undefined;
-        }>, "clear" | "initialSearchValue"> & import('vue').ShallowUnwrapRef<{
-            clear: () => Promise<void>;
-        }> & {} & import('vue').ComponentCustomProperties & {} & {
-            $slots: {
-                options?(_: {}): any;
-            };
-        }) | null;
-    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<{
+    }> & Omit<Readonly<{
         disabled?: boolean;
         engagingIds?: string[];
         entity: import('../../../../../../main.lib').MetadataFilterRequest["entity"];
@@ -158,20 +229,12 @@ declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import
         "onUpdate:search"?: ((search: string, filters?: Record<string, any> | undefined) => any) | undefined;
         "onUpdate:filters"?: ((filters: Record<string, any>) => any) | undefined;
         "onUpdate:searchIn"?: ((searchIn: string) => any) | undefined;
-    }>, {
+    }>, "clearSearch" | ("filters" | "placeholder" | "initialSearchValue" | "includeDraftValues" | "engagingIds" | "popularIds" | "recommendedIds" | "showLatestFilter" | "hideMetadataFilters" | "hideFilters" | "dependentFiltersEntity")> & import('vue').ShallowUnwrapRef<{
         clearSearch: () => void;
-    }, {}, {}, {}, {
-        filters: Record<string, any>;
-        placeholder: string;
-        initialSearchValue: string;
-        includeDraftValues: boolean;
-        engagingIds: string[];
-        popularIds: string[];
-        recommendedIds: string[];
-        showLatestFilter: boolean;
-        hideMetadataFilters: boolean;
-        hideFilters: boolean;
-        dependentFiltersEntity: "file" | "canvas";
-    }> | null;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            'input-suffix'?(_: {}): any;
+        };
+    }) | null;
 }, HTMLDivElement>;
 export default _default;

package/lib/apps/content-selector/components/MultimediaSelectorApp.vue.d.ts

@@ -0,0 +1,12 @@
+import { MultimediaSelectorItem } from '../composables/useMultimediaSelectorApps';
+type __VLS_Props = {
+    appId: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    add: (item: MultimediaSelectorItem) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAdd?: ((item: MultimediaSelectorItem) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    iframeRef: HTMLIFrameElement;
+}, HTMLDivElement>;
+export default _default;

package/lib/apps/content-selector/components/ThemeImages.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/lib/apps/content-selector/components/ui/GridItem.vue.d.ts

@@ -17,6 +17,8 @@ type __VLS_Props = {
         created_by_user_id?: User['id'];
     };
     isSelected?: boolean;
+    isDeleteDisabled?: boolean;
+    deleteDisabledTooltip?: string;
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     itemSelected: (...args: any[]) => void;
@@ -48,5 +50,7 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
         content_extension?: string | null;
         created_by_user_id?: User["id"];
     };
+    isDeleteDisabled: boolean;
+    deleteDisabledTooltip: string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;