@opencloud-eu/web-pkg 4.0.0 → 4.1.0

package/dist/src/helpers/folderLink/types.d.ts

@@ -0,0 +1,6 @@
+import { Resource, SpaceResource } from '@opencloud-eu/web-client';
+export interface CreateTargetRouteOptions {
+    path: string;
+    fileId?: string | number;
+    resource: Resource | SpaceResource;
+}

package/dist/src/helpers/fuse.d.ts

@@ -0,0 +1,5 @@
+export declare const defaultFuseOptions: {
+    ignoreLocation: boolean;
+    threshold: number;
+    useExtendedSearch: boolean;
+};

package/dist/src/helpers/index.d.ts

@@ -0,0 +1,21 @@
+export * from './cache';
+export * from './folderLink';
+export * from './resource';
+export * from './router';
+export * from './share';
+export * from './spaces';
+export * from './ui';
+export * from './breadcrumbs';
+export * from './clipboardActions';
+export * from './contextMenuDropdown';
+export * from './datetime';
+export * from './download';
+export * from './filesize';
+export * from './fuse';
+export * from './locale';
+export * from './path';
+export * from './statusIndicators';
+export * from './store';
+export * from './binary';
+export * from './platform';
+export * from './textByteSize';

package/dist/src/helpers/locale.d.ts

@@ -0,0 +1 @@
+export declare const getLocaleFromLanguage: (currentLanguage: string) => string;

package/dist/src/helpers/path.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return all absolute parent paths.
+ *
+ * For example if passing in "a/b/c" it will return
+ * ["/a/b", "/a", ""]
+
+ * If an empty string or "/" is passed in, an empty array is returned.
+ *
+ * @param {String} path path to process
+ * @param {Boolean} includeCurrent whether to include the current path (with leading slash)
+ * @return {Array.<String>} parent paths
+ */
+export declare function getParentPaths(path?: string, includeCurrent?: boolean): string[];

package/dist/src/helpers/permissions.d.ts

@@ -0,0 +1,8 @@
+import { Resource } from '@opencloud-eu/web-client';
+/**
+ * Asserts whether given resource can be moved
+ * @param {String} resource Resource which is to be moved
+ * @param {Object} parentPath Path of the parent folder of the resource
+ * @return {Boolean} can be moved
+ */
+export declare function canBeMoved(resource: Resource, parentPath: string): boolean;

package/dist/src/helpers/platform.d.ts

@@ -0,0 +1 @@
+export declare const isMacOs: () => RegExpMatchArray;

package/dist/src/helpers/resource/conflictHandling/conflictDialog.d.ts

@@ -0,0 +1,15 @@
+import { Resource } from '@opencloud-eu/web-client';
+import { ResolveConflict, ResolveStrategy } from './types';
+import { Language } from 'vue3-gettext';
+export interface FileConflict {
+    resource: Resource;
+    strategy?: ResolveStrategy;
+}
+export declare class ConflictDialog {
+    protected $gettext: Language['$gettext'];
+    protected $ngettext: Language['$ngettext'];
+    constructor($gettext: Language['$gettext'], $ngettext: Language['$ngettext']);
+    resolveAllConflicts(resourcesToMove: Resource[], targetFolder: Resource, targetFolderResources: Resource[]): Promise<FileConflict[]>;
+    resolveFileExists(resource: Resource, conflictCount: number, suggestMerge?: boolean, separateSkipHandling?: boolean): Promise<ResolveConflict>;
+    resolveDoCopyInsteadOfMoveForSpaces(): Promise<boolean>;
+}

package/dist/src/helpers/resource/conflictHandling/conflictUtils.d.ts

@@ -0,0 +1,3 @@
+import { Resource, SpaceResource } from '@opencloud-eu/web-client';
+export declare const resolveFileNameDuplicate: (name: string, extension: string, existingResources: Resource[], iteration?: number) => string;
+export declare const isResourceBeeingMovedToSameLocation: (sourceSpace: SpaceResource, resource: Resource, targetSpace: SpaceResource, targetFolder: Resource) => boolean;

package/dist/src/helpers/resource/conflictHandling/index.d.ts

@@ -0,0 +1,4 @@
+export * from './conflictDialog';
+export * from './conflictUtils';
+export * from './transfer';
+export * from './types';

package/dist/src/helpers/resource/conflictHandling/transfer.d.ts

@@ -0,0 +1,27 @@
+import { Resource, SpaceResource } from '@opencloud-eu/web-client';
+import { TransferType, TransferData } from './types';
+import { ConflictDialog } from './conflictDialog';
+import { ClientService } from '../../../services';
+import { Ref } from 'vue';
+import { Language } from 'vue3-gettext';
+export declare class ResourceTransfer extends ConflictDialog {
+    private sourceSpace;
+    private resourcesToMove;
+    private targetSpace;
+    private targetFolder;
+    private currentFolder;
+    private clientService;
+    constructor(sourceSpace: SpaceResource, resourcesToMove: Resource[], targetSpace: SpaceResource, targetFolder: Resource, currentFolder: Ref<Resource>, clientService: ClientService, $gettext: Language['$gettext'], $ngettext: Language['$ngettext']);
+    hasRecursion(): boolean;
+    showRecursionErrorMessage(): void;
+    showResultMessage(errors: {
+        resourceName: string;
+        error: Error;
+    }[], movedResources: Array<Resource>, transferType: TransferType): void;
+    /**
+     * Gathers transfer data after resolving all potential conflicts.
+     * This data can then be used to feed the web worker for pasting resources.
+     */
+    getTransferData(transferType: TransferType): Promise<TransferData[]>;
+    isOverwritingParentFolder(resource: Resource, targetFolder: Resource, targetFolderResources: Resource[]): boolean;
+}

package/dist/src/helpers/resource/conflictHandling/types.d.ts

@@ -0,0 +1,24 @@
+import { Resource, SpaceResource } from '@opencloud-eu/web-client';
+export declare enum ResolveStrategy {
+    SKIP = 0,
+    REPLACE = 1,
+    KEEP_BOTH = 2,
+    MERGE = 3
+}
+export interface ResolveConflict {
+    strategy: ResolveStrategy;
+    doForAllConflicts: boolean;
+}
+export declare enum TransferType {
+    COPY = 0,
+    MOVE = 1
+}
+export type TransferData = {
+    resource: Resource;
+    sourceSpace: SpaceResource;
+    targetSpace: SpaceResource;
+    targetFolder: Resource;
+    path: string;
+    overwrite: boolean;
+    transferType: TransferType;
+};

package/dist/src/helpers/resource/filter.d.ts

@@ -0,0 +1,2 @@
+import { Resource } from '@opencloud-eu/web-client';
+export declare const filterResources: <T extends Resource>(resources: T[], term: string, limit?: number) => T[];

package/dist/src/helpers/resource/icon.d.ts

@@ -0,0 +1,10 @@
+import { FillType } from '@opencloud-eu/design-system/helpers';
+export type IconFillType = FillType;
+export type IconType = {
+    name: string;
+    color?: string;
+    fillType?: IconFillType;
+};
+export type ResourceIconMapping = Record<'mimeType' | 'extension', Record<string, IconType>>;
+export declare const resourceIconMappingInjectionKey = "oc-resource-icon-mapping";
+export declare function createDefaultFileIconMapping(): Record<string, IconType>;

package/dist/src/helpers/resource/index.d.ts

@@ -0,0 +1,5 @@
+export * from './sameResource';
+export * from './conflictHandling';
+export * from './filter';
+export * from './icon';
+export * from './renameResource';

package/dist/src/helpers/resource/renameResource.d.ts

@@ -0,0 +1,2 @@
+import { Resource, SpaceResource } from '@opencloud-eu/web-client';
+export declare function renameResource(space: SpaceResource, resource: Resource, newPath: string): Resource;

package/dist/src/helpers/resource/sameResource.d.ts

@@ -0,0 +1,2 @@
+import { Resource } from '@opencloud-eu/web-client';
+export declare const isSameResource: (r1: Resource, r2: Resource) => boolean;

package/dist/src/helpers/router/buildUrl.d.ts

@@ -0,0 +1,2 @@
+import { Router } from 'vue-router';
+export declare const buildUrl: (router: Router, pathname: string) => string;

package/dist/src/helpers/router/index.d.ts

@@ -0,0 +1,2 @@
+export * from './routeOptions';
+export * from './buildUrl';

package/dist/src/helpers/router/routeOptions.d.ts

@@ -0,0 +1,24 @@
+import { SpaceResource } from '@opencloud-eu/web-client';
+import { ConfigStore, LocationQuery } from '../../composables';
+import { RouteParams } from 'vue-router';
+/**
+ * Creates route options for routing into a file location:
+ * - params.driveAliasAndItem
+ * - query.shareId
+ * - query.fileId
+ *
+ * Both query options are optional.
+ *
+ * @param space {SpaceResource}
+ * @param target {path: string, fileId: string | number}
+ * @param options {configStore: ConfigStore}
+ */
+export declare const createFileRouteOptions: (space: SpaceResource, target?: {
+    path?: string;
+    fileId?: string | number;
+}, options?: {
+    configStore: ConfigStore;
+}) => {
+    params: RouteParams;
+    query: LocationQuery;
+};

package/dist/src/helpers/share/driveItem.d.ts

@@ -0,0 +1,12 @@
+import { SpaceResource } from '@opencloud-eu/web-client';
+import { Graph } from '@opencloud-eu/web-client/graph';
+import { SpacesStore } from '../../composables';
+/**
+ * Gets the drive item for a given shared space.
+ */
+export declare const getSharedDriveItem: ({ graphClient, spacesStore, space, signal }: {
+    graphClient: Graph;
+    spacesStore: SpacesStore;
+    space: SpaceResource;
+    signal?: AbortSignal;
+}) => Promise<import('@opencloud-eu/web-client/graph/generated').DriveItem>;

package/dist/src/helpers/share/index.d.ts

@@ -0,0 +1,2 @@
+export * from './driveItem';
+export * from './sharedAncestorRoute';

package/dist/src/helpers/share/sharedAncestorRoute.d.ts

@@ -0,0 +1,7 @@
+import { SpaceResource } from '@opencloud-eu/web-client';
+import { RouteLocationNamedRaw } from 'vue-router';
+import { AncestorMetaDataValue } from '../../types';
+export declare const getSharedAncestorRoute: ({ sharedAncestor, matchingSpace }: {
+    sharedAncestor: AncestorMetaDataValue;
+    matchingSpace: SpaceResource;
+}) => RouteLocationNamedRaw;

package/dist/src/helpers/spaces/index.d.ts

@@ -0,0 +1 @@
+export * from './permissions';

package/dist/src/helpers/spaces/permissions.d.ts

@@ -0,0 +1,13 @@
+import { DriveItem } from '@opencloud-eu/web-client/graph/generated';
+import { SharesStore, SpacesStore } from '../../composables/piniaStores';
+import { SpaceResource } from '@opencloud-eu/web-client';
+/**
+ * Since shared spaces are only virtual, they and their permissions can't be fetched from the server.
+ * Hence the permissions for the current user may need to be set manually via the corresponding drive item.
+ */
+export declare const setCurrentUserShareSpacePermissions: ({ sharesStore, spacesStore, space, sharedDriveItem }: {
+    sharesStore: SharesStore;
+    spacesStore: SpacesStore;
+    space: SpaceResource;
+    sharedDriveItem: DriveItem;
+}) => void;

package/dist/src/helpers/statusIndicators.d.ts

@@ -0,0 +1,23 @@
+import { Resource, SpaceResource } from '@opencloud-eu/web-client';
+import { AncestorMetaData } from '../types';
+import { User } from '@opencloud-eu/web-client/graph/generated';
+import { IconFillType } from './resource';
+import { useInterceptModifierClick } from '../composables';
+export type ResourceIndicatorCategory = 'system' | 'sharing' | 'space';
+export interface ResourceIndicator {
+    id: string;
+    accessibleDescription: string;
+    label: string;
+    icon: string;
+    fillType: IconFillType;
+    type: string;
+    category: ResourceIndicatorCategory;
+    handler?: (resource: Resource, event?: MouseEvent) => void;
+}
+export declare const getIndicators: ({ space, resource, ancestorMetaData, user, interceptModifierClick }: {
+    space: SpaceResource;
+    resource: Resource;
+    ancestorMetaData: AncestorMetaData;
+    user: User;
+    interceptModifierClick: ReturnType<typeof useInterceptModifierClick>["interceptModifierClick"];
+}) => ResourceIndicator[];

package/dist/src/helpers/store.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Takes an object from state and creates a copy of it with only the values (no watchers, etc.)
+ * Editing the copied object does not result in errors due to modifying the state.
+ * The copied object is still reactive.
+ * @param {Object} state Object in the state to be copied
+ * @return {Object} Copied object
+ */
+export declare function cloneStateObject<T>(state: T): T;

package/dist/src/helpers/textByteSize.d.ts

@@ -0,0 +1 @@
+export declare const getTextByteSize: (text: string) => number;

package/dist/src/helpers/ui/index.d.ts

@@ -0,0 +1,3 @@
+export * from './resourceCheckbox';
+export * from './resourceTable';
+export * from './resourceTiles';

package/dist/src/helpers/ui/resourceCheckbox.d.ts

@@ -0,0 +1 @@
+export declare const focusCheckbox: (id: string) => void;

package/dist/src/helpers/ui/resourceTable.d.ts

@@ -0,0 +1,3 @@
+import { Resource } from '@opencloud-eu/web-client';
+import { SortField } from '../../composables/sort';
+export declare const determineResourceTableSortFields: (firstResource: Resource) => SortField[];

package/dist/src/helpers/ui/resourceTiles.d.ts

@@ -0,0 +1,6 @@
+import { Resource } from '@opencloud-eu/web-client';
+import { SortField } from '../../composables/sort';
+import { Language } from 'vue3-gettext';
+export declare const sortFields: SortField[];
+export declare const determineResourceTilesSortFields: (firstResource: Resource) => SortField[];
+export declare const translateSortFields: (fields: SortField[], { $gettext }: Language) => SortField[];

package/dist/src/http/client.d.ts

@@ -0,0 +1,23 @@
+import { AxiosRequestConfig, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+import { z } from 'zod';
+export type RequestConfig<D, S> = AxiosRequestConfig<D> & {
+    schema?: S extends z.Schema ? S : never;
+};
+export declare class HttpClient {
+    private readonly instance;
+    private readonly cancelToken;
+    constructor(config?: AxiosRequestConfig, interceptor?: (value: InternalAxiosRequestConfig<any>) => InternalAxiosRequestConfig<any> | Promise<InternalAxiosRequestConfig<any>>);
+    cancel(msg?: string): void;
+    delete<T = any, D = any, S extends z.Schema | T = T>(url: string, data?: D, config?: RequestConfig<D, S>): Promise<AxiosResponse<S extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> ? z.core.output<S> : S, any, {}>>;
+    get<T = unknown, D = any, S extends z.Schema | T = T>(url: string, config?: RequestConfig<D, S>): Promise<AxiosResponse<S extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> ? z.core.output<S> : S, any, {}>>;
+    head<T = any, D = any, S extends z.Schema | T = T>(url: string, config?: RequestConfig<D, S>): Promise<AxiosResponse<S extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> ? z.core.output<S> : S, any, {}>>;
+    options<T = any, D = any, S extends z.Schema | T = T>(url: string, config?: RequestConfig<D, S>): Promise<AxiosResponse<S extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> ? z.core.output<S> : S, any, {}>>;
+    patch<T = any, D = any, S extends z.Schema | T = T>(url: string, data?: D, config?: RequestConfig<D, S>): Promise<AxiosResponse<S extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> ? z.core.output<S> : S, any, {}>>;
+    post<T = any, D = any, S extends z.Schema | T = T>(url: string, data?: D, config?: RequestConfig<D, S>): Promise<AxiosResponse<S extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> ? z.core.output<S> : S, any, {}>>;
+    put<T = any, D = any, S extends z.Schema | T = T>(url: string, data?: D, config?: RequestConfig<D, S>): Promise<AxiosResponse<S extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> ? z.core.output<S> : S, any, {}>>;
+    request<T = any, D = any, S extends z.Schema | T = T>(config: RequestConfig<D, S>): Promise<AxiosResponse<S extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> ? z.core.output<S> : S, any, {}>>;
+    private obtainConfig;
+    private processResponse;
+    private internalRequest;
+    private internalRequestWithData;
+}

package/dist/src/http/index.d.ts

@@ -0,0 +1 @@
+export * from './client';

package/dist/src/index.d.ts

@@ -0,0 +1,14 @@
+export * from './apps';
+export * from './components';
+export * from './composables';
+export * from './constants';
+export * from './errors';
+export * from './helpers';
+export * from './http';
+export * from './observer';
+export * from './router';
+export * from './services';
+export * from './types';
+export * from './ui';
+export * from './utils';
+export * from './cern';

package/dist/src/observer/index.d.ts

@@ -0,0 +1 @@
+export * from './visibility';

package/dist/src/observer/visibility.d.ts

@@ -0,0 +1,26 @@
+interface CbackOptions {
+    element: Element;
+    callCount: number;
+    unobserve: () => void;
+}
+type cback = (options: CbackOptions) => void;
+interface Cbacks {
+    onEnter?: cback;
+    onExit?: cback;
+}
+interface VisibilityObserverOptions {
+    root?: Element | Document | null;
+    rootMargin?: string;
+    threshold?: number;
+}
+export declare class VisibilityObserver {
+    private targets;
+    private readonly intersectionObserver;
+    private readonly options;
+    constructor(options?: VisibilityObserverOptions);
+    observe(element: Element, cbacks?: Cbacks, threshold?: number): void;
+    unobserve(element: Element): void;
+    disconnect(): void;
+    private trigger;
+}
+export {};

package/dist/src/router/common.d.ts

@@ -0,0 +1,9 @@
+import { RouteComponents } from './router';
+import { RouteLocationNamedRaw, RouteRecordRaw } from 'vue-router';
+type commonTypes = 'files-common-favorites' | 'files-common-search';
+export declare const createLocationCommon: (name: commonTypes, location?: {}) => RouteLocationNamedRaw;
+export declare const locationFavorites: RouteLocationNamedRaw;
+export declare const locationSearch: RouteLocationNamedRaw;
+export declare const isLocationCommonActive: import('./utils').ActiveRouteDirectorFunc<commonTypes>;
+export declare const buildRoutes: (components: RouteComponents) => RouteRecordRaw[];
+export {};

package/dist/src/router/deprecated.d.ts

@@ -0,0 +1,12 @@
+import { RouteRecordRaw, RouteLocationNamedRaw, Router } from 'vue-router';
+/**
+ * listed routes only exist to keep backwards compatibility intact,
+ * all routes written in  a flat syntax to keep them readable.
+ */
+export declare const buildRoutes: () => RouteRecordRaw[];
+/**
+ * same as utils.isLocationActive with the difference that it remaps old route names to new ones and warns
+ * @param router
+ * @param comparatives
+ */
+export declare const isLocationActive: (router: Router, ...comparatives: [RouteLocationNamedRaw, ...RouteLocationNamedRaw[]]) => boolean;

package/dist/src/router/index.d.ts

@@ -0,0 +1,12 @@
+import { RouteRecordRaw } from 'vue-router';
+import { isLocationCommonActive, createLocationCommon } from './common';
+import { isLocationActive } from './deprecated';
+import { createLocationPublic, isLocationPublicActive, locationPublicLink, locationPublicUpload } from './public';
+import { RouteComponents } from './router';
+import { isLocationSharesActive, createLocationShares, locationSharesViaLink, locationSharesWithMe, locationSharesWithOthers, RouteShareTypes } from './shares';
+import { isLocationSpacesActive, createLocationSpaces, locationSpacesGeneric } from './spaces';
+import { isLocationTrashActive, createLocationTrash } from './trash';
+import { isLocationActiveDirector, createLocation, ActiveRouteDirectorFunc } from './utils';
+declare const buildRoutes: (components: RouteComponents) => RouteRecordRaw[];
+export { createLocation, createLocationCommon, createLocationShares, createLocationSpaces, createLocationPublic, isLocationCommonActive, isLocationSharesActive, isLocationSpacesActive, isLocationPublicActive, isLocationActive, isLocationActiveDirector, isLocationTrashActive, createLocationTrash, locationPublicLink, locationPublicUpload, locationSpacesGeneric, locationSharesViaLink, locationSharesWithMe, locationSharesWithOthers, buildRoutes, ActiveRouteDirectorFunc };
+export type { RouteShareTypes };

package/dist/src/router/public.d.ts

@@ -0,0 +1,9 @@
+import { RouteComponents } from './router';
+import { RouteLocationNamedRaw, RouteRecordRaw } from 'vue-router';
+type shareTypes = 'files-public-link' | 'files-public-upload';
+export declare const createLocationPublic: (name: shareTypes, location?: {}) => RouteLocationNamedRaw;
+export declare const locationPublicLink: RouteLocationNamedRaw;
+export declare const locationPublicUpload: RouteLocationNamedRaw;
+export declare const isLocationPublicActive: import('./utils').ActiveRouteDirectorFunc<shareTypes>;
+export declare const buildRoutes: (components: RouteComponents) => RouteRecordRaw[];
+export {};

package/dist/src/router/router.d.ts

@@ -0,0 +1,27 @@
+import { defineComponent } from 'vue';
+/**
+ * we need to inject the vue files into the route builders,
+ * this is because we also import the provided helpers from other js|ts files
+ * like mixins, rollup seems to have a problem to import files which contain vue file imports
+ * into js files which then again get imported by other vue files...
+ */
+type Component = ReturnType<typeof defineComponent>;
+export interface RouteComponents {
+    App: Component;
+    Favorites: Component;
+    FilesDrop: Component;
+    SearchResults: Component;
+    Shares: {
+        SharedWithMe: Component;
+        SharedWithOthers: Component;
+        SharedViaLink: Component;
+    };
+    Spaces: {
+        DriveResolver: Component;
+        Projects: Component;
+    };
+    Trash: {
+        Overview: Component;
+    };
+}
+export {};

package/dist/src/router/shares.d.ts

@@ -0,0 +1,10 @@
+import { RouteComponents } from './router';
+import { RouteLocationNamedRaw, RouteRecordRaw } from 'vue-router';
+export type RouteShareTypes = 'files-shares' | 'files-shares-with-me' | 'files-shares-with-others' | 'files-shares-via-link';
+export declare const createLocationShares: (name: RouteShareTypes, location?: {}) => RouteLocationNamedRaw;
+export declare const locationShares: RouteLocationNamedRaw;
+export declare const locationSharesWithMe: RouteLocationNamedRaw;
+export declare const locationSharesWithOthers: RouteLocationNamedRaw;
+export declare const locationSharesViaLink: RouteLocationNamedRaw;
+export declare const isLocationSharesActive: import('./utils').ActiveRouteDirectorFunc<RouteShareTypes>;
+export declare const buildRoutes: (components: RouteComponents) => RouteRecordRaw[];

package/dist/src/router/spaces.d.ts

@@ -0,0 +1,9 @@
+import { RouteLocationNamedRaw, RouteRecordRaw } from 'vue-router';
+import { RouteComponents } from './router';
+type spaceTypes = 'files-spaces-projects' | 'files-spaces-generic';
+export declare const createLocationSpaces: (name: spaceTypes, location?: {}) => RouteLocationNamedRaw;
+export declare const locationSpacesProjects: RouteLocationNamedRaw;
+export declare const locationSpacesGeneric: RouteLocationNamedRaw;
+export declare const isLocationSpacesActive: import('./utils').ActiveRouteDirectorFunc<spaceTypes>;
+export declare const buildRoutes: (components: RouteComponents) => RouteRecordRaw[];
+export {};

package/dist/src/router/trash.d.ts

@@ -0,0 +1,9 @@
+import { RouteComponents } from './router';
+import { RouteLocationNamedRaw, RouteRecordRaw } from 'vue-router';
+type trashTypes = 'files-trash-generic' | 'files-trash-overview';
+export declare const createLocationTrash: (name: trashTypes, location?: {}) => RouteLocationNamedRaw;
+export declare const locationTrashGeneric: RouteLocationNamedRaw;
+export declare const locationTrashOverview: RouteLocationNamedRaw;
+export declare const isLocationTrashActive: import('./utils').ActiveRouteDirectorFunc<trashTypes>;
+export declare const buildRoutes: (components: RouteComponents) => RouteRecordRaw[];
+export {};

package/dist/src/router/utils.d.ts

@@ -0,0 +1,32 @@
+import { Router, RouteLocationNamedRaw } from 'vue-router';
+export interface ActiveRouteDirectorFunc<T extends string> {
+    (router: Router, ...comparatives: T[]): boolean;
+}
+/**
+ * helper function to find out if comparative route location is active or not.
+ * it uses vue router resolve to do so.
+ *
+ * @param router
+ * @param comparatives
+ */
+export declare const isLocationActive: (router: Router, ...comparatives: [RouteLocationNamedRaw, ...RouteLocationNamedRaw[]]) => boolean;
+/**
+ * wraps isLocationActive to be used as a closure,
+ * the resulting closure then can be used to check a location against the defined set of director locations
+ *
+ * @param defaultComparatives
+ */
+export declare const isLocationActiveDirector: <T extends string>(...defaultComparatives: [RouteLocationNamedRaw, ...RouteLocationNamedRaw[]]) => ActiveRouteDirectorFunc<T>;
+/**
+ * just a dummy function to trick gettext tools
+ *
+ * @param msg
+ */
+export declare function $gettext(msg: string): string;
+/**
+ * create a location with attached default values
+ *
+ * @param name
+ * @param locations
+ */
+export declare const createLocation: (name: string, ...locations: RouteLocationNamedRaw[]) => RouteLocationNamedRaw;

package/dist/src/services/appProvider/index.d.ts

@@ -0,0 +1,2 @@
+export * from './schemas';
+export * from './service';

package/dist/src/services/appProvider/schemas.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+declare const ExternalAppSchema: z.ZodObject<{
+    icon: z.ZodString;
+    name: z.ZodString;
+    secure_view: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    target_ext: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ExternalApp = z.infer<typeof ExternalAppSchema>;
+declare const MimeTypeSchema: z.ZodObject<{
+    allow_creation: z.ZodOptional<z.ZodBoolean>;
+    app_providers: z.ZodArray<z.ZodObject<{
+        icon: z.ZodString;
+        name: z.ZodString;
+        secure_view: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        target_ext: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    default_application: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    ext: z.ZodOptional<z.ZodString>;
+    mime_type: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MimeType = z.infer<typeof MimeTypeSchema>;
+export declare const MimeTypesToAppsSchema: z.ZodObject<{
+    'mime-types': z.ZodArray<z.ZodObject<{
+        allow_creation: z.ZodOptional<z.ZodBoolean>;
+        app_providers: z.ZodArray<z.ZodObject<{
+            icon: z.ZodString;
+            name: z.ZodString;
+            secure_view: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            target_ext: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        default_application: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ext: z.ZodOptional<z.ZodString>;
+        mime_type: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export {};

package/dist/src/services/appProvider/service.d.ts

@@ -0,0 +1,27 @@
+import { MimeType } from './schemas';
+import { ClientService } from '../client';
+export declare class AppProviderService {
+    private _mimeTypes;
+    private readonly serverUrl;
+    private readonly clientService;
+    constructor(serverUrl: string, clientService: ClientService);
+    loadData(): Promise<void>;
+    set mimeTypes(value: MimeType[]);
+    get mimeTypes(): MimeType[];
+    get templateMimeTypes(): {
+        app_providers: {
+            icon: string;
+            name: string;
+            secure_view: boolean;
+            target_ext?: string;
+        }[];
+        mime_type: string;
+        allow_creation?: boolean;
+        default_application?: string;
+        description?: string;
+        ext?: string;
+        name?: string;
+    }[];
+    get appNames(): string[];
+    getMimeTypesByAppName(appName: string): MimeType[];
+}