@pitcher/js-api 1.22.0-beta.6 → 1.22.0-rc.1

package/lib/components/sections/CSectionManagement.vue.d.ts

@@ -1,11 +1,179 @@
+import { ComputedRef } from 'vue';
+import { ColumnDef, SortingState, PaginationState } from '@tanstack/table-core';
 import { PaginatedData } from '../../types/paginatedData';
 import { CLIENT_TYPE } from '../../constants/cdp.const';
 import { GetCanvasesParams } from '../../types/canvases';
 import { CanvasRetrieve, CanvasCreateRequest, PatchedCanvasUpdateRequest } from '../../../types/openapi';
 declare function __VLS_template(): {
-    default?(_: {}): any;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        toolbarWrapper: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            hideCreate?: boolean;
+            search: string;
+            metadataFilterValues: Record<string, any>;
+            recommendedSectionIds: string[];
+            isLoadingItems?: boolean;
+            tableColumnsSettings: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting[];
+            isViewHidden?: boolean;
+        }> & 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;
+            "onUpdate:metadata-filter-values"?: ((mf: Record<string, any>) => any) | undefined;
+            "onCreate:section"?: (() => any) | undefined;
+            onRestoreColumns?: (() => any) | undefined;
+        }>, {}, {}, {}, {}, 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;
+            "update:metadata-filter-values": (mf: Record<string, any>) => any;
+            "create:section": () => any;
+            restoreColumns: () => any;
+        }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            hideCreate?: boolean;
+            search: string;
+            metadataFilterValues: Record<string, any>;
+            recommendedSectionIds: string[];
+            isLoadingItems?: boolean;
+            tableColumnsSettings: import('../CTableColumnsSettings/CTableColumnsSettings.vue').TableColumnSetting[];
+            isViewHidden?: boolean;
+        }> & 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;
+            "onUpdate:metadata-filter-values"?: ((mf: Record<string, any>) => any) | undefined;
+            "onCreate:section"?: (() => any) | undefined;
+            onRestoreColumns?: (() => any) | undefined;
+        }>, {}, {}, {}, {}, {}> | 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;
+            pageSize?: number;
+            pageSizes?: number[];
+            pageIndex?: number;
+            totalCount?: number;
+            displayedCount?: number;
+            serverSide?: boolean;
+            scrollerStyle?: import('vue').StyleValue;
+            selectable?: boolean;
+        }> & 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>;
+        }, {}, {}, {}, 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;
+            }[];
+            columns: ColumnDef<{
+                [x: string]: any;
+            }, any>[];
+            pageIndex: number;
+            loading: boolean;
+            pageSize: number;
+            initialSorting: SortingState;
+            serverSide: boolean;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, 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;
+            pageSize?: number;
+            pageSizes?: number[];
+            pageIndex?: number;
+            totalCount?: number;
+            displayedCount?: number;
+            serverSide?: boolean;
+            scrollerStyle?: import('vue').StyleValue;
+            selectable?: boolean;
+        }> & 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>;
+        }, {}, {}, {}, {
+            data: {
+                [x: string]: any;
+            }[];
+            columns: ColumnDef<{
+                [x: string]: any;
+            }, any>[];
+            pageIndex: number;
+            loading: boolean;
+            pageSize: number;
+            initialSorting: SortingState;
+            serverSide: boolean;
+        }> | null;
+    };
+    attrs: Partial<{}>;
 };
-declare const __VLS_component: import('vue').DefineComponent<__VLS_TypePropsToOption<{
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{
     storageKey?: string;
     myUserId?: CanvasRetrieve["created_by"]["id"];
     updater: (params: PatchedCanvasUpdateRequest & {
@@ -25,14 +193,14 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_TypePropsToOp
     }) => Promise<CanvasRetrieve>;
     client: (typeof CLIENT_TYPE)[keyof typeof CLIENT_TYPE];
     areSectionsSystemControlled?: boolean;
-}>, {
+}, {
     refetch: () => Promise<void>;
-}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    details: (canvas: CanvasRetrieve) => void;
-    edit: (canvas: CanvasRetrieve) => void;
-    open: (canvas: CanvasRetrieve, newTab?: boolean | undefined) => void;
-    create: () => void;
-}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<{
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    create: () => any;
+    edit: (canvas: CanvasRetrieve) => any;
+    open: (canvas: CanvasRetrieve, newTab?: boolean | undefined) => any;
+    details: (canvas: CanvasRetrieve) => any;
+}, string, import('vue').PublicProps, Readonly<{
     storageKey?: string;
     myUserId?: CanvasRetrieve["created_by"]["id"];
     updater: (params: PatchedCanvasUpdateRequest & {
@@ -52,25 +220,16 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_TypePropsToOp
     }) => Promise<CanvasRetrieve>;
     client: (typeof CLIENT_TYPE)[keyof typeof CLIENT_TYPE];
     areSectionsSystemControlled?: boolean;
-}>>> & {
+}> & Readonly<{
     onCreate?: (() => any) | undefined;
-    onOpen?: ((canvas: CanvasRetrieve, newTab?: boolean | undefined) => any) | undefined;
     onEdit?: ((canvas: CanvasRetrieve) => any) | undefined;
+    onOpen?: ((canvas: CanvasRetrieve, newTab?: boolean | undefined) => any) | undefined;
     onDetails?: ((canvas: CanvasRetrieve) => any) | undefined;
-}, {}, {}>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};

package/lib/components/sections/CSectionManagementActionsCell.vue.d.ts

@@ -1,4 +1,4 @@
-declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<{
+declare const _default: import('vue').DefineComponent<{
     hideCopy?: boolean;
     hideEdit?: boolean;
     hideDelete?: boolean;
@@ -6,15 +6,15 @@ declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<{
     hideViewNewTab?: boolean;
     isCopying: boolean;
     isDeleting: boolean;
-}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    view: () => void;
-    delete: () => void;
-    edit: () => void;
-    copy: () => void;
-    duplicate: () => void;
-    viewNewTab: () => void;
-    viewDetails: () => void;
-}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<{
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    delete: () => any;
+    duplicate: () => any;
+    edit: () => any;
+    copy: () => any;
+    view: () => any;
+    viewNewTab: () => any;
+    viewDetails: () => any;
+}, string, import('vue').PublicProps, Readonly<{
     hideCopy?: boolean;
     hideEdit?: boolean;
     hideDelete?: boolean;
@@ -22,22 +22,13 @@ declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<{
     hideViewNewTab?: boolean;
     isCopying: boolean;
     isDeleting: boolean;
-}>>> & {
-    onCopy?: (() => any) | undefined;
-    onEdit?: (() => any) | undefined;
-    onView?: (() => any) | undefined;
+}> & Readonly<{
     onDelete?: (() => any) | undefined;
     onDuplicate?: (() => any) | undefined;
+    onEdit?: (() => any) | undefined;
+    onCopy?: (() => any) | undefined;
+    onView?: (() => any) | undefined;
     onViewNewTab?: (() => any) | undefined;
     onViewDetails?: (() => any) | undefined;
-}, {}, {}>;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};

package/lib/components/sections/CSectionManagementToolbar.vue.d.ts

@@ -1,5 +1,5 @@
 import { TableColumnSetting } from '../CTableColumnsSettings/CTableColumnsSettings.vue';
-declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<{
+declare const _default: import('vue').DefineComponent<{
     hideCreate?: boolean;
     search: string;
     metadataFilterValues: Record<string, any>;
@@ -7,20 +7,20 @@ declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<{
     isLoadingItems?: boolean;
     tableColumnsSettings: TableColumnSetting[];
     isViewHidden?: boolean;
-}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    search: (s: string) => void;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    search: (s: string) => any;
     select: (payload: {
         id: TableColumnSetting["id"];
         checked: boolean;
-    }) => void;
+    }) => any;
     move: (payload: {
         targetItemId: TableColumnSetting["id"];
         itemId: string;
-    }) => void;
-    "update:metadata-filter-values": (mf: Record<string, any>) => void;
-    "create:section": () => void;
-    restoreColumns: () => void;
-}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<{
+    }) => any;
+    "update:metadata-filter-values": (mf: Record<string, any>) => any;
+    "create:section": () => any;
+    restoreColumns: () => any;
+}, string, import('vue').PublicProps, Readonly<{
     hideCreate?: boolean;
     search: string;
     metadataFilterValues: Record<string, any>;
@@ -28,7 +28,7 @@ declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<{
     isLoadingItems?: boolean;
     tableColumnsSettings: TableColumnSetting[];
     isViewHidden?: boolean;
-}>>> & {
+}> & Readonly<{
     onSearch?: ((s: string) => any) | undefined;
     onSelect?: ((payload: {
         id: TableColumnSetting["id"];
@@ -41,14 +41,5 @@ declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<{
     "onUpdate:metadata-filter-values"?: ((mf: Record<string, any>) => any) | undefined;
     "onCreate:section"?: (() => any) | undefined;
     onRestoreColumns?: (() => any) | undefined;
-}, {}, {}>;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};

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

@@ -0,0 +1,32 @@
+import { User, AppsDBEntry as GeneratedAppsDbEntry } from '../../types/openapi';
+type AppsDBEntry = GeneratedAppsDbEntry & {
+    value: Record<string, any> | null;
+};
+interface EntryParams {
+    store_name: string;
+    user_id: User['id'];
+    entry_key: string;
+}
+interface GlobalEntryParams {
+    store_name: string;
+    entry_key: string;
+}
+interface UpsertEntryParams extends EntryParams {
+    data: Record<string, any>;
+}
+interface UpsertGlobalEntryParams extends GlobalEntryParams {
+    data: Record<string, any>;
+}
+export declare function useAppsDb(): {
+    upsertEntry: (payload: UpsertEntryParams) => Promise<AppsDBEntry>;
+    getEntry: (params: EntryParams) => Promise<GeneratedAppsDbEntry & {
+        value: Record<string, any> | null;
+    } & {
+        value: Record<string, 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>>;
+};
+export {};

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

@@ -2,6 +2,8 @@ import { FileViewerSettings } from '../types/fileViewerSettings.types';
 export default function useFileViewerSettings(): {
     fileViewerSettings: Readonly<import('vue').Ref<{
         readonly fitMode: "width" | "viewport";
+    }, {
+        readonly fitMode: "width" | "viewport";
     }>>;
     updateFileViewerSettings: (partialSettings: Partial<FileViewerSettings>) => void;
 };

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

@@ -1,10 +1,14 @@
 import { Tag, Instance } from '../../types/openapi';
+import { InstanceTagsCanvasType, InstanceTagsType } from '../types/instanceTags.types';
 export default function useInstanceTagsActions(): {
-    fetchInstanceTags: ({ search, instanceId, page, pageSize, }: {
+    fetchInstanceTags: ({ search, instanceId, page, pageSize, includeHidden, canvasType, type, }: {
         search: string;
         instanceId?: Instance["id"];
         page?: number;
         pageSize?: number;
+        includeHidden?: boolean;
+        canvasType?: InstanceTagsCanvasType;
+        type?: InstanceTagsType[];
     }) => Promise<Tag[]>;
     fetchAllInstanceTags: ({ search, instanceId }: {
         search?: string;

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

@@ -0,0 +1,20 @@
+interface StackItem {
+    fileId: string;
+    pageIndex: number;
+    startTime?: number;
+}
+export default function useOpenFileStack(): {
+    resetStack: () => void;
+    pushToStack: (fileId: string, pageIndex: number, startTime?: number) => void;
+    popFromStack: () => StackItem | undefined;
+    fileStack: Readonly<import('vue').Ref<readonly {
+        readonly fileId: string;
+        readonly pageIndex: number;
+        readonly startTime?: number | undefined;
+    }[], readonly {
+        readonly fileId: string;
+        readonly pageIndex: number;
+        readonly startTime?: number | undefined;
+    }[]>>;
+};
+export {};

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

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+import { Call, ContentRating } from '../types/call';
+import { CDP_EVENT_TYPE } from '../constants/cdp.const';
+export default function usePresentationHistory(): {
+    updatePresentationHistory: (p: {
+        eventName: (typeof CDP_EVENT_TYPE)[keyof typeof CDP_EVENT_TYPE];
+        payload: any;
+        call: Ref<Call>;
+        canvasName?: string;
+    }) => void;
+    setMetadataItem: (call: Ref<Call>, id: string, rating: ContentRating) => void;
+};

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

@@ -7,5 +7,6 @@ export default function useRecentFiles({ instanceId, app, }: {
 }): {
     addRecentFile: (file: RecentFile) => void;
     instanceRecentFiles: ComputedRef<RecentFile[]>;
-    updateRecentFiles: (files: Partial<RecentFile>[]) => void;
+    updateRecentFiles: (files: Partial<RecentFile>[]) => RecentFile[];
+    updatePageInRecentFile: (fileId: string, pageIndex: number) => void;
 };

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

@@ -1,3 +1,8 @@
+import { InstanceTagsCanvasType, InstanceTagsType } from '../types/instanceTags.types';
 export default function useSuggestedTags(): {
-    fetchSuggestedInstanceTags: (search: string) => Promise<string[]>;
+    fetchSuggestedInstanceTags: (search: string, { includeHidden, canvasType, type, }?: {
+        includeHidden?: boolean;
+        canvasType?: InstanceTagsCanvasType;
+        type?: InstanceTagsType[];
+    }) => Promise<string[]>;
 };

package/lib/composables/useAdminAndDsrState.d.ts

@@ -0,0 +1,6 @@
+import { File } from '../../types/openapi';
+export declare function useAdminAndDsrState(onCleanup?: () => void): {
+    openFileId: Readonly<import('vue').Ref<string | null, string | null>>;
+    setOpenFileId: (id: File["id"]) => void;
+    clearOpenFileId: () => void;
+};

package/lib/composables/useAssetUpload.d.ts

@@ -1,5 +1,6 @@
+import { Ref } from 'vue';
 import { AxiosProgressEvent } from 'axios';
 export declare function useAssetUpload(): {
-    isUploading: import('vue').Ref<boolean>;
+    isUploading: Ref<boolean, boolean>;
     uploadAsset: (file: File, onUploadProgress?: (progress: AxiosProgressEvent, file: File) => void) => Promise<import('../../types/openapi').FileRetrieve>;
 };

package/lib/composables/useCanvasTablesPagination.d.ts

@@ -1,13 +1,15 @@
-interface PaginationPayload<T> {
+import { Ref, UnwrapRef } from 'vue';
+type PaginationPayload<T> = {
     storageKey?: string;
     initialFilters: T;
     initialOrdering: string;
-}
-declare const _default: <T>({ storageKey, initialFilters, initialOrdering }: PaginationPayload<T>) => {
-    search: import('vue').Ref<string>;
-    pageSize: import('vue').Ref<number>;
-    selectedFilters: import('vue').Ref<T | import('vue').UnwrapRef<T>>;
-    page: import('vue').Ref<number>;
-    ordering: import('vue').Ref<string>;
 };
+type PaginationReturn<T> = {
+    search: Ref<string>;
+    pageSize: Ref<number>;
+    selectedFilters: Ref<T> | Ref<UnwrapRef<T>, T | UnwrapRef<T>>;
+    page: Ref<number>;
+    ordering: Ref<string>;
+};
+declare const _default: <T>({ storageKey, initialFilters, initialOrdering }: PaginationPayload<T>) => PaginationReturn<T>;
 export default _default;

package/lib/composables/useConnectUpload.d.ts

@@ -1,5 +1,7 @@
 interface UploadResponse {
     url: string;
 }
-export declare function uploadToConnect(formData: FormData): Promise<UploadResponse>;
+export default function useConnectUpload(): {
+    uploadToConnect: (formData: FormData) => Promise<UploadResponse>;
+};
 export {};

package/lib/composables/useElementHeightResize.d.ts

@@ -1,4 +1,4 @@
 import { Ref } from 'vue';
 export declare function useElementHeightResize(toolbarWrapper: Ref<HTMLElement | null>, calculateWrapperHeight: (height: number) => string): {
-    wrapperHeight: Ref<string>;
+    wrapperHeight: Ref<string, string>;
 };

package/lib/composables/useFetchUsers.d.ts

@@ -1,5 +1,4 @@
 import { SelectOption } from 'naive-ui';
-import { PitcherInfo } from '../types/app';
 import { User } from '../../types/openapi';
 export type Owner = {
     value: User['id'];
@@ -8,9 +7,8 @@ export type Owner = {
 };
 declare function insertUserSorted(users: Owner[], newUser: Owner): Owner[];
 declare function filterUsers(searchTerm: string | null | undefined, option: SelectOption): boolean;
-declare function fetchUsers(pitcherInfo: PitcherInfo, myUser?: User | null): Promise<Owner[]>;
 export default function useFetchUsers(): {
-    fetchUsers: typeof fetchUsers;
+    fetchUsers: (myUser?: User | null) => Promise<Owner[]>;
     filterUsers: typeof filterUsers;
     insertUserSorted: typeof insertUserSorted;
 };

package/lib/composables/useFileDisplayHelpers.d.ts

@@ -0,0 +1,8 @@
+import { ViewCompactFolder } from '../types/files';
+import { FileContentTypeEnum } from '../../types/openapi';
+export default function useFileDisplayHelpers(): {
+    getFolderDescription: (item: Partial<ViewCompactFolder>) => string;
+    renderContentType: (contentType: FileContentTypeEnum) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>;
+};

package/lib/composables/useLocation.d.ts

@@ -18,7 +18,7 @@ export default function useLocation({ app, router, isReady, isRoot, selfRegister
     relations: Record<string, string>;
     unmount: () => Promise<void>;
     update: (newRoutes: UpdateLocationOnUpdate["routes"]) => Promise<void>;
-    isPathRestored: import('vue').Ref<boolean>;
+    isPathRestored: import('vue').Ref<boolean, boolean>;
     isAppMounted: import('vue').ComputedRef<boolean>;
     isAppRestored: import('vue').ComputedRef<boolean>;
     app: string;

package/lib/composables/useLocationManipulation.d.ts

@@ -21,7 +21,7 @@ interface Route {
     query: LocationQuery;
 }
 export default function useLocationManipulation({ routes, relations, app, actionsQueue }: UseLocationManipulation): {
-    isPathRestored: Ref<boolean>;
+    isPathRestored: Ref<boolean, boolean>;
     isAppMounted: import('vue').ComputedRef<boolean>;
     isAppRestored: import('vue').ComputedRef<boolean>;
     recoverRouteFromLocations: (rootApp: string) => Route;

package/lib/composables/useMetadataFilters.d.ts

@@ -1,9 +1,11 @@
+import { MetadataTemplateField, MetadataTemplateOption } from '../../types/openapi';
 export declare function getComponentNameByFilterType(type: string): "CSearchFilter" | "CSelectFilter" | "CDateRangeFilter";
-export declare function getBooleanOptions(): {
-    label: string;
-    value: string;
-}[];
-export default function useMetadataFilters(): {
-    getBooleanOptions: typeof getBooleanOptions;
+export default function useMetadataFilters(t: (input: string) => string): {
+    getBooleanOptions: () => {
+        label: string;
+        value: string;
+    }[];
     getComponentNameByFilterType: typeof getComponentNameByFilterType;
+    getDefaultDateOptions: () => MetadataTemplateOption[];
+    getFilterOptions: (type: MetadataTemplateField["type"], options: MetadataTemplateField["options"]) => MetadataTemplateOption[];
 };

package/lib/composables/useSharedTranslations.d.ts

@@ -0,0 +1,10 @@
+export default function useSharedTranslations(): {
+    typographyPresetTranslations: {
+        h_1: string;
+        h_2: string;
+        h_3: string;
+        big_text: string;
+        normal_text: string;
+        small_text: string;
+    };
+};

package/lib/composables/useThemeVars.d.ts

@@ -26,5 +26,33 @@ declare const _default: () => import('vue').Ref<{
     boxShadow: string;
     boxShadow2: string;
     boxShadow3: string;
+}, import('../main.lib').BasicPalette | {
+    base: string;
+    primary: string;
+    primary2: string;
+    primary3: string;
+    primary4: string;
+    primary5: string;
+    primary6: string;
+    primary6_1: string;
+    accent: string;
+    text: string;
+    text2: string;
+    text3: string;
+    error: string;
+    error2: string;
+    error3: string;
+    warning: string;
+    warning2: string;
+    warning3: string;
+    success: string;
+    success2: string;
+    success3: string;
+    info: string;
+    info2: string;
+    info3: string;
+    boxShadow: string;
+    boxShadow2: string;
+    boxShadow3: string;
 }>;
 export default _default;

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

@@ -0,0 +1,10 @@
+export declare const APPS_DB: {
+    readonly STORES: {
+        readonly SMART_FOLDERS: "smart-folders";
+    };
+    readonly ENTRIES: {
+        readonly CONFIGURATION: "configuration";
+    };
+    readonly GLOBAL_STORES: {};
+    readonly GLOBAL_ENTRIES: {};
+};