@opencloud-eu/web-pkg 0.1.1 → 1.0.0

package/dist/package/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(): {
+        name?: string;
+        description?: string;
+        app_providers?: {
+            name?: string;
+            icon?: string;
+            secure_view?: boolean;
+            target_ext?: string;
+        }[];
+        allow_creation?: boolean;
+        default_application?: string;
+        ext?: string;
+        mime_type?: string;
+    }[];
+    get appNames(): string[];
+    getMimeTypesByAppName(appName: string): MimeType[];
+}

package/dist/package/src/services/archiver.d.ts

@@ -0,0 +1,26 @@
+import { ClientService } from '../services';
+import { Ref } from 'vue';
+import { ArchiverCapability } from '@opencloud-eu/web-client/ocs';
+import { UserStore } from '../composables';
+interface TriggerDownloadOptions {
+    dir?: string;
+    files?: string[];
+    fileIds?: string[];
+    downloadSecret?: string;
+    publicToken?: string;
+    publicLinkPassword?: string;
+}
+export declare class ArchiverService {
+    clientService: ClientService;
+    userStore: UserStore;
+    serverUrl: string;
+    capability: Ref<ArchiverCapability>;
+    available: Ref<boolean>;
+    fileIdsSupported: Ref<boolean>;
+    constructor(clientService: ClientService, userStore: UserStore, serverUrl: string, archiverCapabilities?: Ref<ArchiverCapability[]>);
+    triggerDownload(options: TriggerDownloadOptions): Promise<string>;
+    private buildDownloadUrl;
+    private get url();
+    private getFileNameFromResponseHeaders;
+}
+export {};

package/dist/package/src/services/cache.d.ts

@@ -0,0 +1,14 @@
+import { Cache } from '../helpers/cache';
+declare class CacheService {
+    get avatarUrl(): Cache<string, {
+        size?: number;
+        src?: string;
+    }>;
+    get filePreview(): Cache<string, {
+        etag?: string;
+        src?: string;
+        dimensions?: [number, number];
+    }>;
+}
+export declare const cacheService: CacheService;
+export {};

package/dist/package/src/services/client/auth.d.ts

@@ -0,0 +1,12 @@
+export interface AuthParameters {
+    accessToken?: string;
+    publicLinkToken?: string;
+    publicLinkPassword?: string;
+}
+export declare class Auth {
+    accessToken?: string;
+    publicLinkToken?: string;
+    publicLinkPassword?: string;
+    constructor(params?: AuthParameters);
+    getHeaders(): Record<string, string>;
+}

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

@@ -0,0 +1,43 @@
+import { HttpClient } from '../../http';
+import { Graph } from '@opencloud-eu/web-client/graph';
+import { OCS } from '@opencloud-eu/web-client/ocs';
+import { WebDAV } from '@opencloud-eu/web-client/webdav';
+import { Language } from 'vue3-gettext';
+import { AuthStore, ConfigStore } from '../../composables';
+export interface ClientServiceOptions {
+    configStore: ConfigStore;
+    language: Language;
+    authStore: AuthStore;
+}
+export declare class ClientService {
+    private configStore;
+    private language;
+    private authStore;
+    private httpAuthenticatedClient;
+    private httpUnAuthenticatedClient;
+    private graphClient;
+    private ocsClient;
+    private webDavClient;
+    initiatorId: string;
+    private staticHeaders;
+    constructor(options: ClientServiceOptions);
+    get httpAuthenticated(): HttpClient;
+    get httpUnAuthenticated(): HttpClient;
+    get graphAuthenticated(): Graph;
+    get sseAuthenticated(): EventSource;
+    get ocs(): OCS;
+    /** @deprecated use `ocs()` instead */
+    get ocsUserContext(): OCS;
+    /** @deprecated use `ocs()` instead */
+    ocsPublicLinkContext(password?: string): OCS;
+    get webdav(): WebDAV;
+    get currentLanguage(): string;
+    private initGraphClient;
+    private initOcsClient;
+    private initWebDavClient;
+    /**
+     * Dynamic headers that should be provided via callback or interceptor because they may
+     * change during the lifetime of the application (e.g. token renewal).
+     */
+    private getDynamicHeaders;
+}

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

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

package/dist/package/src/services/eventBus.d.ts

@@ -0,0 +1,8 @@
+export declare class EventBus {
+    private topics;
+    constructor();
+    subscribe<T = unknown>(topic: string, callback: (data?: T) => void): string;
+    publish(topic: string, data?: unknown): void;
+    unsubscribe(topic: string, token: string): void;
+}
+export declare const eventBus: EventBus;

package/dist/package/src/services/folder/folderService.d.ts

@@ -0,0 +1,26 @@
+import { Router } from 'vue-router';
+import { UserStore, SpacesStore, CapabilityStore, ConfigStore, ResourcesStore, SharesStore, AuthServiceInterface } from '../../composables';
+import { ClientService } from '../../services';
+export type FolderLoaderTask = any;
+export type TaskContext = {
+    clientService: ClientService;
+    configStore: ConfigStore;
+    userStore: UserStore;
+    spacesStore: SpacesStore;
+    router: Router;
+    capabilityStore: CapabilityStore;
+    resourcesStore: ResourcesStore;
+    sharesStore: SharesStore;
+    authService: AuthServiceInterface;
+};
+export interface FolderLoader {
+    isEnabled(): boolean;
+    isActive(router: Router): boolean;
+    getTask(options: TaskContext): FolderLoaderTask;
+}
+export declare class FolderService {
+    private readonly loaders;
+    constructor();
+    getTask(): FolderLoaderTask;
+}
+export declare const folderService: FolderService;

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

@@ -0,0 +1,2 @@
+export * from './folderService';
+export * from './loaders';

package/dist/package/src/services/folder/loaders/index.d.ts

@@ -0,0 +1,7 @@
+export * from './loaderSpace';
+export * from './loaderFavorites';
+export * from './loaderSharedViaLink';
+export * from './loaderSharedWithMe';
+export * from './loaderSharedWithOthers';
+export * from './loaderTrashbin';
+export * from './types';

package/dist/package/src/services/folder/loaders/loaderFavorites.d.ts

@@ -0,0 +1,7 @@
+import { FolderLoader, FolderLoaderTask, TaskContext } from '../folderService';
+import { Router } from 'vue-router';
+export declare class FolderLoaderFavorites implements FolderLoader {
+    isEnabled(): boolean;
+    isActive(router: Router): boolean;
+    getTask(context: TaskContext): FolderLoaderTask;
+}

package/dist/package/src/services/folder/loaders/loaderSharedViaLink.d.ts

@@ -0,0 +1,7 @@
+import { FolderLoader, FolderLoaderTask, TaskContext } from '../folderService';
+import { Router } from 'vue-router';
+export declare class FolderLoaderSharedViaLink implements FolderLoader {
+    isEnabled(): boolean;
+    isActive(router: Router): boolean;
+    getTask(context: TaskContext): FolderLoaderTask;
+}

package/dist/package/src/services/folder/loaders/loaderSharedWithMe.d.ts

@@ -0,0 +1,7 @@
+import { FolderLoader, FolderLoaderTask, TaskContext } from '../folderService';
+import { Router } from 'vue-router';
+export declare class FolderLoaderSharedWithMe implements FolderLoader {
+    isEnabled(): boolean;
+    isActive(router: Router): boolean;
+    getTask(context: TaskContext): FolderLoaderTask;
+}

package/dist/package/src/services/folder/loaders/loaderSharedWithOthers.d.ts

@@ -0,0 +1,7 @@
+import { FolderLoader, FolderLoaderTask, TaskContext } from '../folderService';
+import { Router } from 'vue-router';
+export declare class FolderLoaderSharedWithOthers implements FolderLoader {
+    isEnabled(): boolean;
+    isActive(router: Router): boolean;
+    getTask(context: TaskContext): FolderLoaderTask;
+}

package/dist/package/src/services/folder/loaders/loaderSpace.d.ts

@@ -0,0 +1,12 @@
+import { FolderLoader, FolderLoaderTask, TaskContext } from '../folderService';
+import { Router } from 'vue-router';
+export declare class FolderLoaderSpace implements FolderLoader {
+    isEnabled(): boolean;
+    isActive(router: Router): boolean;
+    getTask(context: TaskContext): FolderLoaderTask;
+    /**
+     * Since shared spaces are only virtual, they and their permissions can't be fetched from the server.
+     * Hence the permissions for the current user need to be set manually via the corresponding drive item.
+     */
+    private setCurrentUserShareSpacePermissions;
+}

package/dist/package/src/services/folder/loaders/loaderTrashbin.d.ts

@@ -0,0 +1,7 @@
+import { FolderLoader, FolderLoaderTask, TaskContext } from '../folderService';
+import { Router } from 'vue-router';
+export declare class FolderLoaderTrashbin implements FolderLoader {
+    isEnabled(): boolean;
+    isActive(router: Router): boolean;
+    getTask(context: TaskContext): FolderLoaderTask;
+}

package/dist/package/src/services/folder/loaders/types.d.ts

@@ -0,0 +1,3 @@
+export interface FolderLoaderOptions {
+    loadShares?: boolean;
+}

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

@@ -0,0 +1,10 @@
+export * from './appProvider';
+export * from './archiver';
+export * from './cache';
+export * from './client';
+export * from './eventBus';
+export * from './folder';
+export * from './loadingService';
+export * from './preview';
+export * from './passwordPolicy';
+export * from './uppy';

package/dist/package/src/services/loadingService.d.ts

@@ -0,0 +1,33 @@
+export declare enum LoadingEventTopics {
+    add = "loading-service.add",
+    remove = "loading-service.remove",
+    setProgress = "loading-service.set-progress"
+}
+export interface LoadingTaskState {
+    total: number;
+    current: number;
+}
+export interface LoadingTask {
+    id: string;
+    active: boolean;
+    state?: LoadingTaskState;
+}
+export interface LoadingTaskCallbackArguments {
+    setProgress: (args: LoadingTaskState) => void;
+}
+export declare class LoadingService {
+    private tasks;
+    get isLoading(): boolean;
+    /**
+     * Get the current progress from 0 to 100.
+     * Returns null if at least one task is indeterminate.
+     */
+    get currentProgress(): number | null;
+    addTask<T>(callback: ({ setProgress }: LoadingTaskCallbackArguments) => Promise<T>, { debounceTime, indeterminate }?: {
+        debounceTime?: number;
+        indeterminate?: boolean;
+    }): Promise<T>;
+    private removeTask;
+    private setProgress;
+    private onBeforeUnload;
+}

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

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

package/dist/package/src/services/passwordPolicy/passwordPolicy.d.ts

@@ -0,0 +1,20 @@
+import { Language } from 'vue3-gettext';
+import { CapabilityStore } from '../../composables';
+import { PasswordPolicy } from 'password-sheriff';
+export declare class PasswordPolicyService {
+    private readonly language;
+    private capability;
+    private policy;
+    private generatePasswordRules;
+    constructor({ language }: {
+        language: Language;
+    });
+    initialize(capabilityStore: CapabilityStore): void;
+    private hasRules;
+    private buildGeneratePasswordRules;
+    private buildPolicy;
+    getPolicy({ enforcePassword }?: {
+        enforcePassword?: boolean;
+    }): PasswordPolicy;
+    generatePassword(): string;
+}

package/dist/package/src/services/passwordPolicy/rules.d.ts

@@ -0,0 +1,63 @@
+import { Language } from 'vue3-gettext';
+export interface PasswordPolicyRuleOptions {
+    minLength?: number;
+    maxLength?: number;
+    characters?: string;
+}
+export interface PasswordPolicyRuleExplained {
+    code: string;
+    message: string;
+    helperMessage?: string;
+    format: (number | string)[];
+    verified?: boolean;
+}
+export interface PasswordPolicyRule {
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+    explain(options: PasswordPolicyRuleOptions, verified?: boolean): PasswordPolicyRuleExplained;
+    missing(options: PasswordPolicyRuleOptions, password: string): PasswordPolicyRuleExplained;
+    validate(options?: PasswordPolicyRuleOptions): boolean;
+}
+export declare class MustNotBeEmptyRule implements PasswordPolicyRule {
+    protected $gettext: any;
+    constructor({ $gettext }: Language);
+    explain(options: PasswordPolicyRuleOptions, verified: boolean): PasswordPolicyRuleExplained;
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+    validate(): boolean;
+    missing(options: PasswordPolicyRuleOptions, password: string): PasswordPolicyRuleExplained;
+}
+export declare class MustContainRule implements PasswordPolicyRule {
+    protected $gettext: any;
+    constructor({ $gettext }: Language);
+    explain(options: PasswordPolicyRuleOptions, verified: boolean): PasswordPolicyRuleExplained;
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+    validate(options: PasswordPolicyRuleOptions): boolean;
+    missing(options: PasswordPolicyRuleOptions, password: string): PasswordPolicyRuleExplained;
+}
+export declare class AtLeastBaseRule implements PasswordPolicyRule {
+    protected $gettext: any;
+    constructor({ $gettext }: Language);
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+    explain(options: PasswordPolicyRuleOptions, verified?: boolean): PasswordPolicyRuleExplained;
+    validate(options: PasswordPolicyRuleOptions): boolean;
+    missing(options: PasswordPolicyRuleOptions, password: string): PasswordPolicyRuleExplained;
+}
+export declare class AtLeastCharactersRule extends AtLeastBaseRule implements PasswordPolicyRule {
+    constructor(args: Language);
+    explain(options: PasswordPolicyRuleOptions, verified: boolean): PasswordPolicyRuleExplained;
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+}
+export declare class AtLeastUppercaseCharactersRule extends AtLeastBaseRule {
+    constructor(args: Language);
+    explain(options: PasswordPolicyRuleOptions, verified: boolean): PasswordPolicyRuleExplained;
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+}
+export declare class AtLeastLowercaseCharactersRule extends AtLeastBaseRule {
+    constructor(args: Language);
+    explain(options: PasswordPolicyRuleOptions, verified: boolean): PasswordPolicyRuleExplained;
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+}
+export declare class AtLeastDigitsRule extends AtLeastBaseRule {
+    constructor(args: Language);
+    explain(options: PasswordPolicyRuleOptions, verified: boolean): PasswordPolicyRuleExplained;
+    assert(options: PasswordPolicyRuleOptions, password: string): boolean;
+}

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

@@ -0,0 +1,2 @@
+export * from './previewService';
+export * from './types';

package/dist/package/src/services/preview/previewService.d.ts

@@ -0,0 +1,28 @@
+import { ClientService } from '../client';
+import { LoadPreviewOptions } from '.';
+import { AuthStore, CapabilityStore, ConfigStore, UserStore } from '../../composables';
+export declare class PreviewService {
+    clientService: ClientService;
+    configStore: ConfigStore;
+    userStore: UserStore;
+    authStore: AuthStore;
+    capabilityStore: CapabilityStore;
+    capability?: CapabilityStore['capabilities']['files']['thumbnail'];
+    constructor({ clientService, userStore, authStore, capabilityStore, configStore }: {
+        clientService: ClientService;
+        userStore: UserStore;
+        authStore: AuthStore;
+        capabilityStore: CapabilityStore;
+        configStore: ConfigStore;
+    });
+    private get available();
+    private get supportedMimeTypes();
+    private get user();
+    isMimetypeSupported(mimeType: string, onlyImages?: boolean): boolean;
+    getSupportedMimeTypes(filter?: string): string[];
+    loadPreview(options: LoadPreviewOptions, cached?: boolean, silenceErrors?: boolean, signal?: AbortSignal): Promise<string | undefined>;
+    private cacheFactory;
+    private buildQueryString;
+    private privatePreviewBlob;
+    private publicPreviewUrl;
+}

package/dist/package/src/services/preview/types.d.ts

@@ -0,0 +1,18 @@
+import { Resource, SpaceResource } from '@opencloud-eu/web-client';
+import { z } from 'zod';
+export declare const ProcessorType: z.ZodEnum<["fit", "resize", "fill", "thumbnail"]>;
+export type ProcessorType = z.infer<typeof ProcessorType>;
+export interface BuildQueryStringOptions {
+    preview?: number;
+    scalingup?: number;
+    a?: number;
+    etag?: string;
+    dimensions?: [number, number];
+    processor?: ProcessorType;
+}
+export interface LoadPreviewOptions {
+    space: SpaceResource;
+    resource: Resource;
+    dimensions?: [number, number];
+    processor?: ProcessorType;
+}

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

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

package/dist/package/src/services/uppy/uppyService.d.ts

@@ -0,0 +1,90 @@
+import { default as Uppy, BasePlugin, UnknownPlugin, UppyFile } from '@uppy/core';
+import { TusOptions } from '@uppy/tus';
+import { XHRUploadOptions } from '@uppy/xhr-upload';
+import { Language } from 'vue3-gettext';
+import { Resource } from '@opencloud-eu/web-client';
+import { Body, MinimalRequiredUppyFile } from '@uppy/utils/lib/UppyFile';
+type UppyServiceTopics = 'uploadStarted' | 'uploadCancelled' | 'uploadCompleted' | 'uploadSuccess' | 'uploadError' | 'filesSelected' | 'progress' | 'addedForUpload' | 'upload-progress' | 'drag-over' | 'drag-out' | 'drop';
+export type uppyHeaders = {
+    [name: string]: string | number;
+};
+export type UploadResult = {
+    successful: OcUppyFile[];
+    failed: OcUppyFile[];
+    uploadID?: string;
+};
+interface UppyServiceOptions {
+    language: Language;
+}
+export type OcUppyMeta = {
+    retry?: boolean;
+    name?: string;
+    mtime?: number;
+    spaceId: string;
+    spaceName: string;
+    driveAlias: string;
+    driveType: string;
+    currentFolder: string;
+    currentFolderId?: string;
+    fileId?: string;
+    uppyId?: string;
+    relativeFolder: string;
+    relativePath: string;
+    tusEndpoint: string;
+    uploadId: string;
+    topLevelFolderId?: string;
+    routeName?: string;
+    routeDriveAliasAndItem?: string;
+    routeShareId?: string;
+    isFolder: boolean;
+};
+export type OcUppyBody = Body;
+export type OcUppyFile = UppyFile<OcUppyMeta, OcUppyBody>;
+type OcUppyPlugin = typeof BasePlugin<any, OcUppyMeta, OcUppyBody>;
+export type OcMinimalUppyFile = MinimalRequiredUppyFile<OcUppyMeta, OcUppyBody>;
+export type OcTusOptions = TusOptions<OcUppyMeta, OcUppyBody>;
+/** `OmitFirstArg<typeof someArray>` is the type of the returned value of `someArray.slice(1)`. */
+type OmitFirstArg<T> = T extends [any, ...infer U] ? U : never;
+export declare class UppyService {
+    uppy: Uppy<OcUppyMeta, OcUppyBody>;
+    uploadInputs: HTMLInputElement[];
+    uploadFolderMap: Record<string, Resource>;
+    constructor({ language }: UppyServiceOptions);
+    getRelativeFilePath: (file: OcUppyFile) => string | undefined;
+    addPlugin<T extends OcUppyPlugin>(Plugin: T, ...args: OmitFirstArg<ConstructorParameters<T>>): void;
+    removePlugin(plugin: UnknownPlugin<OcUppyMeta, OcUppyBody>): void;
+    getPlugin<T extends UnknownPlugin<OcUppyMeta, OcUppyBody> = UnknownPlugin<OcUppyMeta, OcUppyBody>>(name: string): T | undefined;
+    useTus({ chunkSize, overridePatchMethod, uploadDataDuringCreation, onBeforeRequest, headers }: TusOptions<OcUppyMeta, OcUppyBody>): void;
+    useXhr({ headers, timeout, endpoint }: XHRUploadOptions<OcUppyMeta, OcUppyBody>): void;
+    tusActive(): boolean;
+    useDropTarget({ targetSelector }: {
+        targetSelector: string;
+    }): void;
+    removeDropTarget(): void;
+    subscribe<T>(topic: UppyServiceTopics, callback: (data?: T) => void): string;
+    unsubscribe(topic: UppyServiceTopics, token: string): void;
+    publish(topic: UppyServiceTopics, data?: unknown): void;
+    private setUpEvents;
+    registerUploadInput(el: HTMLInputElement): void;
+    removeUploadInput(el: HTMLInputElement): void;
+    generateUploadId(uppyFile: OcUppyFile): string;
+    addFiles(files: OcMinimalUppyFile[] | File[]): void;
+    uploadFiles(): Promise<import('@uppy/core').UploadResult<OcUppyMeta, Body>>;
+    retryAllUploads(): Promise<import('@uppy/core').UploadResult<OcUppyMeta, Body>>;
+    pauseAllUploads(): void;
+    resumeAllUploads(): void;
+    cancelAllUploads(): void;
+    getCurrentUploads(): Record<string, unknown>;
+    isRemoteUploadInProgress(): boolean;
+    clearInputs(): void;
+    /**
+     * Set a specific upload folder for an upload. The HandleUpload plugin
+     * checks, if a specific folder has been specified as upload destination.
+     * If not, it falls back to the current folder.
+     * The uploadId needs to be set within the meta object of the upload files
+     * for the plugin to connect an upload to its destination folder.
+     **/
+    setUploadFolder(uploadId: string, folder: Resource): void;
+    removeUploadFolder(uploadId: string): void;
+}
+export {};

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

@@ -0,0 +1,17 @@
+export interface AncestorMetaDataValue {
+    id: string;
+    shareTypes: number[];
+    parentFolderId: string;
+    spaceId: string;
+    path: string;
+}
+export type AncestorMetaData = Record<string, AncestorMetaDataValue>;
+export type FederatedUser = {
+    display_name: string;
+    idp: string;
+    mail: string;
+    user_id: string;
+};
+export type FederatedConnection = FederatedUser & {
+    id: string;
+};

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

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

package/dist/package/src/ui/types.d.ts

@@ -0,0 +1,13 @@
+import { IconFillType } from '../helpers/resource';
+import { Component } from 'vue';
+export type FolderView = {
+    name: string;
+    label: string;
+    icon: {
+        name: string;
+        fillType: IconFillType;
+    };
+    isScrollable?: boolean;
+    component: Component;
+    componentAttrs?: () => Record<string, unknown>;
+};

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

@@ -0,0 +1 @@
+export { dirname } from 'path';

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

@@ -0,0 +1 @@
+export declare const encodePath: (path?: string) => string;

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

@@ -0,0 +1,4 @@
+export * from './dirname';
+export * from './encodePath';
+export * from './objectKeys';
+export * from './types';

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

@@ -0,0 +1 @@
+export declare const objectKeys: (obj: Record<string, unknown>) => string[];

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

@@ -0,0 +1,5 @@
+import { Ref, MaybeRef } from 'vue';
+export type StringUnionOrAnyString<T extends string> = T | Omit<string, T>;
+export type ReadOnlyRef<T> = Readonly<Ref<T>>;
+export type MaybeReadonlyRef<T> = MaybeRef<T> | ReadOnlyRef<T>;
+export type { MaybeRef } from 'vue';

package/dist/package/vite.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vite').UserConfig;
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencloud-eu/web-pkg",
-  "version": "0.1.1",
+  "version": "1.0.0",
   "description": "OpenCloud web pkg",
   "license": "AGPL-3.0",
   "main": "src/index.ts",
@@ -59,8 +59,8 @@
     "vue-router": "^4.2.5",
     "vue3-gettext": "^2.4.0",
     "zod": "^3.23.8",
-    "@opencloud-eu/design-system": "^0.1.0",
-    "@opencloud-eu/web-client": "^0.1.0"
+    "@opencloud-eu/design-system": "^1.0.0",
+    "@opencloud-eu/web-client": "^1.0.0"
   },
   "exports": {
     ".": {