@pitcher/js-api 1.23.0 → 1.24.0-beta.0

package/lib/apps/{canvas-builder/components/ui/CollectionPlayer → collection-player}/components/MainImage.vue.d.ts

@@ -1,13 +1,13 @@
-import { CollectionSelectorSlide } from '../../../../types/canvas';
+import { CollectionSlide } from '../types/collection-player.type';
 declare const _default: import('vue').DefineComponent<{
     fitToContainerWidth: boolean;
     isActive: boolean;
     zoom: number;
-    item: CollectionSelectorSlide;
+    item: CollectionSlide;
 }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
     fitToContainerWidth: boolean;
     isActive: boolean;
     zoom: number;
-    item: CollectionSelectorSlide;
+    item: CollectionSlide;
 }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/lib/apps/collection-player/components/TableOfContents.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, {}, any>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import { Ref } from 'vue';
+type UseFocusTrapOptions = {
+    preventFocusLostOnly: boolean;
+};
+export default function useFocusTrap(element: Ref<HTMLElement | null>, options?: UseFocusTrapOptions): {
+    enable: () => void;
+    disable: () => void;
+};
+export {};

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

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+type FullscreenPayload = {
+    rootElement: Ref<HTMLElement | null>;
+};
+declare const _default: ({ rootElement }: FullscreenPayload) => {
+    isFullscreen: Ref<boolean, boolean>;
+    enterFullscreen: () => void;
+    exitFullscreen: () => void;
+};
+export default _default;

package/lib/apps/{canvas-builder/components/ui/CollectionPlayer/composables/gestures.use.d.ts → collection-player/composables/moving-group-gestures.use.d.ts}

@@ -1,9 +1,12 @@
 import { Ref } from 'vue';
 import { UseSwipeDirection } from '@vueuse/core';
+import { AxisDirection } from './slide-direction.use';
 declare const _default: (element: Ref<HTMLElement | null>, actions: {
-    onSwipeLeft: () => void;
-    onSwipeRight: () => void;
-}) => {
+    onSwipeLeft?: () => void;
+    onSwipeRight?: () => void;
+    onSwipeUp?: () => void;
+    onSwipeDown?: () => void;
+}, slideAxis: Ref<AxisDirection | undefined>) => {
     touchDirection: import('vue').ComputedRef<UseSwipeDirection>;
     gestureStyling: import('vue').ComputedRef<{
         transform: string;

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

@@ -0,0 +1,11 @@
+import { Api } from '../stores/app.store';
+import { CollectionGroup } from '../types/collection-player.type';
+export declare enum AxisDirection {
+    HORIZONTAL = "horizontal",
+    VERTICAL = "vertical"
+}
+declare const _default: (api: Api) => {
+    direction: import('vue').Ref<AxisDirection | undefined, AxisDirection | undefined>;
+    updateSlideDirection: (groups: CollectionGroup[]) => Promise<void>;
+};
+export default _default;

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

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+import { CollectionSlide } from '../types/collection-player.type';
+import { Api } from '../stores/app.store';
+declare const _default: ({ nodeId, isSwiperVisible, activeSlide, api: { onFileEnter, onFileExit, onFilePageEnter, onFilePageExit }, }: {
+    nodeId: string | undefined;
+    isSwiperVisible: Ref<boolean>;
+    activeSlide: Ref<CollectionSlide | null>;
+    api: Api;
+}) => void;
+export default _default;

package/lib/apps/{canvas-builder/components/ui/CollectionPlayer → collection-player}/composables/zoom.use.d.ts

@@ -1,10 +1,10 @@
 import { Ref } from 'vue';
 import { default as Swiper } from 'swiper';
-import { CollectionSelectorSlide } from '../../../../types/canvas';
+import { CollectionSlide } from '../types/collection-player.type';
 type SwiperElement = HTMLElement & {
     swiper: Swiper;
 };
-declare const _default: (swiperElement: Ref<SwiperElement | null>, activeSlide: Ref<CollectionSelectorSlide | null>) => {
+declare const _default: (swiperElement: Ref<SwiperElement | null>, activeSlide: Ref<CollectionSlide | null>) => {
     zoom: Ref<number, number>;
     isZoomEnabled: import('vue').ComputedRef<boolean | null>;
     resetZoom: () => void;

package/lib/apps/collection-player/export.d.ts

@@ -0,0 +1,3 @@
+export * from './stores/app.store';
+export * from './types/collection-player.type';
+export * from './utils/node.util';

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

@@ -0,0 +1,77 @@
+import { EmitFn, Ref, ComputedRef } from 'vue';
+import { CollectionGroup, CollectionPlayer, CollectionSlide } from '../types/collection-player.type';
+import { default as Swiper } from 'swiper';
+import { File } from '../../../../types/openapi';
+import { default as useZoom } from '../composables/zoom.use';
+import { default as useFullscreen } from '../composables/fullscreen.use';
+import { CollectionFileEntity, NodeInfo } from '../../canvas-builder/types/canvas';
+import { default as useArrowKeys } from '../composables/arrow-keys.use';
+import { default as useSlideDirection } from '../composables/slide-direction.use';
+export type RenderPageAsImage = (payload: {
+    fileId: File['id'];
+    documentId?: File['id'];
+    pageIndex: number;
+    params: {
+        width: number;
+    } | {
+        height: number;
+    };
+}) => Promise<ArrayBuffer>;
+export type Api = {
+    renderPageAsImage: RenderPageAsImage;
+    onFileEnter?: (node: NodeInfo, file: CollectionFileEntity) => void;
+    onFileExit?: (node: NodeInfo, file: CollectionFileEntity) => void;
+    onFilePageEnter?: (node: NodeInfo, file: CollectionFileEntity, pageIndex: number) => void;
+    onFilePageExit?: (node: NodeInfo, file: CollectionFileEntity, pageIndex: number) => void;
+};
+export type Options = {
+    videoStartTime?: number;
+};
+export type Emit = {
+    close: [];
+    click: [event: MouseEvent];
+};
+type StorePayload = {
+    isLoading: Ref<boolean>;
+    inModal: Ref<boolean>;
+    isEditMode: Ref<boolean>;
+    data: Ref<CollectionPlayer>;
+    rootElement: Ref<HTMLElement | null>;
+    api: Api;
+    emit: EmitFn<Emit>;
+    options?: Options;
+};
+type StoreData = {
+    isLoading: Ref<boolean>;
+    inModal: Ref<boolean>;
+    fitToWidth: Ref<boolean>;
+    isEditMode: Ref<boolean>;
+    isOpenTableOfContents: Ref<boolean>;
+    swiperElement: Ref<(HTMLElement & {
+        swiper: Swiper;
+    }) | null>;
+    zoom: ReturnType<typeof useZoom>;
+    fullscreen: ReturnType<typeof useFullscreen>;
+    data: Ref<CollectionPlayer>;
+    visibleGroups: ComputedRef<CollectionGroup[]>;
+    isNotInModalOrIsInModalWithManyGroups: ComputedRef<boolean>;
+    activeSlide: Ref<CollectionSlide | null>;
+    activeGroup: Ref<CollectionGroup | null>;
+    setActiveSlide: (group?: CollectionGroup, slide?: CollectionSlide) => void;
+    onSlideChange: (customEvent: CustomEvent<[swiper: Swiper]>) => void;
+    activatePreviousGroup: () => void;
+    activateNextGroup: () => void;
+    toggleTableOfContents: () => void;
+    toggleFitToWidth: () => void;
+    allowTouchMove: (value: boolean) => void;
+    isSwiperVisible: Ref<boolean>;
+    setSwiperVisibility: (isVisible: boolean) => void;
+    api: Api;
+    arrowKeys: ReturnType<typeof useArrowKeys>;
+    slideDirection: ReturnType<typeof useSlideDirection>;
+    closeApp: () => void;
+    options?: Options;
+};
+export declare function provideAppStore({ data, isEditMode, rootElement, api, emit, inModal, options, isLoading, }: StorePayload): StoreData;
+export declare function useAppStore(): StoreData;
+export {};

package/lib/apps/collection-player/types/collection-player.type.d.ts

@@ -0,0 +1,26 @@
+import { FileRetrieve } from '../../../../types/openapi';
+import { CollectionFileEntity } from '../../canvas-builder/types/canvas';
+export type CollectionPage = {
+    id: string;
+    type: 'slide';
+    file: CollectionFileEntity;
+    slide: {
+        index: number;
+        url: FileRetrieve['thumbnail_url'];
+    };
+};
+export type CollectionFile = {
+    id: string;
+    type: 'file';
+    file: CollectionFileEntity;
+};
+export type CollectionSlide = CollectionPage | CollectionFile;
+export type CollectionGroup = {
+    id: string;
+    name: string;
+    slides: CollectionSlide[];
+};
+export type CollectionPlayer = {
+    groups: CollectionGroup[];
+    name: string;
+};

package/lib/apps/collection-player/utils/node.util.d.ts

@@ -0,0 +1,4 @@
+import { CollectionPlayer, CollectionSlide } from '../types/collection-player.type';
+export declare const generateNewCollection: (t: (key: string, values?: Record<string, string | number>) => string) => CollectionPlayer;
+export declare const generateNewCollectionStructure: () => CollectionPlayer;
+export declare const getUniqueSlides: (uniqueSlides: CollectionSlide[], newSlides: CollectionSlide[]) => CollectionSlide[];

package/lib/apps/collection-player/utils/slide-type.util.d.ts

@@ -0,0 +1,5 @@
+import { CollectionSlide } from '../types/collection-player.type';
+export declare const isVideo: (slide?: CollectionSlide) => boolean;
+export declare const isImage: (slide?: CollectionSlide) => boolean;
+export declare const isWeb: (slide?: CollectionSlide) => boolean;
+export declare const isSlide: (slide?: CollectionSlide) => slide is import('../types/collection-player.type').CollectionPage;

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

@@ -0,0 +1,29 @@
+import { FileRetrieve } from '../../../types/openapi';
+import { CollectionPlayer, CollectionSlide } from '../collection-player/types/collection-player.type';
+import { FetchFileList, SelectFileContent } from './types/common.type';
+declare const _default: import('vue').DefineComponent<{
+    zIndex?: number;
+    attachTo?: string | HTMLElement;
+    initialData?: CollectionPlayer;
+    selectFileContent: SelectFileContent;
+    openSettings?: () => void;
+    fetchFile: (id: string) => Promise<FileRetrieve>;
+    fetchFileList: FetchFileList;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: () => any;
+    close: (args_0: CollectionPlayer) => any;
+    contentChange: (args_0: CollectionSlide) => any;
+}, string, import('vue').PublicProps, Readonly<{
+    zIndex?: number;
+    attachTo?: string | HTMLElement;
+    initialData?: CollectionPlayer;
+    selectFileContent: SelectFileContent;
+    openSettings?: () => void;
+    fetchFile: (id: string) => Promise<FileRetrieve>;
+    fetchFileList: FetchFileList;
+}> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onClose?: ((args_0: CollectionPlayer) => any) | undefined;
+    onContentChange?: ((args_0: CollectionSlide) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/apps/collection-selector/components/AppFooter.vue.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: () => any;
+    close: () => any;
+}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/lib/apps/collection-selector/components/AppHeader.vue.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/lib/apps/collection-selector/components/CollectionGroup.vue.d.ts

@@ -0,0 +1,7 @@
+import { CollectionGroup } from '../../collection-player/types/collection-player.type';
+declare const _default: import('vue').DefineComponent<{
+    group: CollectionGroup;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    group: CollectionGroup;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/apps/collection-selector/components/CollectionItem.vue.d.ts

@@ -0,0 +1,21 @@
+import { CollectionSlide } from '../../collection-player/types/collection-player.type';
+declare const _default: import('vue').DefineComponent<{
+    item: CollectionSlide;
+    isFirst?: boolean;
+    isLast?: boolean;
+    disabledMoveToGroup?: boolean;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    moveUp: () => any;
+    moveDown: () => any;
+    moveToGroup: () => any;
+}, string, import('vue').PublicProps, Readonly<{
+    item: CollectionSlide;
+    isFirst?: boolean;
+    isLast?: boolean;
+    disabledMoveToGroup?: boolean;
+}> & Readonly<{
+    onMoveUp?: (() => any) | undefined;
+    onMoveDown?: (() => any) | undefined;
+    onMoveToGroup?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/apps/collection-selector/components/CollectionToolbar.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, {}, any>;
+export default _default;

package/lib/apps/{canvas-builder/components/ui/CollectionPlayer/CollectionGroupSelector.vue.d.ts → collection-selector/components/modals/MoveSlideModal.vue.d.ts}

@@ -1,21 +1,15 @@
-import { CollectionSelectorGroup, CollectionSelectorSlide } from '../../../types/canvas';
+import { CollectionGroup, CollectionSlide } from '../../../collection-player/types/collection-player.type';
 declare const _default: import('vue').DefineComponent<{
-    groups: CollectionSelectorGroup[];
-    data: {
-        groupId: string;
-        slide: CollectionSelectorSlide;
-    } | null;
+    zIndex?: number;
+    groups: CollectionGroup[];
 }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     close: () => any;
-    moveToGroup: (fromGroup: string, toGroup: string, slide: CollectionSelectorSlide) => any;
+    moveToGroup: (fromGroup: string, toGroup: string, slide: CollectionSlide) => any;
 }, string, import('vue').PublicProps, Readonly<{
-    groups: CollectionSelectorGroup[];
-    data: {
-        groupId: string;
-        slide: CollectionSelectorSlide;
-    } | null;
+    zIndex?: number;
+    groups: CollectionGroup[];
 }> & Readonly<{
     onClose?: (() => any) | undefined;
-    onMoveToGroup?: ((fromGroup: string, toGroup: string, slide: CollectionSelectorSlide) => any) | undefined;
+    onMoveToGroup?: ((fromGroup: string, toGroup: string, slide: CollectionSlide) => any) | undefined;
 }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/lib/apps/collection-selector/composables/move-slide-modal.use.d.ts

@@ -0,0 +1,106 @@
+import { ComputedRef, Ref } from 'vue';
+import { ActiveElement } from '../types/move-slide-modal.type';
+type MoveItemModal = {
+    open: (type: ActiveElement) => void;
+    close: () => void;
+    isOpen: Readonly<ComputedRef<boolean>>;
+    activeElement: Readonly<Ref<ActiveElement | null>>;
+};
+export declare function provideMoveSlideModal(): {
+    isOpen: ComputedRef<boolean>;
+    activeElement: Ref<{
+        groupId: string;
+        slide: {
+            id: string;
+            type: "slide";
+            file: {
+                metadata?: Record<string, any> | undefined;
+                readonly id: string;
+                name?: string | undefined;
+                readonly type: import('../../../main.lib').FileTypeEnum;
+                readonly thumbnail_url: string | null;
+                permissions?: {
+                    can_download?: boolean | undefined;
+                    can_share?: boolean | undefined;
+                } | undefined;
+                readonly content_url: string | null;
+                readonly content_type: import('../../../main.lib').FileContentTypeEnum;
+                readonly pspdfkit_auth_payload: Record<string, any> | null;
+                readonly pspdfkit_document_id: string | null;
+                readonly pspdfkit_server_url: string | null;
+            };
+            slide: {
+                index: number;
+                url: import('../../../main.lib').FileRetrieve["thumbnail_url"];
+            };
+        } | {
+            id: string;
+            type: "file";
+            file: {
+                metadata?: Record<string, any> | undefined;
+                readonly id: string;
+                name?: string | undefined;
+                readonly type: import('../../../main.lib').FileTypeEnum;
+                readonly thumbnail_url: string | null;
+                permissions?: {
+                    can_download?: boolean | undefined;
+                    can_share?: boolean | undefined;
+                } | undefined;
+                readonly content_url: string | null;
+                readonly content_type: import('../../../main.lib').FileContentTypeEnum;
+                readonly pspdfkit_auth_payload: Record<string, any> | null;
+                readonly pspdfkit_document_id: string | null;
+                readonly pspdfkit_server_url: string | null;
+            };
+        };
+    } | null, ActiveElement | {
+        groupId: string;
+        slide: {
+            id: string;
+            type: "slide";
+            file: {
+                metadata?: Record<string, any> | undefined;
+                readonly id: string;
+                name?: string | undefined;
+                readonly type: import('../../../main.lib').FileTypeEnum;
+                readonly thumbnail_url: string | null;
+                permissions?: {
+                    can_download?: boolean | undefined;
+                    can_share?: boolean | undefined;
+                } | undefined;
+                readonly content_url: string | null;
+                readonly content_type: import('../../../main.lib').FileContentTypeEnum;
+                readonly pspdfkit_auth_payload: Record<string, any> | null;
+                readonly pspdfkit_document_id: string | null;
+                readonly pspdfkit_server_url: string | null;
+            };
+            slide: {
+                index: number;
+                url: import('../../../main.lib').FileRetrieve["thumbnail_url"];
+            };
+        } | {
+            id: string;
+            type: "file";
+            file: {
+                metadata?: Record<string, any> | undefined;
+                readonly id: string;
+                name?: string | undefined;
+                readonly type: import('../../../main.lib').FileTypeEnum;
+                readonly thumbnail_url: string | null;
+                permissions?: {
+                    can_download?: boolean | undefined;
+                    can_share?: boolean | undefined;
+                } | undefined;
+                readonly content_url: string | null;
+                readonly content_type: import('../../../main.lib').FileContentTypeEnum;
+                readonly pspdfkit_auth_payload: Record<string, any> | null;
+                readonly pspdfkit_document_id: string | null;
+                readonly pspdfkit_server_url: string | null;
+            };
+        };
+    } | null>;
+    open: (type: ActiveElement) => void;
+    close: () => null;
+};
+export declare function useMoveSlideModal(): MoveItemModal;
+export {};

package/lib/apps/collection-selector/composables/table-input.use.d.ts

@@ -0,0 +1,15 @@
+import { Ref } from 'vue';
+type TableInput = {
+    activeInputId: Ref<string | null>;
+    setActiveInput: (id: string) => void;
+    clearActiveInput: () => void;
+    getInputState: (isEdit: boolean) => 'edit' | 'view';
+};
+export declare function provideTableInput(): {
+    activeInputId: Ref<string | null, string | null>;
+    setActiveInput: (id: string) => string;
+    clearActiveInput: () => void;
+    getInputState: (isEdit: boolean) => "edit" | "view";
+};
+export declare function useTableInput(): TableInput;
+export {};

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

@@ -0,0 +1,156 @@
+import { Ref } from 'vue';
+import { default as useConfirmation } from '../../../composables/useConfirmation';
+import { CollectionGroup, CollectionPlayer, CollectionSlide } from '../../collection-player/types/collection-player.type';
+import { FetchFileList, SelectFileContent } from '../types/common.type';
+import { File, FileRetrieve, FileContentTypeEnum } from '../../../../types/openapi';
+type StorePayload = {
+    initialCollection?: CollectionPlayer;
+    t: (key: string, values?: Record<string, string | number>) => string;
+    confirmation: ReturnType<typeof useConfirmation>;
+    selectFileContent: SelectFileContent;
+    attachTo?: HTMLElement | string;
+    openSettings?: () => void;
+    fetchFile: (id: string) => Promise<FileRetrieve>;
+    fetchFileList: FetchFileList;
+    zIndex?: number;
+};
+type StoreData = {
+    collection: Ref<CollectionPlayer>;
+    expandedGroups: Ref<string[]>;
+    usedFiles: Ref<Record<File['id'], File>>;
+    addGroup: (group?: Partial<CollectionGroup>) => CollectionGroup | undefined;
+    deleteGroup: (groupId: string, groupName: string) => void;
+    updateGroup: (group: Partial<Omit<CollectionGroup, 'id'>> & Pick<CollectionGroup, 'id'>) => void;
+    updateGroups: (groups: CollectionGroup[]) => void;
+    updateSlides: (groupId: string, slides: CollectionSlide[]) => void;
+    updateCollectionName: (name: string) => void;
+    updateGroupName: (groupId: string, name: string) => void;
+    deleteSlide: (groupId: string, slide: CollectionSlide) => void;
+    addSlides: (groupId: string) => Promise<CollectionSlide[] | undefined>;
+    moveSlideToGroup: (fromGroup: string, toGroup: string, slide: CollectionSlide) => void;
+    selectFileContent: SelectFileContent;
+    openSettings?: () => void;
+    fetchFile: (id: string) => Promise<FileRetrieve>;
+    fetchFileList: FetchFileList;
+    childModalZIndex?: number;
+};
+export declare function provideAppStore({ initialCollection, t, confirmation, selectFileContent, attachTo, openSettings, fetchFile, fetchFileList, zIndex, }: StorePayload): {
+    collection: Ref<{
+        groups: {
+            id: string;
+            name: string;
+            slides: ({
+                id: string;
+                type: "slide";
+                file: {
+                    metadata?: Record<string, any> | undefined;
+                    readonly id: string;
+                    name?: string | undefined;
+                    readonly type: import('../../../../types/openapi').FileTypeEnum;
+                    readonly thumbnail_url: string | null;
+                    permissions?: {
+                        can_download?: boolean | undefined;
+                        can_share?: boolean | undefined;
+                    } | undefined;
+                    readonly content_url: string | null;
+                    readonly content_type: FileContentTypeEnum;
+                    readonly pspdfkit_auth_payload: Record<string, any> | null;
+                    readonly pspdfkit_document_id: string | null;
+                    readonly pspdfkit_server_url: string | null;
+                };
+                slide: {
+                    index: number;
+                    url: FileRetrieve["thumbnail_url"];
+                };
+            } | {
+                id: string;
+                type: "file";
+                file: {
+                    metadata?: Record<string, any> | undefined;
+                    readonly id: string;
+                    name?: string | undefined;
+                    readonly type: import('../../../../types/openapi').FileTypeEnum;
+                    readonly thumbnail_url: string | null;
+                    permissions?: {
+                        can_download?: boolean | undefined;
+                        can_share?: boolean | undefined;
+                    } | undefined;
+                    readonly content_url: string | null;
+                    readonly content_type: FileContentTypeEnum;
+                    readonly pspdfkit_auth_payload: Record<string, any> | null;
+                    readonly pspdfkit_document_id: string | null;
+                    readonly pspdfkit_server_url: string | null;
+                };
+            })[];
+        }[];
+        name: string;
+    }, CollectionPlayer | {
+        groups: {
+            id: string;
+            name: string;
+            slides: ({
+                id: string;
+                type: "slide";
+                file: {
+                    metadata?: Record<string, any> | undefined;
+                    readonly id: string;
+                    name?: string | undefined;
+                    readonly type: import('../../../../types/openapi').FileTypeEnum;
+                    readonly thumbnail_url: string | null;
+                    permissions?: {
+                        can_download?: boolean | undefined;
+                        can_share?: boolean | undefined;
+                    } | undefined;
+                    readonly content_url: string | null;
+                    readonly content_type: FileContentTypeEnum;
+                    readonly pspdfkit_auth_payload: Record<string, any> | null;
+                    readonly pspdfkit_document_id: string | null;
+                    readonly pspdfkit_server_url: string | null;
+                };
+                slide: {
+                    index: number;
+                    url: FileRetrieve["thumbnail_url"];
+                };
+            } | {
+                id: string;
+                type: "file";
+                file: {
+                    metadata?: Record<string, any> | undefined;
+                    readonly id: string;
+                    name?: string | undefined;
+                    readonly type: import('../../../../types/openapi').FileTypeEnum;
+                    readonly thumbnail_url: string | null;
+                    permissions?: {
+                        can_download?: boolean | undefined;
+                        can_share?: boolean | undefined;
+                    } | undefined;
+                    readonly content_url: string | null;
+                    readonly content_type: FileContentTypeEnum;
+                    readonly pspdfkit_auth_payload: Record<string, any> | null;
+                    readonly pspdfkit_document_id: string | null;
+                    readonly pspdfkit_server_url: string | null;
+                };
+            })[];
+        }[];
+        name: string;
+    }>;
+    expandedGroups: Ref<string[], string[]>;
+    selectFileContent: SelectFileContent;
+    openSettings: (() => void) | undefined;
+    fetchFile: (id: string) => Promise<FileRetrieve>;
+    fetchFileList: FetchFileList;
+    usedFiles: Ref<Record<string, File>, Record<string, File>>;
+    childModalZIndex: number | undefined;
+    addGroup: (group?: Partial<CollectionGroup>) => CollectionGroup | undefined;
+    deleteGroup: (groupId: string, groupName: string) => void;
+    updateGroup: (group: Partial<Omit<CollectionGroup, "id">> & Pick<CollectionGroup, "id">) => void;
+    updateGroups: (groups: CollectionGroup[]) => void;
+    updateSlides: (groupId: string, slides: CollectionSlide[]) => void;
+    updateCollectionName: (name: string) => void;
+    updateGroupName: (groupId: string, name: string) => void;
+    deleteSlide: (groupId: string, slide: CollectionSlide) => void;
+    addSlides: (groupId: string) => Promise<(import('../../collection-player/types/collection-player.type').CollectionPage | import('../../collection-player/types/collection-player.type').CollectionFile)[] | undefined>;
+    moveSlideToGroup: (fromGroup: string, toGroup: string, slide: CollectionSlide) => void;
+};
+export declare function useAppStore(): StoreData;
+export {};

package/lib/apps/collection-selector/types/collection-selector.type.d.ts

@@ -0,0 +1,12 @@
+import { CollectionPlayer } from '../../collection-player/types/collection-player.type';
+import { FetchFileList, SelectFileContent } from './common.type';
+import { FileRetrieve } from '../../../../types/openapi';
+export type CollectionSelectorProps = {
+    zIndex?: number;
+    attachTo?: string | HTMLElement;
+    initialData?: CollectionPlayer;
+    selectFileContent: SelectFileContent;
+    openSettings?: () => void;
+    fetchFile: (id: string) => Promise<FileRetrieve>;
+    fetchFileList: FetchFileList;
+};

package/lib/apps/collection-selector/types/common.type.d.ts

@@ -0,0 +1,18 @@
+import { SelectedFile, SelectedPage, SelectorType } from '../../content-selector/stores/app';
+import { File, FileContentTypeEnum } from '../../../../types/openapi';
+import { Selection } from '../../../types/selections';
+export type SelectFileContent = (payload: {
+    attachTo?: HTMLElement | string;
+    selections?: Selection[];
+    allowedSelectorTypes?: SelectorType[];
+    allowedContentTypes?: FileContentTypeEnum[];
+    allowedAssetContentTypes?: FileContentTypeEnum[];
+}) => Promise<{
+    user_action: string;
+    content?: (SelectedFile | SelectedPage)[];
+}>;
+export type FetchFileList = <T extends {
+    filters: {
+        id__in: string;
+    };
+}>(payload: T) => Promise<File[]>;