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

package/lib/components/themes/CThemeManagement.vue.d.ts

@@ -33,15 +33,41 @@ declare function __VLS_template(): {
             hideCreate?: boolean;
             hideView?: boolean;
             isLoadingItems?: boolean;
-            modelValue: string;
+            search: string;
+            metadataFilterValues: Record<string, any>;
+            tableColumnsSettings: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting[];
+            customFilterComponents?: {
+                type: import('../../../types/openapi').MetadataTemplateFieldTypeEnum;
+                name: string;
+                label: string;
+                options?: [];
+            }[];
         }> & Readonly<{
-            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onSearch?: ((value: string) => any) | undefined;
+            onSelect?: ((payload: {
+                id: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting["id"];
+                checked: boolean;
+            }) => any) | undefined;
+            onMove?: ((payload: {
+                targetItemId: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting["id"];
+                itemId: string;
+            }) => any) | undefined;
             onCreate?: (() => any) | undefined;
             onRestoreColumns?: (() => any) | undefined;
+            "onUpdate:filter-values"?: ((value: Record<string, any>) => any) | undefined;
         }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-            "update:modelValue": (value: string) => any;
+            search: (value: string) => any;
+            select: (payload: {
+                id: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting["id"];
+                checked: boolean;
+            }) => any;
+            move: (payload: {
+                targetItemId: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting["id"];
+                itemId: string;
+            }) => any;
             create: () => any;
             restoreColumns: () => any;
+            "update:filter-values": (value: Record<string, any>) => any;
         }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
             P: {};
             B: {};
@@ -53,11 +79,28 @@ declare function __VLS_template(): {
             hideCreate?: boolean;
             hideView?: boolean;
             isLoadingItems?: boolean;
-            modelValue: string;
+            search: string;
+            metadataFilterValues: Record<string, any>;
+            tableColumnsSettings: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting[];
+            customFilterComponents?: {
+                type: import('../../../types/openapi').MetadataTemplateFieldTypeEnum;
+                name: string;
+                label: string;
+                options?: [];
+            }[];
         }> & Readonly<{
-            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onSearch?: ((value: string) => any) | undefined;
+            onSelect?: ((payload: {
+                id: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting["id"];
+                checked: boolean;
+            }) => any) | undefined;
+            onMove?: ((payload: {
+                targetItemId: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting["id"];
+                itemId: string;
+            }) => any) | undefined;
             onCreate?: (() => any) | undefined;
             onRestoreColumns?: (() => any) | undefined;
+            "onUpdate:filter-values"?: ((value: Record<string, any>) => any) | undefined;
         }>, {}, {}, {}, {}, {}> | null;
         tableRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
             selectedRows?: Record<string, boolean>;
@@ -95,8 +138,6 @@ declare function __VLS_template(): {
             selectedRowsCount: ComputedRef<number>;
             pageRowsCount: ComputedRef<number>;
             isRowDisabled: (id: string | number) => boolean;
-            saveScrollPosition: () => void;
-            restoreScrollPosition: () => void;
         }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
             sortChanged: (s: SortingState) => any;
             pageChanged: (p: PaginationState) => any;
@@ -121,6 +162,7 @@ declare function __VLS_template(): {
             disabledIds: Array<string | number>;
         }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
             tableScroller: HTMLDivElement;
+            tableElement: HTMLTableElement;
         }, HTMLDivElement, import('vue').ComponentProvideOptions, {
             P: {};
             B: {};
@@ -164,8 +206,6 @@ declare function __VLS_template(): {
             selectedRowsCount: ComputedRef<number>;
             pageRowsCount: ComputedRef<number>;
             isRowDisabled: (id: string | number) => boolean;
-            saveScrollPosition: () => void;
-            restoreScrollPosition: () => void;
         }, {}, {}, {}, {
             data: {
                 [x: string]: any;
@@ -205,15 +245,41 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
         hideCreate?: boolean;
         hideView?: boolean;
         isLoadingItems?: boolean;
-        modelValue: string;
+        search: string;
+        metadataFilterValues: Record<string, any>;
+        tableColumnsSettings: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting[];
+        customFilterComponents?: {
+            type: import('../../../types/openapi').MetadataTemplateFieldTypeEnum;
+            name: string;
+            label: string;
+            options?: [];
+        }[];
     }> & Readonly<{
-        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onSearch?: ((value: string) => any) | undefined;
+        onSelect?: ((payload: {
+            id: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting["id"];
+            checked: boolean;
+        }) => any) | undefined;
+        onMove?: ((payload: {
+            targetItemId: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting["id"];
+            itemId: string;
+        }) => any) | undefined;
         onCreate?: (() => any) | undefined;
         onRestoreColumns?: (() => any) | undefined;
+        "onUpdate:filter-values"?: ((value: Record<string, any>) => any) | undefined;
     }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-        "update:modelValue": (value: string) => any;
+        search: (value: string) => any;
+        select: (payload: {
+            id: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting["id"];
+            checked: boolean;
+        }) => any;
+        move: (payload: {
+            targetItemId: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting["id"];
+            itemId: string;
+        }) => any;
         create: () => any;
         restoreColumns: () => any;
+        "update:filter-values": (value: Record<string, any>) => any;
     }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
         P: {};
         B: {};
@@ -225,11 +291,28 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
         hideCreate?: boolean;
         hideView?: boolean;
         isLoadingItems?: boolean;
-        modelValue: string;
+        search: string;
+        metadataFilterValues: Record<string, any>;
+        tableColumnsSettings: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting[];
+        customFilterComponents?: {
+            type: import('../../../types/openapi').MetadataTemplateFieldTypeEnum;
+            name: string;
+            label: string;
+            options?: [];
+        }[];
     }> & Readonly<{
-        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onSearch?: ((value: string) => any) | undefined;
+        onSelect?: ((payload: {
+            id: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting["id"];
+            checked: boolean;
+        }) => any) | undefined;
+        onMove?: ((payload: {
+            targetItemId: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting["id"];
+            itemId: string;
+        }) => any) | undefined;
         onCreate?: (() => any) | undefined;
         onRestoreColumns?: (() => any) | undefined;
+        "onUpdate:filter-values"?: ((value: Record<string, any>) => any) | undefined;
     }>, {}, {}, {}, {}, {}> | null;
     tableRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
         selectedRows?: Record<string, boolean>;
@@ -267,8 +350,6 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
         selectedRowsCount: ComputedRef<number>;
         pageRowsCount: ComputedRef<number>;
         isRowDisabled: (id: string | number) => boolean;
-        saveScrollPosition: () => void;
-        restoreScrollPosition: () => void;
     }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
         sortChanged: (s: SortingState) => any;
         pageChanged: (p: PaginationState) => any;
@@ -293,6 +374,7 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
         disabledIds: Array<string | number>;
     }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
         tableScroller: HTMLDivElement;
+        tableElement: HTMLTableElement;
     }, HTMLDivElement, import('vue').ComponentProvideOptions, {
         P: {};
         B: {};
@@ -336,8 +418,6 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
         selectedRowsCount: ComputedRef<number>;
         pageRowsCount: ComputedRef<number>;
         isRowDisabled: (id: string | number) => boolean;
-        saveScrollPosition: () => void;
-        restoreScrollPosition: () => void;
     }, {}, {}, {}, {
         data: {
             [x: string]: any;

package/lib/components/themes/CThemeManagementToolbar.vue.d.ts

@@ -1,16 +1,44 @@
+import { TableColumnSetting } from '../CTableColumnsSettings/CTableColumnsSettings.vue';
+import { MetadataTemplateFieldTypeEnum } from '../../../types/openapi';
 type __VLS_Props = {
     hideCreate?: boolean;
     hideView?: boolean;
     isLoadingItems?: boolean;
-    modelValue: string;
+    search: string;
+    metadataFilterValues: Record<string, any>;
+    tableColumnsSettings: TableColumnSetting[];
+    customFilterComponents?: {
+        type: MetadataTemplateFieldTypeEnum;
+        name: string;
+        label: string;
+        options?: [];
+    }[];
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-    "update:modelValue": (value: string) => any;
+    search: (value: string) => any;
+    select: (payload: {
+        id: TableColumnSetting["id"];
+        checked: boolean;
+    }) => any;
+    move: (payload: {
+        targetItemId: TableColumnSetting["id"];
+        itemId: string;
+    }) => any;
     create: () => any;
     restoreColumns: () => any;
+    "update:filter-values": (value: Record<string, any>) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onSearch?: ((value: string) => any) | undefined;
+    onSelect?: ((payload: {
+        id: TableColumnSetting["id"];
+        checked: boolean;
+    }) => any) | undefined;
+    onMove?: ((payload: {
+        targetItemId: TableColumnSetting["id"];
+        itemId: string;
+    }) => any) | undefined;
     onCreate?: (() => any) | undefined;
     onRestoreColumns?: (() => any) | undefined;
+    "onUpdate:filter-values"?: ((value: Record<string, any>) => any) | undefined;
 }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

package/lib/composables/appsDb.use.d.ts

@@ -31,9 +31,9 @@ export declare function useAppsDb(payload?: UseAppsDbPayload): {
     } & {
         value: Record<string, any>;
     }>;
-    deleteEntry: (params: EntryParams) => Promise<import('axios').AxiosResponse<void, any>>;
+    deleteEntry: (params: EntryParams) => Promise<import('axios').AxiosResponse<void, any, {}>>;
     upsertGlobalEntry: (payload: UpsertGlobalEntryParams) => Promise<AppsDBEntry>;
     getGlobalEntry: (params: GlobalEntryParams) => Promise<AppsDBEntry>;
-    deleteGlobalEntry: (params: GlobalEntryParams) => Promise<import('axios').AxiosResponse<void, any>>;
+    deleteGlobalEntry: (params: GlobalEntryParams) => Promise<import('axios').AxiosResponse<void, any, {}>>;
 };
 export {};

package/lib/composables/bulkActions.use.d.ts

@@ -1,5 +1,5 @@
-import { BulkDeleteRequest, BulkDeleteResponse, BulkUpdateTagsRequest, BulkUpdateTags, BulkUpdateMetadataRequest, BulkUpdateMetadata } from '../../types/openapi';
-export default function useBulkActions(): {
+import { BulkDeleteRequest, BulkDeleteResponse, BulkUpdateTagsRequest, BulkUpdateTags, BulkUpdateMetadataRequest, BulkUpdateMetadata, MiniFile } from '../../types/openapi';
+export default function useBulkActions(emit?: (event: 'filesDeleted', ids: MiniFile['id'][]) => void): {
     deleteCanvases: (payload: BulkDeleteRequest) => Promise<BulkDeleteResponse>;
     deleteFiles: (payload: BulkDeleteRequest) => Promise<BulkDeleteResponse>;
     deleteFolders: (payload: BulkDeleteRequest) => Promise<BulkDeleteResponse>;

package/lib/composables/useBindValidation.d.ts

@@ -1,6 +1,6 @@
 import { Validation } from '@vuelidate/core';
-import { FormValidationStatus } from 'naive-ui/es/form/src/interface';
 import { Ref } from 'vue';
+type FormValidationStatus = 'error' | 'warning' | 'success';
 /**
  * Options for validators.
  */

package/lib/composables/useBroadcastRouteChange.d.ts

@@ -0,0 +1,4 @@
+export declare function broadcastRouteChangedEvent(routeName: string, routePath: string): Promise<void>;
+export default function useBroadcastRouteChange(): {
+    broadcastRouteChangedEvent: typeof broadcastRouteChangedEvent;
+};

package/lib/composables/useCanvasStandardFilters.d.ts

@@ -0,0 +1,35 @@
+import { MetadataTemplateFieldTypeEnum } from '../../types/openapi';
+export interface CanvasStandardFiltersOptions {
+    /**
+     * Include the "Tags" filter (default: true)
+     */
+    includeTagsFilter?: boolean;
+    /**
+     * Include the "Draft" filter (default: true)
+     */
+    includeDraftFilter?: boolean;
+    /**
+     * Include the "Template Used" filter (only for saved canvases)
+     */
+    includeTemplateFilter?: boolean;
+    /**
+     * Include the "Owner" filter
+     */
+    includeOwnerFilter?: boolean;
+    /**
+     * Custom label for the Owner filter (defaults to "Owner")
+     */
+    ownerLabel?: string;
+}
+/**
+ * Composable that returns standard filter components for canvas management views
+ * @param options Configuration options for which filters to include
+ * @returns Array of filter component configurations
+ */
+export declare function useCanvasStandardFilters(options?: CanvasStandardFiltersOptions): {
+    filterComponents: import('vue').ComputedRef<{
+        type: MetadataTemplateFieldTypeEnum;
+        name: string;
+        label: string;
+    }[]>;
+};

package/lib/composables/useCollectionPlayerOverlay.d.ts

@@ -0,0 +1,18 @@
+import { CollectionPlayer } from '../apps/collection-player/types/collection-player.type';
+export interface CollectionPlayerOverlayGroup {
+    id: string;
+    name: string;
+    slides?: Array<{
+        file_id: string;
+        slide_index: number;
+    }>;
+}
+export interface CollectionPlayerOverlay {
+    groups: CollectionPlayerOverlayGroup[];
+    name: string;
+}
+declare const _default: () => {
+    setCollectionPlayerData: import('vue').Ref<((data: CollectionPlayer) => void) | null, ((data: CollectionPlayer) => void) | null>;
+    openCollectionPlayerOverlay: (data: CollectionPlayerOverlay, fetchFile: (fileId: string) => Promise<any>) => Promise<void>;
+};
+export default _default;

package/lib/composables/useDeleteUsedCanvasesConfirmation.d.ts

@@ -0,0 +1,23 @@
+import { ViewCompactFileFolder } from '../types/files';
+import { FolderDeleter, FileDeleter } from '../apps/browser/stores/api';
+import { ActionKeys } from '../apps/browser/types/actionKeys';
+export default function useDeleteUsedCanvasesConfirmation(): {
+    getDeleteConfirmationConfig: ({ item, deleteFunction, action, onAfterDelete, }: {
+        item: ViewCompactFileFolder;
+        deleteFunction: FolderDeleter | FileDeleter;
+        action: ActionKeys.DeleteFile | ActionKeys.DeleteFolder;
+        onAfterDelete?: () => void;
+    }) => Promise<{
+        title: string;
+        content: () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+            [key: string]: any;
+        }>;
+        confirmText: string;
+        cancelText: string;
+        onConfirm: () => Promise<void>;
+        style?: {
+            width: string;
+        } | undefined;
+        hasExit: boolean;
+    }>;
+};

package/lib/composables/useElementSizeAfterDom.d.ts

@@ -0,0 +1,5 @@
+import { Ref } from 'vue';
+export default function useElementSizeAfterDom(targetRef: Ref<HTMLElement | null>): {
+    clientWidth: Ref<number, number>;
+    clientHeight: Ref<number, number>;
+};

package/lib/composables/useFileDisplayHelpers.d.ts

@@ -2,10 +2,14 @@ import { ViewCompactItemType, ViewCompactFolder } from '../types/files';
 import { CoreFolderEntityType } from '../types/folder';
 import { FileContentTypeEnum } from '../../types/openapi';
 export default function useFileDisplayHelpers(): {
-    getFolderDescription: (item: Omit<Partial<ViewCompactFolder>, "type"> & {
+    getFolderDescription: (item: (Omit<Partial<ViewCompactFolder>, "type"> & {
         type?: ViewCompactItemType.Folder | ViewCompactItemType.SmartFolder;
-    }, { entity }?: {
+    }) & {
+        available_files_count?: number;
+        available_folders_count?: number;
+    }, { entity, hideFilesCount }?: {
         entity?: CoreFolderEntityType;
+        hideFilesCount?: boolean;
     }) => string;
     renderContentType: (contentType: FileContentTypeEnum) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
         [key: string]: any;

package/lib/composables/useFileInfo.d.ts

@@ -0,0 +1,30 @@
+import { FileRetrieve } from '../../types/openapi';
+export interface ResolveFileIdsOptions {
+    chunkSize?: number;
+}
+export interface ResolveRequest {
+    ids: string[];
+    entity: 'file' | 'canvas';
+    instance_id: string;
+}
+export interface ResolveResponse {
+    objects: Record<string, FileRetrieve | null>;
+    found_count: number;
+    total_count: number;
+}
+export interface UseFileInfoOptions {
+    listFetcher?: (args: {
+        filters: {
+            id__in: string;
+        };
+    }) => Promise<FileRetrieve[] | {
+        results: FileRetrieve[];
+    }>;
+    fetchById?: (id: FileRetrieve['id']) => Promise<FileRetrieve>;
+    resolveFetcher?: (request: ResolveRequest) => Promise<ResolveResponse>;
+    instanceId?: string;
+}
+export default function useFileInfo(options?: UseFileInfoOptions): {
+    filesById: import('vue').Ref<Record<string, FileRetrieve>, Record<string, FileRetrieve>>;
+    resolveFileIds: (ids: FileRetrieve["id"][], fetcher?: UseFileInfoOptions["listFetcher"] | UseFileInfoOptions["fetchById"], opts?: ResolveFileIdsOptions) => Promise<FileRetrieve[]>;
+};

package/lib/composables/useFilterSuggestions.d.ts

@@ -0,0 +1,48 @@
+import { ComputedRef, Ref } from 'vue';
+import { MetadataFilterRequest } from '../types/core/MetadataFilter';
+export interface FilterSuggestion {
+    name: string;
+    displayName: string;
+    usageCount?: number;
+}
+interface FilterSuggestionsData {
+    suggestions: FilterSuggestion[];
+    hasMore?: boolean;
+}
+interface FilterConstraint {
+    key: string;
+    value: string;
+}
+interface UseFilterSuggestionsOptions {
+    entity?: MetadataFilterRequest['entity'];
+    filterKey?: string;
+    includeDraftValues?: boolean;
+    isSection?: boolean;
+    isTemplate?: boolean;
+    ownerId?: number | null;
+    limit?: number;
+}
+export default function useFilterSuggestions(options?: UseFilterSuggestionsOptions): {
+    suggestionsData: Ref<{
+        suggestions: {
+            name: string;
+            displayName: string;
+            usageCount?: number | undefined;
+        }[];
+        hasMore?: boolean | undefined;
+    }, FilterSuggestionsData | {
+        suggestions: {
+            name: string;
+            displayName: string;
+            usageCount?: number | undefined;
+        }[];
+        hasMore?: boolean | undefined;
+    }>;
+    isLoading: Ref<boolean, boolean>;
+    isEnabled: ComputedRef<boolean | undefined>;
+    fetchSuggestions: (currentFilters?: Record<string, any>) => Promise<FilterSuggestionsData>;
+    debouncedFetch: (currentFilters?: Record<string, any>, delay?: number) => Promise<FilterSuggestionsData>;
+    buildConstraints: (currentFilters: Record<string, any>, excludeCurrentField?: boolean) => FilterConstraint[];
+    cleanup: () => void;
+};
+export {};

package/lib/composables/useFolderNameDescription.d.ts

@@ -0,0 +1,25 @@
+import { ComputedRef } from 'vue';
+interface NameDescription {
+    name: string;
+    description: string;
+}
+/**
+ * Composable for parsing folder/file names with conditional description support
+ *
+ * When `enable_folder_description_via_name` setting is enabled:
+ * - Names like "Folder name | Folder description" are parsed
+ * - Returns { name: "Folder name", description: "Folder description" }
+ *
+ * When setting is disabled:
+ * - Returns original name without parsing
+ * - Returns { name: "Full name", description: "" }
+ */
+export default function useFolderNameDescription(): {
+    isEnabled: ComputedRef<boolean>;
+    isFolderNameDescriptionEnabled: ComputedRef<boolean>;
+    parseNameDescription: (nameString: string) => NameDescription;
+    createNameDescription: (nameRef: ComputedRef<string>) => ComputedRef<NameDescription>;
+    createNameDescriptionForItem: (nameRef: ComputedRef<string>, itemTypeRef: ComputedRef<string>) => ComputedRef<NameDescription>;
+    parseNameOnly: (nameString: string) => string;
+};
+export {};

package/lib/composables/useImageAccessibility.d.ts

@@ -0,0 +1,13 @@
+import { ComputedRef } from 'vue';
+interface UseImageAccessibilityOptions {
+    thumbnailUrl: ComputedRef<string | null>;
+    hasAIEnabled: ComputedRef<boolean>;
+    hasFile: ComputedRef<boolean>;
+}
+export default function useImageAccessibility({ thumbnailUrl, hasAIEnabled, hasFile }: UseImageAccessibilityOptions): {
+    imageAccessible: import('vue').Ref<boolean | null, boolean | null>;
+    hasValidThumbnail: ComputedRef<boolean>;
+    handleImageError: () => void;
+    checkImageAccessibility: () => Promise<void>;
+};
+export {};

package/lib/composables/useLegacyCollectionFileLoader.d.ts

@@ -0,0 +1,31 @@
+import { FileRetrieve } from '../../types/openapi';
+export interface FileLoadingState {
+    id: string;
+    name?: string;
+    isLoading: boolean;
+    isLoaded: boolean;
+    file?: FileRetrieve;
+    error?: string;
+}
+export default function useLegacyCollectionFileLoader(): {
+    fileStates: import('vue').ComputedRef<Record<string, FileLoadingState>>;
+    filesById: import('vue').ComputedRef<Record<string, FileRetrieve>>;
+    initializeFiles: (fileIds: string[], fileNames?: Record<string, string>) => void;
+    loadFile: (fileId: string) => Promise<FileRetrieve | null>;
+    loadAllFiles: (fileIds: string[]) => Promise<void>;
+    getFile: (fileId: string) => FileRetrieve | undefined;
+    getFileState: (fileId: string) => FileLoadingState | undefined;
+    getFileName: (fileId: string) => string | undefined;
+    isFileLoaded: (fileId: string) => boolean;
+    isFileLoading: (fileId: string) => boolean;
+    hasFileFailed: (fileId: string) => boolean;
+    isFileResolved: (fileId: string) => boolean;
+    reset: () => void;
+    getLoadingStats: () => {
+        total: number;
+        loaded: number;
+        loading: number;
+        failed: number;
+        pending: number;
+    };
+};

package/lib/composables/useMetadataSearch.d.ts

@@ -1,10 +1,17 @@
 import { MetadataFilterRequest, MetadataSearchParams } from '../types/core/MetadataFilter';
 import { StyledAutoCompleteOption } from '../types/search';
+export declare const SEARCH_TERM_PREFIX = "__search_term__";
+interface MetadataUniqueValuesResponse {
+    popular: Array<StyledAutoCompleteOption & {
+        usage_count: number;
+    }>;
+    all: StyledAutoCompleteOption[];
+}
 interface UseMetadataSearchOptions {
     includeSearchTermAsOption?: boolean;
 }
 export default function useMetadataSearch(options?: UseMetadataSearchOptions): {
-    handleFetch: (searchTerm: string, entity: MetadataFilterRequest["entity"], { includeNameSearch, includeDraftValues, isSection, isTemplate, isBlock, key, ownerId, searchMode, threshold, fetchAllUnique, }?: {
+    handleFetch: (searchTerm: string, entity: MetadataFilterRequest["entity"], { includeNameSearch, includeDraftValues, isSection, isTemplate, isBlock, key, ownerId, searchMode, threshold, fetchAllUnique, contentType, }?: {
         includeNameSearch?: boolean;
         includeDraftValues?: boolean;
         isSection?: boolean;
@@ -15,6 +22,20 @@ export default function useMetadataSearch(options?: UseMetadataSearchOptions): {
         searchMode?: MetadataSearchParams["searchMode"];
         threshold?: number;
         fetchAllUnique?: boolean;
+        contentType?: string[];
     }) => Promise<StyledAutoCompleteOption[]>;
+    fetchUniqueValues: (entity: MetadataFilterRequest["entity"], { includeDraftValues, isSection, isTemplate, isBlock, key, ownerId, limit, and, }?: {
+        includeDraftValues?: boolean;
+        isSection?: boolean;
+        isTemplate?: boolean;
+        isBlock?: boolean;
+        key?: MetadataSearchParams["key"];
+        ownerId?: number | null;
+        limit?: number;
+        and?: Array<{
+            key: string;
+            value: string;
+        }>;
+    }) => Promise<MetadataUniqueValuesResponse>;
 };
 export {};

package/lib/composables/usePolling.d.ts

@@ -0,0 +1,23 @@
+import { Ref } from 'vue';
+interface UsePollingOptions {
+    interval: number;
+    cleanupTimeout?: number;
+    executeImmediately?: boolean;
+}
+interface UsePollingReturn {
+    isPolling: Ref<boolean>;
+    startPolling: (pollFn: () => Promise<boolean>) => void;
+    stopPolling: () => void;
+}
+/**
+ * Generic polling composable that can poll any async function
+ *
+ * By default, polling waits for the first interval before executing.
+ * Set executeImmediately: true to execute immediately when startPolling is called,
+ * then continue at the specified interval.
+ *
+ * @param options - Configuration with required interval, optional cleanup timeout, and execution behavior
+ * @returns Object with polling state and control methods
+ */
+export declare function usePolling(options: UsePollingOptions): UsePollingReturn;
+export {};

package/lib/composables/useWindowEvents.d.ts

@@ -6,6 +6,7 @@ export type InactiveEventPayload = {
     platform?: (typeof PLATFORM_TYPE)[keyof typeof PLATFORM_TYPE];
     client?: (typeof CLIENT_TYPE)[keyof typeof CLIENT_TYPE];
     pair_id?: string;
+    file_id?: string;
     [key: string]: any;
 };
 export default function (track: (eventName: string, payload: any) => void, pitcherApi?: ReturnType<typeof usePitcherApi>): {

package/lib/constants/cdp.const.d.ts

@@ -10,6 +10,8 @@ export declare const CDP_EVENT_TYPE: {
     readonly appExited: "App Exited";
     readonly canvasEntered: "Canvas Entered";
     readonly canvasExited: "Canvas Exited";
+    readonly wizardEntered: "Wizard Entered";
+    readonly wizardExited: "Wizard Exited";
     readonly canvasShared: "Canvas Shared";
     readonly customerSentimentCaptured: "Customer Sentiment Captured";
     readonly canvasPageEntered: "Canvas Page Entered";

package/lib/constants/dimensions.const.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Gotenberg-supported dimension units for PDF conversion.
+ * Reference: https://gotenberg.dev/docs/routes#page-properties
+ *
+ * Gotenberg supports: 72pt, 96px, 1in, 25.4mm, 2.54cm, or 6pc.
+ * Default unit is inches if unspecified.
+ */
+export declare const GOTENBERG_DIMENSION_UNITS: readonly ["mm", "cm", "in", "px", "pt", "pc"];
+export type GotenbergDimensionUnit = (typeof GOTENBERG_DIMENSION_UNITS)[number];
+/**
+ * Regex pattern for matching dimension values with Gotenberg-supported units.
+ * Supports both comma and period as decimal separators (e.g., "10.5mm" or "10,5mm").
+ */
+export declare const GOTENBERG_DIMENSION_PATTERN: string;
+/**
+ * Conversion rates from various units to pixels (CSS standard).
+ * - 1 inch = 96 pixels
+ * - 1 cm = 37.795275591 pixels
+ * - 1 mm = 3.7795275591 pixels
+ * - 1 pt = 1.333333 pixels
+ * - 1 pc = 16 pixels
+ */
+export declare const DIMENSION_TO_PIXEL_CONVERSION: Record<GotenbergDimensionUnit, number>;