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

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

@@ -1,17 +1,67 @@
 import { ComputedRef } from 'vue';
 import { ColumnDef, PaginationState, SortingState } from '@tanstack/table-core';
 import { PaginatedData } from '../../types/paginatedData';
+import { CoreFolderEntityType, CoreFolderRetrieve } from '../../types/folder';
 import { CLIENT_TYPE } from '../../constants/cdp.const';
 import { CanvasType, GetCanvasesParams } from '../../types/canvases';
-import { CanvasRetrieve, CanvasCreateRequest, PatchedCanvasUpdateRequest, MetadataTemplateFieldTypeEnum } from '../../../types/openapi';
+import { CanvasRetrieve, CanvasCreateRequest, PatchedCanvasUpdateRequest, FolderRetrieve, MetadataTemplateFieldTypeEnum } from '../../../types/openapi';
+type __VLS_Props = {
+    storageKey?: string;
+    myUserId?: CanvasRetrieve['created_by']['id'];
+    updater: (params: PatchedCanvasUpdateRequest & {
+        id: CanvasRetrieve['id'];
+        fields?: string;
+    }) => Promise<CanvasRetrieve>;
+    creator: (params: Omit<CanvasCreateRequest, 'instance_id'>, folderId?: string | null) => Promise<CanvasRetrieve>;
+    fetcher: (params: GetCanvasesParams & {
+        filters?: Record<string, any>;
+        fields?: string;
+        id__in?: string;
+    }) => Promise<PaginatedData<CanvasRetrieve>>;
+    deleter: (id: CanvasRetrieve['id']) => Promise<CanvasRetrieve>;
+    byIdFetcher: (params: {
+        id: CanvasRetrieve['id'];
+        fields?: string;
+    }) => Promise<CanvasRetrieve>;
+    client: (typeof CLIENT_TYPE)[keyof typeof CLIENT_TYPE];
+    canvasType: Exclude<CanvasType, 'section' | 'canvas' | 'block'>;
+    folderCreator?: (params: {
+        name: string;
+        parent_id?: string | null;
+    }) => Promise<any>;
+    folderDeleter?: (id: string, params: {
+        entity: CoreFolderEntityType;
+    }) => Promise<any>;
+    folderPatcher?: (id: string, params: Partial<CoreFolderRetrieve>) => Promise<any>;
+    folderItemsFetcher?: (params: {
+        parent_id?: string;
+    }) => Promise<FolderRetrieve>;
+    folderFetcher?: (params: {
+        folder_id?: string | null;
+        entity: CoreFolderEntityType;
+    }) => Promise<any>;
+    onItemsMove?: (params: {
+        target_folder_id: string;
+        entity: CoreFolderEntityType;
+        item_ids: string[];
+    }) => Promise<void>;
+    hideConvert?: boolean;
+    isAnyTypeOfAdmin?: boolean;
+};
 declare function __VLS_template(): {
+    attrs: Partial<{}>;
     slots: {
         default?(_: {}): any;
     };
     refs: {
         toolbarWrapper: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            breadcrumbs: {
+                id: string;
+                name: string;
+            }[];
+            canvasType: Exclude<CanvasType, "section" | "canvas" | "block">;
             search: string;
-            filterValues: Record<string, any>;
+            metadataFilterValues: Record<string, any>;
             recommendedIds: string[];
             tableColumnsSettings: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting[];
             customFilterComponents: {
@@ -21,8 +71,15 @@ declare function __VLS_template(): {
                 options?: [];
             }[];
             hideCreate?: boolean;
+            hideConvert?: boolean;
             hideView?: boolean;
             isLoadingItems?: boolean;
+            isTemplateFolderEnabled?: boolean;
+            currentSort?: {
+                field: string;
+                order: "asc" | "desc";
+            };
+            viewMode?: "table" | "list";
         }> & Readonly<{
             onSearch?: ((s: string) => any) | undefined;
             onSelect?: ((payload: {
@@ -34,9 +91,19 @@ declare function __VLS_template(): {
                 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;
-        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "onBreadcrumb:click"?: ((id: string | null) => any) | undefined;
+            "onToggle-view-mode"?: (() => any) | undefined;
+        }>, {
+            clearSearch: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
             search: (s: string) => any;
             select: (payload: {
                 id: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting["id"];
@@ -47,9 +114,199 @@ declare function __VLS_template(): {
                 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;
-        }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            "breadcrumb:click": (id: string | null) => any;
+            "toggle-view-mode": () => any;
+        }, import('vue').PublicProps, {
+            breadcrumbs: {
+                id: string;
+                name: string;
+            }[];
+            currentSort: {
+                field: string;
+                order: "asc" | "desc";
+            };
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            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, import('vue').ComponentProvideOptions, {
             P: {};
             B: {};
             D: {};
@@ -57,8 +314,13 @@ declare function __VLS_template(): {
             M: {};
             Defaults: {};
         }, Readonly<{
+            breadcrumbs: {
+                id: string;
+                name: string;
+            }[];
+            canvasType: Exclude<CanvasType, "section" | "canvas" | "block">;
             search: string;
-            filterValues: Record<string, any>;
+            metadataFilterValues: Record<string, any>;
             recommendedIds: string[];
             tableColumnsSettings: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting[];
             customFilterComponents: {
@@ -68,8 +330,15 @@ declare function __VLS_template(): {
                 options?: [];
             }[];
             hideCreate?: boolean;
+            hideConvert?: boolean;
             hideView?: boolean;
             isLoadingItems?: boolean;
+            isTemplateFolderEnabled?: boolean;
+            currentSort?: {
+                field: string;
+                order: "asc" | "desc";
+            };
+            viewMode?: "table" | "list";
         }> & Readonly<{
             onSearch?: ((s: string) => any) | undefined;
             onSelect?: ((payload: {
@@ -81,9 +350,28 @@ declare function __VLS_template(): {
                 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;
-        }>, {}, {}, {}, {}, {}> | null;
+            "onBreadcrumb:click"?: ((id: string | null) => any) | undefined;
+            "onToggle-view-mode"?: (() => any) | undefined;
+        }>, {
+            clearSearch: () => void;
+        }, {}, {}, {}, {
+            breadcrumbs: {
+                id: string;
+                name: string;
+            }[];
+            currentSort: {
+                field: string;
+                order: "asc" | "desc";
+            };
+        }> | null;
         tableRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
             selectedRows?: Record<string, boolean>;
             scrollerClass?: string;
@@ -95,6 +383,10 @@ declare function __VLS_template(): {
             }[];
             initialSorting?: SortingState;
             loading?: boolean;
+            hidePageSelector?: boolean;
+            hidePageSize?: boolean;
+            hidePagination?: boolean;
+            hideTotalResults?: boolean;
             pageSize?: number;
             pageSizes?: number[];
             pageIndex?: number;
@@ -103,6 +395,7 @@ declare function __VLS_template(): {
             serverSide?: boolean;
             scrollerStyle?: import('vue').StyleValue;
             selectable?: boolean;
+            disabledIds?: Array<string | number>;
         }> & Readonly<{
             onSortChanged?: ((s: SortingState) => any) | undefined;
             onPageChanged?: ((p: PaginationState) => any) | undefined;
@@ -114,6 +407,7 @@ declare function __VLS_template(): {
             selectAll: () => void;
             selectedRowsCount: ComputedRef<number>;
             pageRowsCount: ComputedRef<number>;
+            isRowDisabled: (id: string | number) => boolean;
         }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
             sortChanged: (s: SortingState) => any;
             pageChanged: (p: PaginationState) => any;
@@ -130,8 +424,13 @@ declare function __VLS_template(): {
             pageSize: number;
             pageIndex: number;
             initialSorting: SortingState;
+            hidePageSelector: boolean;
+            hidePageSize: boolean;
+            hidePagination: boolean;
+            hideTotalResults: boolean;
             serverSide: boolean;
-        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            disabledIds: Array<string | number>;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
             P: {};
             B: {};
             D: {};
@@ -149,6 +448,10 @@ declare function __VLS_template(): {
             }[];
             initialSorting?: SortingState;
             loading?: boolean;
+            hidePageSelector?: boolean;
+            hidePageSize?: boolean;
+            hidePagination?: boolean;
+            hideTotalResults?: boolean;
             pageSize?: number;
             pageSizes?: number[];
             pageIndex?: number;
@@ -157,6 +460,7 @@ declare function __VLS_template(): {
             serverSide?: boolean;
             scrollerStyle?: import('vue').StyleValue;
             selectable?: boolean;
+            disabledIds?: Array<string | number>;
         }> & Readonly<{
             onSortChanged?: ((s: SortingState) => any) | undefined;
             onPageChanged?: ((p: PaginationState) => any) | undefined;
@@ -168,6 +472,7 @@ declare function __VLS_template(): {
             selectAll: () => void;
             selectedRowsCount: ComputedRef<number>;
             pageRowsCount: ComputedRef<number>;
+            isRowDisabled: (id: string | number) => boolean;
         }, {}, {}, {}, {
             data: {
                 [x: string]: any;
@@ -179,67 +484,477 @@ declare function __VLS_template(): {
             pageSize: number;
             pageIndex: number;
             initialSorting: SortingState;
+            hidePageSelector: boolean;
+            hidePageSize: boolean;
+            hidePagination: boolean;
+            hideTotalResults: boolean;
             serverSide: boolean;
+            disabledIds: Array<string | number>;
         }> | null;
     };
-    attrs: Partial<{}>;
+    rootEl: HTMLDivElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<{
-    storageKey?: string;
-    myUserId?: CanvasRetrieve["created_by"]["id"];
-    updater: (params: PatchedCanvasUpdateRequest & {
-        id: CanvasRetrieve["id"];
-        fields?: string;
-    }) => Promise<CanvasRetrieve>;
-    creator: (params: Omit<CanvasCreateRequest, "instance_id">) => Promise<CanvasRetrieve>;
-    fetcher: (params: GetCanvasesParams & {
-        filters?: Record<string, any>;
-        fields?: string;
-        id__in?: string;
-    }) => Promise<PaginatedData<CanvasRetrieve>>;
-    deleter: (id: CanvasRetrieve["id"]) => Promise<CanvasRetrieve>;
-    byIdFetcher: (params: {
-        id: CanvasRetrieve["id"];
-        fields?: string;
-    }) => Promise<CanvasRetrieve>;
-    client: (typeof CLIENT_TYPE)[keyof typeof CLIENT_TYPE];
-    canvasType: Exclude<CanvasType, "section" | "canvas" | "block">;
-}, {
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
     refetch: () => Promise<void>;
+    currentFolderId: import('@vueuse/shared').RemovableRef<string | null>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    create: () => any;
-    edit: (canvas: CanvasRetrieve) => any;
     details: (canvas: CanvasRetrieve) => any;
+    edit: (canvas: CanvasRetrieve) => any;
     open: (canvas: CanvasRetrieve, newTab?: boolean | undefined) => any;
+    move: (canvas: CanvasRetrieve) => any;
+    create: (folderId?: string | null | undefined) => any;
+    manageDistribution: () => any;
+    convert: () => any;
     createFromTemplate: (templateId: string) => any;
-}, string, import('vue').PublicProps, Readonly<{
-    storageKey?: string;
-    myUserId?: CanvasRetrieve["created_by"]["id"];
-    updater: (params: PatchedCanvasUpdateRequest & {
-        id: CanvasRetrieve["id"];
-        fields?: string;
-    }) => Promise<CanvasRetrieve>;
-    creator: (params: Omit<CanvasCreateRequest, "instance_id">) => Promise<CanvasRetrieve>;
-    fetcher: (params: GetCanvasesParams & {
-        filters?: Record<string, any>;
-        fields?: string;
-        id__in?: string;
-    }) => Promise<PaginatedData<CanvasRetrieve>>;
-    deleter: (id: CanvasRetrieve["id"]) => Promise<CanvasRetrieve>;
-    byIdFetcher: (params: {
-        id: CanvasRetrieve["id"];
-        fields?: string;
-    }) => Promise<CanvasRetrieve>;
-    client: (typeof CLIENT_TYPE)[keyof typeof CLIENT_TYPE];
-    canvasType: Exclude<CanvasType, "section" | "canvas" | "block">;
-}> & Readonly<{
-    onCreate?: (() => any) | undefined;
-    onEdit?: ((canvas: CanvasRetrieve) => any) | undefined;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onDetails?: ((canvas: CanvasRetrieve) => any) | undefined;
+    onEdit?: ((canvas: CanvasRetrieve) => any) | undefined;
     onOpen?: ((canvas: CanvasRetrieve, newTab?: boolean | undefined) => any) | undefined;
+    onMove?: ((canvas: CanvasRetrieve) => any) | undefined;
+    onCreate?: ((folderId?: string | null | undefined) => any) | undefined;
+    onManageDistribution?: (() => any) | undefined;
+    onConvert?: (() => any) | undefined;
     onCreateFromTemplate?: ((templateId: string) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    toolbarWrapper: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        breadcrumbs: {
+            id: string;
+            name: string;
+        }[];
+        canvasType: Exclude<CanvasType, "section" | "canvas" | "block">;
+        search: string;
+        metadataFilterValues: Record<string, any>;
+        recommendedIds: string[];
+        tableColumnsSettings: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting[];
+        customFilterComponents: {
+            type: MetadataTemplateFieldTypeEnum;
+            name: string;
+            label: string;
+            options?: [];
+        }[];
+        hideCreate?: boolean;
+        hideConvert?: boolean;
+        hideView?: boolean;
+        isLoadingItems?: boolean;
+        isTemplateFolderEnabled?: boolean;
+        currentSort?: {
+            field: string;
+            order: "asc" | "desc";
+        };
+        viewMode?: "table" | "list";
+    }> & Readonly<{
+        onSearch?: ((s: 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;
+        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;
+        "onBreadcrumb:click"?: ((id: string | null) => any) | undefined;
+        "onToggle-view-mode"?: (() => any) | undefined;
+    }>, {
+        clearSearch: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        search: (s: 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;
+        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;
+        "breadcrumb:click": (id: string | null) => any;
+        "toggle-view-mode": () => any;
+    }, import('vue').PublicProps, {
+        breadcrumbs: {
+            id: string;
+            name: string;
+        }[];
+        currentSort: {
+            field: string;
+            order: "asc" | "desc";
+        };
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        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, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        breadcrumbs: {
+            id: string;
+            name: string;
+        }[];
+        canvasType: Exclude<CanvasType, "section" | "canvas" | "block">;
+        search: string;
+        metadataFilterValues: Record<string, any>;
+        recommendedIds: string[];
+        tableColumnsSettings: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting[];
+        customFilterComponents: {
+            type: MetadataTemplateFieldTypeEnum;
+            name: string;
+            label: string;
+            options?: [];
+        }[];
+        hideCreate?: boolean;
+        hideConvert?: boolean;
+        hideView?: boolean;
+        isLoadingItems?: boolean;
+        isTemplateFolderEnabled?: boolean;
+        currentSort?: {
+            field: string;
+            order: "asc" | "desc";
+        };
+        viewMode?: "table" | "list";
+    }> & Readonly<{
+        onSearch?: ((s: 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;
+        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;
+        "onBreadcrumb:click"?: ((id: string | null) => any) | undefined;
+        "onToggle-view-mode"?: (() => any) | undefined;
+    }>, {
+        clearSearch: () => void;
+    }, {}, {}, {}, {
+        breadcrumbs: {
+            id: string;
+            name: string;
+        }[];
+        currentSort: {
+            field: string;
+            order: "asc" | "desc";
+        };
+    }> | null;
+    tableRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        selectedRows?: Record<string, boolean>;
+        scrollerClass?: string;
+        columns: ColumnDef<{
+            [x: string]: any;
+        }, any>[];
+        data: {
+            [x: string]: any;
+        }[];
+        initialSorting?: SortingState;
+        loading?: boolean;
+        hidePageSelector?: boolean;
+        hidePageSize?: boolean;
+        hidePagination?: boolean;
+        hideTotalResults?: boolean;
+        pageSize?: number;
+        pageSizes?: number[];
+        pageIndex?: number;
+        totalCount?: number;
+        displayedCount?: number;
+        serverSide?: boolean;
+        scrollerStyle?: import('vue').StyleValue;
+        selectable?: boolean;
+        disabledIds?: Array<string | number>;
+    }> & Readonly<{
+        onSortChanged?: ((s: SortingState) => any) | undefined;
+        onPageChanged?: ((p: PaginationState) => any) | undefined;
+        onPageSizeChanged?: ((p: number) => any) | undefined;
+        "onUpdate:selectedRows"?: ((s: Record<string, boolean>) => any) | undefined;
+    }>, {
+        isNoneSelected: ComputedRef<boolean>;
+        areAllSelected: ComputedRef<boolean>;
+        selectAll: () => void;
+        selectedRowsCount: ComputedRef<number>;
+        pageRowsCount: ComputedRef<number>;
+        isRowDisabled: (id: string | number) => boolean;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        sortChanged: (s: SortingState) => any;
+        pageChanged: (p: PaginationState) => any;
+        pageSizeChanged: (p: number) => any;
+        "update:selectedRows": (s: Record<string, boolean>) => any;
+    }, import('vue').PublicProps, {
+        data: {
+            [x: string]: any;
+        }[];
+        loading: boolean;
+        columns: ColumnDef<{
+            [x: string]: any;
+        }, any>[];
+        pageSize: number;
+        pageIndex: number;
+        initialSorting: SortingState;
+        hidePageSelector: boolean;
+        hidePageSize: boolean;
+        hidePagination: boolean;
+        hideTotalResults: boolean;
+        serverSide: boolean;
+        disabledIds: Array<string | number>;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        selectedRows?: Record<string, boolean>;
+        scrollerClass?: string;
+        columns: ColumnDef<{
+            [x: string]: any;
+        }, any>[];
+        data: {
+            [x: string]: any;
+        }[];
+        initialSorting?: SortingState;
+        loading?: boolean;
+        hidePageSelector?: boolean;
+        hidePageSize?: boolean;
+        hidePagination?: boolean;
+        hideTotalResults?: boolean;
+        pageSize?: number;
+        pageSizes?: number[];
+        pageIndex?: number;
+        totalCount?: number;
+        displayedCount?: number;
+        serverSide?: boolean;
+        scrollerStyle?: import('vue').StyleValue;
+        selectable?: boolean;
+        disabledIds?: Array<string | number>;
+    }> & Readonly<{
+        onSortChanged?: ((s: SortingState) => any) | undefined;
+        onPageChanged?: ((p: PaginationState) => any) | undefined;
+        onPageSizeChanged?: ((p: number) => any) | undefined;
+        "onUpdate:selectedRows"?: ((s: Record<string, boolean>) => any) | undefined;
+    }>, {
+        isNoneSelected: ComputedRef<boolean>;
+        areAllSelected: ComputedRef<boolean>;
+        selectAll: () => void;
+        selectedRowsCount: ComputedRef<number>;
+        pageRowsCount: ComputedRef<number>;
+        isRowDisabled: (id: string | number) => boolean;
+    }, {}, {}, {}, {
+        data: {
+            [x: string]: any;
+        }[];
+        loading: boolean;
+        columns: ColumnDef<{
+            [x: string]: any;
+        }, any>[];
+        pageSize: number;
+        pageIndex: number;
+        initialSorting: SortingState;
+        hidePageSelector: boolean;
+        hidePageSize: boolean;
+        hidePagination: boolean;
+        hideTotalResults: boolean;
+        serverSide: boolean;
+        disabledIds: Array<string | number>;
+    }> | null;
+}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {