@pitcher/js-api 1.24.0-beta.3 → 1.25.0-beta.0

package/lib/components/canvas-templates/CTemplateManagementActionsCell.vue.d.ts

@@ -1,44 +1,48 @@
-declare const _default: import('vue').DefineComponent<{
+type __VLS_Props = {
     hideCopy?: boolean;
     hideEdit?: boolean;
     hideDelete?: boolean;
+    hideMove?: boolean;
+    hideView?: boolean;
     hideViewDetails?: boolean;
     hideViewNewTab?: boolean;
     hideCreateFromTemplate?: boolean;
     hideToggleDefault?: boolean;
+    hideToggleStatus?: boolean;
     isCopying?: boolean;
     isDeleting?: boolean;
     isDefault?: boolean;
-}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    delete: () => any;
-    duplicate: () => any;
-    edit: () => any;
+    isDraft?: boolean;
+    hideLock?: boolean;
+    canvasId: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     copy: () => any;
     view: () => any;
+    delete: () => any;
+    edit: () => any;
+    move: () => any;
+    duplicate: () => any;
     viewNewTab: () => any;
     viewDetails: () => any;
     createFromTemplate: () => any;
     toggleDefault: () => any;
-}, string, import('vue').PublicProps, Readonly<{
-    hideCopy?: boolean;
-    hideEdit?: boolean;
-    hideDelete?: boolean;
-    hideViewDetails?: boolean;
-    hideViewNewTab?: boolean;
-    hideCreateFromTemplate?: boolean;
-    hideToggleDefault?: boolean;
-    isCopying?: boolean;
-    isDeleting?: boolean;
-    isDefault?: boolean;
-}> & Readonly<{
-    onDelete?: (() => any) | undefined;
-    onDuplicate?: (() => any) | undefined;
-    onEdit?: (() => any) | undefined;
+    toggleStatus: () => any;
+    lock: () => any;
+    unlock: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onCopy?: (() => any) | undefined;
     onView?: (() => any) | undefined;
+    onDelete?: (() => any) | undefined;
+    onEdit?: (() => any) | undefined;
+    onMove?: (() => any) | undefined;
+    onDuplicate?: (() => any) | undefined;
     onViewNewTab?: (() => any) | undefined;
     onViewDetails?: (() => any) | undefined;
     onCreateFromTemplate?: (() => any) | undefined;
     onToggleDefault?: (() => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+    onToggleStatus?: (() => any) | undefined;
+    onLock?: (() => any) | undefined;
+    onUnlock?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

package/lib/components/canvas-templates/CTemplateManagementActionsCellIconWrapper.vue.d.ts

@@ -1,15 +1,10 @@
 import { FontAwesomeType } from '../../apps/canvas-builder/types/font-awesome.types';
-declare const _default: import('vue').DefineComponent<{
+type __VLS_Props = {
     icon: string;
     tooltip: string;
     faType: FontAwesomeType;
     color: string;
     iconColor: string;
-}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
-    icon: string;
-    tooltip: string;
-    faType: FontAwesomeType;
-    color: string;
-    iconColor: string;
-}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/lib/components/canvas-templates/CTemplateManagementListItem.vue.d.ts

@@ -0,0 +1,54 @@
+type __VLS_Props = {
+    highlightText?: string;
+    doNotShowFolderDetails?: boolean;
+    isContextMenuOpen?: boolean;
+    isDraggedOver?: boolean;
+    isSelected?: boolean;
+    isReadonly?: boolean;
+    item: {
+        [key: string]: any;
+        id: number | string;
+    };
+    selectedItemIds: string[];
+    popularityDict: Record<string, any>;
+    recommendedSectionIds: string[];
+    isEditingCurrentItem: (id: string | number, prop: 'name' | 'tags') => boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        actions?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    edit: (id: string | number, prop: "name" | "tags") => any;
+    updateName: (id: string, value: string) => any;
+    updateTags: (id: string, value: string[]) => any;
+    toggleItemSelection: (item: any, options: {
+        disableMultiple: boolean;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onEdit?: ((id: string | number, prop: "name" | "tags") => any) | undefined;
+    onUpdateName?: ((id: string, value: string) => any) | undefined;
+    onUpdateTags?: ((id: string, value: string[]) => any) | undefined;
+    onToggleItemSelection?: ((item: any, options: {
+        disableMultiple: boolean;
+    }) => any) | undefined;
+}>, {
+    isSelected: boolean;
+    highlightText: string;
+    isReadonly: boolean;
+    isContextMenuOpen: boolean;
+    isDraggedOver: boolean;
+    doNotShowFolderDetails: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/canvas-templates/CTemplateManagementToolbar.vue.d.ts

@@ -1,8 +1,14 @@
 import { TableColumnSetting } from '../CTableColumnsSettings/CTableColumnsSettings.vue';
 import { MetadataTemplateFieldTypeEnum } from '../../../types/openapi';
-declare const _default: import('vue').DefineComponent<{
+import { CanvasType } from '../../types/canvases';
+type __VLS_Props = {
+    breadcrumbs: {
+        id: string;
+        name: string;
+    }[];
+    canvasType: Exclude<CanvasType, 'section' | 'canvas' | 'block'>;
     search: string;
-    filterValues: Record<string, any>;
+    metadataFilterValues: Record<string, any>;
     recommendedIds: string[];
     tableColumnsSettings: TableColumnSetting[];
     customFilterComponents: {
@@ -12,9 +18,20 @@ declare const _default: import('vue').DefineComponent<{
         options?: [];
     }[];
     hideCreate?: boolean;
+    hideConvert?: boolean;
     hideView?: boolean;
     isLoadingItems?: boolean;
-}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    isTemplateFolderEnabled?: boolean;
+    currentSort?: {
+        field: string;
+        order: 'asc' | 'desc';
+    };
+    viewMode?: 'table' | 'list';
+};
+declare function clearSearch(): void;
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    clearSearch: typeof clearSearch;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     search: (s: string) => any;
     select: (payload: {
         id: TableColumnSetting["id"];
@@ -25,23 +42,17 @@ declare const _default: import('vue').DefineComponent<{
         itemId: string;
     }) => any;
     restoreColumns: () => any;
+    "sort-changed": (sort: {
+        field: string;
+        order: "asc" | "desc";
+    }) => any;
     "create:template": () => any;
+    "create:folder": () => any;
+    convert: () => any;
     "update:filter-values": (mf: Record<string, any>) => any;
-}, string, import('vue').PublicProps, Readonly<{
-    search: string;
-    filterValues: Record<string, any>;
-    recommendedIds: string[];
-    tableColumnsSettings: TableColumnSetting[];
-    customFilterComponents: {
-        type: MetadataTemplateFieldTypeEnum;
-        name: string;
-        label: string;
-        options?: [];
-    }[];
-    hideCreate?: boolean;
-    hideView?: boolean;
-    isLoadingItems?: boolean;
-}> & Readonly<{
+    "breadcrumb:click": (id: string | null) => any;
+    "toggle-view-mode": () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onSearch?: ((s: string) => any) | undefined;
     onSelect?: ((payload: {
         id: TableColumnSetting["id"];
@@ -52,7 +63,197 @@ declare const _default: import('vue').DefineComponent<{
         itemId: string;
     }) => any) | undefined;
     onRestoreColumns?: (() => any) | undefined;
+    "onSort-changed"?: ((sort: {
+        field: string;
+        order: "asc" | "desc";
+    }) => any) | undefined;
     "onCreate:template"?: (() => any) | undefined;
+    "onCreate:folder"?: (() => any) | undefined;
+    onConvert?: (() => any) | undefined;
     "onUpdate:filter-values"?: ((mf: Record<string, any>) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+    "onBreadcrumb:click"?: ((id: string | null) => any) | undefined;
+    "onToggle-view-mode"?: (() => any) | undefined;
+}>, {
+    breadcrumbs: {
+        id: string;
+        name: string;
+    }[];
+    currentSort: {
+        field: string;
+        order: "asc" | "desc";
+    };
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    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('../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: 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, {
+        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";
+    }, 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<{
+        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('../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: 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;
+    }, {}, {}, {}, {
+        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;
+}, HTMLDivElement>;
 export default _default;

package/lib/components/canvases/CCanvasDeleteDialogContent.vue.d.ts

@@ -1,9 +1,6 @@
-import { CanvasRetrieve } from '../../../types/openapi';
-declare const _default: import('vue').DefineComponent<{
-    canvas: CanvasRetrieve;
-    texts: Record<"name" | "info", string>;
-}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
-    canvas: CanvasRetrieve;
-    texts: Record<"name" | "info", string>;
-}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+type __VLS_Props = {
+    name: string;
+    texts: Record<'name' | 'info', string>;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

package/lib/components/canvases/CCanvasMetadataFilters.vue.d.ts

@@ -1,20 +1,14 @@
-declare const _default: import('vue').DefineComponent<{
+type __VLS_Props = {
     disabled?: boolean;
     engagingIds?: string[];
     metadataFilterValues?: Record<string, any>;
     popularIds?: string[];
     recommendedIds?: string[];
     showLatestFilter?: boolean;
-}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:metadata-filter-values": (mf: Record<string, any>) => any;
-}, string, import('vue').PublicProps, Readonly<{
-    disabled?: boolean;
-    engagingIds?: string[];
-    metadataFilterValues?: Record<string, any>;
-    popularIds?: string[];
-    recommendedIds?: string[];
-    showLatestFilter?: boolean;
-}> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:metadata-filter-values"?: ((mf: Record<string, any>) => any) | undefined;
 }>, {
     engagingIds: string[];
@@ -22,5 +16,5 @@ declare const _default: import('vue').DefineComponent<{
     popularIds: string[];
     recommendedIds: string[];
     showLatestFilter: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

package/lib/components/canvases/CanvasesManagementBulk.use.d.ts

@@ -1,7 +1,7 @@
 import { Ref, ComputedRef } from 'vue';
 import { GetInstanceMetadataTemplatesPayload } from '../../sdk/payload.types';
 import { CanvasType } from '../../types/canvases';
-import { PaginatedMetadataTemplateList, CanvasRetrieve } from '../../../types/openapi';
+import { PaginatedMetadataTemplateList, CanvasRetrieve, PatchedCanvasUpdateRequest } from '../../../types/openapi';
 interface BaseBulkProps {
     selectedRows: Ref<Record<string, boolean>>;
     title?: string;
@@ -17,11 +17,16 @@ interface BulkUpdateFileAttributeProps extends BaseBulkProps {
     isBulkUpdating: Ref<boolean>;
 }
 interface BulkUpdateMetadataDialogProps extends BaseBulkProps {
+    selectedItemNames?: string[];
     metadataFetcher?: (params?: GetInstanceMetadataTemplatesPayload) => Promise<PaginatedMetadataTemplateList>;
     noMetadataErrorText?: string;
     subtitle?: string;
     isBulkUpdating: Ref<boolean>;
-    canvasType: Extract<CanvasType, 'canvas' | 'section'>;
+    canvasType: CanvasType;
+    updater?: (params: PatchedCanvasUpdateRequest & {
+        id: CanvasRetrieve['id'];
+        fields?: string;
+    }) => Promise<CanvasRetrieve>;
 }
 interface BulkDeleteDialogProps extends BaseBulkProps {
     filteredData: ComputedRef<CanvasRetrieve[]>;
@@ -39,9 +44,28 @@ interface BulkTagsProps extends BaseBulkProps {
 }
 export default function useCanvasesManagementBulk(): {
     bulkDeleteDialog: ({ filteredData, selectedRows, isBulkDeleting, canvasType, onComplete, isReadonly, title, content, confirmText, cancelText, }: BulkDeleteDialogProps) => Promise<void>;
-    bulkUpdateMetadataDialog: ({ selectedRows, metadataFetcher, noMetadataErrorText, title, subtitle, isBulkUpdating, onComplete, confirmText, cancelText, canvasType, }: BulkUpdateMetadataDialogProps) => Promise<void>;
+    bulkUpdateMetadataDialog: ({ selectedRows, selectedItemNames, metadataFetcher, noMetadataErrorText, title, subtitle, isBulkUpdating, onComplete, confirmText, cancelText, canvasType, updater, }: BulkUpdateMetadataDialogProps) => Promise<void>;
     bulkUpdateFileAttributes: ({ selectedRows, fileNames, metadataFetcher, noMetadataErrorText, title, subtitle, isBulkUpdating, onComplete, confirmText, cancelText, }: BulkUpdateFileAttributeProps) => Promise<void>;
     bulkAddTagsDialog: ({ filteredData, selectedRows, isBulkUpdating, canvasType, onComplete, isReadonly, title, confirmText, cancelText, }: BulkTagsProps) => Promise<void>;
     bulkRemoveTagsDialog: ({ filteredData, selectedRows, isBulkUpdating, canvasType, onComplete, isReadonly, title, confirmText, cancelText, }: BulkTagsProps) => Promise<void>;
+    bulkUpdateDistributionDialog: ({ selectedCount, isBulkUpdating, canvasType, selectedRows, onComplete, title, confirmText, cancelText, }: {
+        selectedCount: number;
+        isBulkUpdating: Ref<boolean>;
+        canvasType: CanvasType;
+        selectedRows: Ref<Record<string, boolean>>;
+        onComplete: () => void | Promise<void>;
+        title?: string;
+        confirmText?: string;
+        cancelText?: string;
+    }) => Promise<void>;
+    bulkUpdateFileDistributionDialog: ({ selectedCount, isBulkUpdating, selectedRows, onComplete, title, confirmText, cancelText, }: {
+        selectedCount: number;
+        isBulkUpdating: Ref<boolean>;
+        selectedRows: Ref<Record<string, boolean>>;
+        onComplete: () => void | Promise<void>;
+        title?: string;
+        confirmText?: string;
+        cancelText?: string;
+    }) => Promise<void>;
 };
 export {};

package/lib/components/filters/CDateRangeFilter.vue.d.ts

@@ -17,8 +17,9 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
     "onUpdate:modelValue"?: ((v: ModelValue) => any) | undefined;
 }>, {
     name: string;
-    inline: boolean;
+    options: Option[];
     disabled: boolean;
+    inline: boolean;
     modelValue: ModelValue;
     allowCustomDateRange: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/lib/components/filters/CSearchFilter.vue.d.ts

@@ -1,8 +1,16 @@
+import { MetadataFilterRequest } from '../../types/core/MetadataFilter';
 type Props = {
     disabled?: boolean;
+    entity?: MetadataFilterRequest['entity'];
     inline?: boolean;
+    includeDraftValues?: boolean;
     name?: string;
     modelValue?: string;
+    filterKey?: string;
+    isCustom?: boolean;
+    isSection?: boolean;
+    isTemplate?: boolean;
+    ownerId?: number | null;
 };
 declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     clear: () => any;
@@ -12,8 +20,88 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
     "onUpdate:modelValue"?: ((v: string) => any) | undefined;
 }>, {
     name: string;
-    inline: boolean;
     disabled: boolean;
+    inline: boolean;
     modelValue: string;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+    isSection: boolean;
+    isTemplate: boolean;
+    includeDraftValues: boolean;
+    ownerId: number | null;
+    filterKey: string;
+    isCustom: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    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;
+}, any>;
 export default _default;

package/lib/components/filters/CSelectFilter.vue.d.ts

@@ -11,16 +11,14 @@ declare const _default: <FilterValue extends string>(__VLS_props: NonNullable<Aw
             value: FilterValue;
         }[];
         multiple?: boolean;
-    }> & import('vue').PublicProps;
+    } & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
     attrs: any;
     slots: {
         footer?(_: {}): any;
     };
     emit: (e: "update:modelValue", v: "" | FilterValue | FilterValue[]) => void;
-}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}> & {
+}>) => import('vue').VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 export default _default;