@internxt/cli 1.2.2 → 1.3.1

package/dist/services/database/drive-file/drive-file.model.js

@@ -43,6 +43,10 @@ __decorate([
     (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.INTEGER),
     __metadata("design:type", Number)
 ], DriveFileModel.prototype, "folderId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.UUIDV4),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "folderUuid", void 0);
 __decorate([
     (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.STRING(24)),
     __metadata("design:type", String)

package/dist/services/database/drive-folder/drive-folder.attributes.d.ts

@@ -5,6 +5,7 @@ export interface DriveFolderAttributes {
     status: 'EXISTS' | 'TRASHED';
     relativePath: string;
     parentId: number | null;
+    parentUuid: string | null;
     createdAt: Date;
     updatedAt: Date;
 }

package/dist/services/database/drive-folder/drive-folder.domain.d.ts

@@ -1,3 +1,4 @@
+import { DriveFolderItem } from '../../../types/drive.types';
 import { DriveFolderAttributes } from './drive-folder.attributes';
 export declare class DriveFolder implements DriveFolderAttributes {
     id: number;
@@ -5,10 +6,12 @@ export declare class DriveFolder implements DriveFolderAttributes {
     uuid: string;
     relativePath: string;
     parentId: number | null;
+    parentUuid: string | null;
     createdAt: Date;
     updatedAt: Date;
     status: DriveFolderAttributes['status'];
-    constructor({ id, name, uuid, relativePath, parentId, createdAt, updatedAt, status }: DriveFolderAttributes);
+    constructor({ id, name, uuid, relativePath, parentId, parentUuid, createdAt, updatedAt, status, }: DriveFolderAttributes);
     static build(folder: DriveFolderAttributes): DriveFolder;
     toJSON(): DriveFolderAttributes;
+    toItem(): DriveFolderItem;
 }

package/dist/services/database/drive-folder/drive-folder.domain.js

@@ -7,15 +7,17 @@ class DriveFolder {
     uuid;
     relativePath;
     parentId;
+    parentUuid;
     createdAt;
     updatedAt;
     status;
-    constructor({ id, name, uuid, relativePath, parentId, createdAt, updatedAt, status }) {
+    constructor({ id, name, uuid, relativePath, parentId, parentUuid, createdAt, updatedAt, status, }) {
         this.id = id;
         this.name = name;
         this.uuid = uuid;
         this.relativePath = relativePath;
         this.parentId = parentId;
+        this.parentUuid = parentUuid;
         this.createdAt = createdAt;
         this.updatedAt = updatedAt;
         this.status = status;
@@ -31,9 +33,24 @@ class DriveFolder {
             status: this.status,
             relativePath: this.relativePath,
             parentId: this.parentId,
+            parentUuid: this.parentUuid,
             createdAt: this.createdAt,
             updatedAt: this.updatedAt,
         };
     }
+    toItem() {
+        return {
+            id: this.id,
+            name: this.name,
+            uuid: this.uuid,
+            status: this.status,
+            parentId: this.parentId,
+            parentUuid: this.parentUuid,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+            encryptedName: '',
+            bucket: null,
+        };
+    }
 }
 exports.DriveFolder = DriveFolder;

package/dist/services/database/drive-folder/drive-folder.model.d.ts

@@ -7,6 +7,7 @@ export declare class DriveFolderModel extends Model implements DriveFolderAttrib
     uuid: string;
     relativePath: string;
     parentId: number | null;
+    parentUuid: string | null;
     createdAt: Date;
     updatedAt: Date;
 }

package/dist/services/database/drive-folder/drive-folder.model.js

@@ -43,6 +43,11 @@ __decorate([
     (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.INTEGER),
     __metadata("design:type", Object)
 ], DriveFolderModel.prototype, "parentId", void 0);
+__decorate([
+    sequelize_typescript_1.AllowNull,
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.UUIDV4),
+    __metadata("design:type", Object)
+], DriveFolderModel.prototype, "parentUuid", void 0);
 __decorate([
     (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.DATE),
     __metadata("design:type", Date)

package/dist/services/drive/drive-file.service.d.ts

@@ -12,4 +12,9 @@ export declare class DriveFileService {
     }) => Promise<DriveFileItem>;
     getFileMetadata: (uuid: string) => Promise<DriveFileItem>;
     moveFile: (payload: StorageTypes.MoveFileUuidPayload) => Promise<StorageTypes.FileMeta>;
+    renameFile: (fileUuid: string, payload: {
+        plainName?: string;
+        type?: string | null;
+    }) => Promise<void>;
+    getFileMetadataByPath: (path: string) => Promise<DriveFileItem>;
 }

package/dist/services/drive/drive-file.service.js

@@ -35,6 +35,7 @@ class DriveFileService {
             type: payload.type,
             status: driveFile.status,
             folderId: driveFile.folderId,
+            folderUuid: driveFile.folderUuid,
         };
     };
     getFileMetadata = async (uuid) => {
@@ -47,5 +48,14 @@ class DriveFileService {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
         return storageClient.moveFileByUuid(payload);
     };
+    renameFile = (fileUuid, payload) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        return storageClient.updateFileMetaByUUID(fileUuid, payload);
+    };
+    getFileMetadataByPath = async (path) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const fileMetadata = await storageClient.getFileByPath(encodeURIComponent(path));
+        return drive_utils_1.DriveUtils.driveFileMetaToItem(fileMetadata);
+    };
 }
 exports.DriveFileService = DriveFileService;

package/dist/services/drive/drive-folder.service.d.ts

@@ -10,11 +10,16 @@ export declare class DriveFolderService {
         folders: FetchPaginatedFolder[];
         files: FetchPaginatedFile[];
     }>;
-    private getAllSubfolders;
-    private getAllSubfiles;
+    private readonly getAllSubfolders;
+    private readonly getAllSubfiles;
     moveFolder: (payload: StorageTypes.MoveFolderUuidPayload) => Promise<StorageTypes.FolderMeta>;
     createFolder(payload: {
         folderName: string;
         parentFolderId: number;
     }): [Promise<StorageTypes.CreateFolderResponse>, RequestCanceler];
+    renameFolder: (payload: {
+        folderUuid: string;
+        name: string;
+    }) => Promise<void>;
+    getFolderMetadataByPath: (path: string) => Promise<DriveFolderItem>;
 }

package/dist/services/drive/drive-folder.service.js

@@ -52,5 +52,21 @@ class DriveFolderService {
             parentFolderId: payload.parentFolderId,
         });
     }
+    renameFolder = (payload) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        return storageClient.updateFolderNameWithUUID(payload);
+    };
+    getFolderMetadataByPath = async (path) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const folderMeta = await storageClient.getFolderByPath(encodeURIComponent(path));
+        return drive_utils_1.DriveUtils.driveFolderMetaToItem({
+            ...folderMeta,
+            createdAt: folderMeta.createdAt ?? folderMeta.created_at,
+            updatedAt: folderMeta.updatedAt ?? folderMeta.updated_at,
+            plainName: folderMeta.plainName ?? folderMeta.plain_name,
+            parentId: folderMeta.parentId ?? folderMeta.parent_id,
+            parentUuid: folderMeta.parentUuid ?? folderMeta.parent_uuid,
+        });
+    };
 }
 exports.DriveFolderService = DriveFolderService;

package/dist/services/drive/trash.service.d.ts

@@ -2,4 +2,11 @@ import { StorageTypes } from '@internxt/sdk/dist/drive';
 export declare class TrashService {
     static readonly instance: TrashService;
     trashItems: (payload: StorageTypes.AddItemsToTrashPayload) => Promise<void>;
+    clearTrash: () => Promise<void>;
+    getTrashFolderContent: () => Promise<{
+        folders: StorageTypes.FetchPaginatedFolder[];
+        files: StorageTypes.FetchPaginatedFile[];
+    }>;
+    private getAllTrashSubfolders;
+    private getAllTrashSubfiles;
 }

package/dist/services/drive/trash.service.js

@@ -8,5 +8,35 @@ class TrashService {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
         return storageClient.addItemsToTrash(payload);
     };
+    clearTrash = () => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getTrash();
+        return storageClient.clearTrash();
+    };
+    getTrashFolderContent = async () => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getTrash();
+        const folders = await this.getAllTrashSubfolders(storageClient, 0);
+        const files = await this.getAllTrashSubfiles(storageClient, 0);
+        return { folders, files };
+    };
+    getAllTrashSubfolders = async (storageClient, offset) => {
+        const folderContentPromise = storageClient.getTrashedFilesPaginated(50, offset, 'folders', true);
+        const { result: folders } = (await folderContentPromise);
+        if (folders.length > 0) {
+            return folders.concat(await this.getAllTrashSubfolders(storageClient, offset + folders.length));
+        }
+        else {
+            return folders;
+        }
+    };
+    getAllTrashSubfiles = async (storageClient, offset) => {
+        const folderContentPromise = storageClient.getTrashedFilesPaginated(50, offset, 'files', true);
+        const { result: folders } = (await folderContentPromise);
+        if (folders.length > 0) {
+            return folders.concat(await this.getAllTrashSubfiles(storageClient, offset + folders.length));
+        }
+        else {
+            return folders;
+        }
+    };
 }
 exports.TrashService = TrashService;

package/dist/services/network/upload.service.js

@@ -8,7 +8,11 @@ const node_fetch_1 = __importDefault(require("node-fetch"));
 class UploadService {
     static instance = new UploadService();
     async uploadFile(url, from, options) {
-        const response = await (0, node_fetch_1.default)(url, { method: 'PUT', body: from, signal: options.abortController?.signal });
+        const response = await (0, node_fetch_1.default)(url, {
+            method: 'PUT',
+            body: from,
+            signal: options.abortController?.signal,
+        });
         const etag = response.headers.get('etag');
         options.progressCallback(1);
         if (!etag) {

package/dist/services/sdk-manager.service.d.ts

@@ -1,4 +1,4 @@
-import { Auth, Drive, photos, Network as NetworkModule } from '@internxt/sdk';
+import { Auth, Drive, Network as NetworkModule } from '@internxt/sdk';
 import { ApiSecurity, AppDetails } from '@internxt/sdk/dist/shared';
 export type SdkManagerApiSecurity = ApiSecurity & {
     newToken: string;
@@ -19,7 +19,6 @@ export declare class SdkManager {
     getReferrals(): Drive.Referrals;
     getStorage(useNewApi?: boolean): Drive.Storage;
     getTrash(): Drive.Trash;
-    getPhotos(): photos.Photos;
     getShare(): Drive.Share;
     getNetwork(credentials: {
         user: string;

package/dist/services/sdk-manager.service.js

@@ -79,11 +79,6 @@ class SdkManager {
             token: newToken,
         });
     }
-    getPhotos() {
-        const PHOTOS_API_URL = config_service_1.ConfigService.instance.get('PHOTOS_API_URL');
-        const newToken = SdkManager.getApiSecurity().newToken;
-        return new sdk_1.photos.Photos(PHOTOS_API_URL, newToken);
-    }
     getShare() {
         const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const newToken = SdkManager.getApiSecurity().newToken;

package/dist/services/usage.service.d.ts

@@ -1,6 +1,7 @@
+import { UsageResponse } from '@internxt/sdk/dist/drive/storage/types';
 export declare class UsageService {
     static readonly instance: UsageService;
     static readonly INFINITE_LIMIT: number;
-    fetchTotalUsage: () => Promise<number>;
+    fetchUsage: () => Promise<UsageResponse>;
     fetchSpaceLimit: () => Promise<number>;
 }

package/dist/services/usage.service.js

@@ -5,14 +5,10 @@ const sdk_manager_service_1 = require("./sdk-manager.service");
 class UsageService {
     static instance = new UsageService();
     static INFINITE_LIMIT = 99 * Math.pow(1024, 4);
-    fetchTotalUsage = async () => {
+    fetchUsage = async () => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        const photosClient = sdk_manager_service_1.SdkManager.instance.getPhotos();
-        const [driveUsage, { usage: photosUsage }] = await Promise.all([
-            storageClient.spaceUsage(),
-            photosClient.photos.getUsage(),
-        ]);
-        return driveUsage.total + photosUsage;
+        const driveUsage = await storageClient.spaceUsage();
+        return driveUsage;
     };
     fetchSpaceLimit = async () => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();

package/dist/services/validation.service.d.ts

@@ -4,4 +4,6 @@ export declare class ValidationService {
     validate2FA: (code: string) => boolean;
     validateMnemonic: (mnemonic: string) => boolean;
     validateUUIDv4: (uuid: string) => boolean;
+    validateYesOrNoString: (message: string) => boolean;
+    validateTCPIntegerPort: (port: string) => boolean;
 }

package/dist/services/validation.service.js

@@ -17,5 +17,11 @@ class ValidationService {
     validateUUIDv4 = (uuid) => {
         return /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i.test(uuid);
     };
+    validateYesOrNoString = (message) => {
+        return message.length > 0 && /^(yes|no|y|n)$/i.test(message.toLowerCase().trim());
+    };
+    validateTCPIntegerPort = (port) => {
+        return /^\d+$/.test(port) && Number(port) >= 1 && Number(port) <= 65535;
+    };
 }
 exports.ValidationService = ValidationService;

package/dist/types/command.types.d.ts

@@ -8,6 +8,10 @@ export interface LoginCredentials {
 export interface CLICredentials extends LoginCredentials {
     root_folder_uuid: string;
 }
+export interface WebdavConfig {
+    port: string;
+    protocol: 'http' | 'https';
+}
 export declare class NotValidEmailError extends Error {
     constructor();
 }
@@ -20,6 +24,9 @@ export declare class NotValidTwoFactorCodeError extends Error {
 export declare class NotValidFolderUuidError extends Error {
     constructor();
 }
+export declare class NotValidFileUuidError extends Error {
+    constructor();
+}
 export declare class NotValidItemUuidError extends Error {
     constructor();
 }
@@ -32,6 +39,15 @@ export declare class NoRootFolderIdFoundError extends Error {
 export declare class MissingCredentialsError extends Error {
     constructor();
 }
+export declare class NotValidYesOrNoError extends Error {
+    constructor();
+}
+export declare class EmptyItemNameError extends Error {
+    constructor();
+}
+export declare class NotValidPortError extends Error {
+    constructor();
+}
 export type PaginatedItem = {
     plainName: string;
     uuid: string;

package/dist/types/command.types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MissingCredentialsError = exports.NoRootFolderIdFoundError = exports.ItemNotFoundError = exports.NotValidItemUuidError = exports.NotValidFolderUuidError = exports.NotValidTwoFactorCodeError = exports.EmptyPasswordError = exports.NotValidEmailError = void 0;
+exports.NotValidPortError = exports.EmptyItemNameError = exports.NotValidYesOrNoError = exports.MissingCredentialsError = exports.NoRootFolderIdFoundError = exports.ItemNotFoundError = exports.NotValidItemUuidError = exports.NotValidFileUuidError = exports.NotValidFolderUuidError = exports.NotValidTwoFactorCodeError = exports.EmptyPasswordError = exports.NotValidEmailError = void 0;
 class NotValidEmailError extends Error {
     constructor() {
         super('Email is not valid');
@@ -29,6 +29,13 @@ class NotValidFolderUuidError extends Error {
     }
 }
 exports.NotValidFolderUuidError = NotValidFolderUuidError;
+class NotValidFileUuidError extends Error {
+    constructor() {
+        super('File UUID is not valid (it must be a valid v4 UUID)');
+        Object.setPrototypeOf(this, NotValidFileUuidError.prototype);
+    }
+}
+exports.NotValidFileUuidError = NotValidFileUuidError;
 class NotValidItemUuidError extends Error {
     constructor() {
         super('Item UUID is not valid (it must be a valid v4 UUID)');
@@ -57,3 +64,24 @@ class MissingCredentialsError extends Error {
     }
 }
 exports.MissingCredentialsError = MissingCredentialsError;
+class NotValidYesOrNoError extends Error {
+    constructor() {
+        super('Only yes or not -> ["yes", "no", "y", "n"] options are valid');
+        Object.setPrototypeOf(this, NotValidYesOrNoError.prototype);
+    }
+}
+exports.NotValidYesOrNoError = NotValidYesOrNoError;
+class EmptyItemNameError extends Error {
+    constructor() {
+        super('Item name can not be empty');
+        Object.setPrototypeOf(this, EmptyPasswordError.prototype);
+    }
+}
+exports.EmptyItemNameError = EmptyItemNameError;
+class NotValidPortError extends Error {
+    constructor() {
+        super('Port should be a number between 1 and 65535');
+        Object.setPrototypeOf(this, NotValidPortError.prototype);
+    }
+}
+exports.NotValidPortError = NotValidPortError;

package/dist/types/config.types.d.ts

@@ -9,7 +9,6 @@ export interface ConfigKeys {
     readonly APP_MAGIC_IV: string;
     readonly APP_MAGIC_SALT: string;
     readonly NETWORK_URL: string;
-    readonly WEBDAV_SERVER_PORT: string;
     readonly RUDDERSTACK_WRITE_KEY: string;
     readonly RUDDERSTACK_DATAPLANE_URL: string;
 }

package/dist/types/drive.types.d.ts

@@ -1,5 +1,5 @@
 import { DriveFileData, DriveFolderData } from '@internxt/sdk/dist/drive/storage/types';
-export type DriveFileItem = Pick<DriveFileData, 'name' | 'bucket' | 'fileId' | 'id' | 'uuid' | 'folderId' | 'status'> & {
+export type DriveFileItem = Pick<DriveFileData, 'name' | 'bucket' | 'fileId' | 'id' | 'uuid' | 'folderId' | 'status' | 'folderUuid'> & {
     encryptedName: string;
     size: number;
     createdAt: Date;
@@ -12,4 +12,5 @@ export type DriveFolderItem = Pick<DriveFolderData, 'name' | 'bucket' | 'id' | '
     createdAt: Date;
     updatedAt: Date;
     status: 'EXISTS' | 'TRASHED';
+    parentUuid: string | null;
 };

package/dist/types/network.types.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 export interface NetworkCredentials {
     user: string;
     pass: string;
@@ -9,3 +10,7 @@ export interface NetworkOperationBaseOptions {
 }
 export type UploadOptions = NetworkOperationBaseOptions;
 export type DownloadOptions = NetworkOperationBaseOptions;
+export interface SelfsignedCert {
+    cert: string | Buffer;
+    key: string | Buffer;
+}

package/dist/types/webdav.types.d.ts

@@ -12,4 +12,5 @@ export type WebDavRequestedResource = {
     url: string;
     name: string;
     path: ParsedPath;
+    parentPath: string;
 };

package/dist/utils/cli.utils.d.ts

@@ -26,7 +26,7 @@ export declare class CLIUtils {
     static readonly prompt: (prompt: {
         message: string;
         options?: ux.IPromptOptions;
-        error: Error;
+        error?: Error;
     }, validate?: ((value: string) => boolean) | undefined) => Promise<string>;
     static readonly parseEmpty: (input: string) => Promise<string>;
 }

package/dist/utils/drive.utils.js

@@ -6,7 +6,8 @@ class DriveUtils {
         return {
             uuid: fileMeta.uuid ?? '',
             status: fileMeta.status,
-            folderId: fileMeta.folder_id,
+            folderId: fileMeta.folderId ?? fileMeta.folder_id,
+            folderUuid: fileMeta.folderUuid,
             size: fileMeta.size,
             encryptedName: fileMeta.name,
             name: fileMeta.plainName ?? fileMeta.name,
@@ -27,6 +28,7 @@ class DriveUtils {
             name: folderMeta.plainName ?? folderMeta.name,
             encryptedName: folderMeta.name,
             parentId: folderMeta.parentId,
+            parentUuid: folderMeta.parentUuid,
             createdAt: new Date(folderMeta.createdAt),
             updatedAt: new Date(folderMeta.updatedAt),
         };

package/dist/utils/network.utils.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" />
-import { NetworkCredentials } from '../types/network.types';
+import { NetworkCredentials, SelfsignedCert } from '../types/network.types';
 import selfsigned from 'selfsigned';
 export declare class NetworkUtils {
     static getAuthFromCredentials(creds: NetworkCredentials): {
@@ -10,13 +9,8 @@ export declare class NetworkUtils {
         cert: string;
         privateKey: string;
     };
-    static getWebdavSSLCerts(): {
-        cert: string;
-        key: string;
-    } | {
-        cert: Buffer;
-        key: Buffer;
-    };
+    static generateNewSelfsignedCerts(): SelfsignedCert;
+    static getWebdavSSLCerts(): SelfsignedCert;
     static saveWebdavSSLCerts(pems: selfsigned.GenerateResult): void;
     static generateSelfSignedSSLCerts(): selfsigned.GenerateResult;
 }

package/dist/utils/network.utils.js

@@ -20,20 +20,34 @@ class NetworkUtils {
         cert: node_path_1.default.join(config_service_1.ConfigService.WEBDAV_SSL_CERTS_DIR, 'cert.crt'),
         privateKey: node_path_1.default.join(config_service_1.ConfigService.WEBDAV_SSL_CERTS_DIR, 'priv.key'),
     };
+    static generateNewSelfsignedCerts() {
+        const newCerts = this.generateSelfSignedSSLCerts();
+        this.saveWebdavSSLCerts(newCerts);
+        return {
+            cert: newCerts.cert,
+            key: newCerts.private,
+        };
+    }
     static getWebdavSSLCerts() {
         if (!(0, node_fs_1.existsSync)(this.WEBDAV_SSL_CERTS_PATH.cert) || !(0, node_fs_1.existsSync)(this.WEBDAV_SSL_CERTS_PATH.privateKey)) {
-            const newCerts = this.generateSelfSignedSSLCerts();
-            this.saveWebdavSSLCerts(newCerts);
-            return {
-                cert: newCerts.cert,
-                key: newCerts.private,
-            };
+            return this.generateNewSelfsignedCerts();
         }
         else {
-            return {
+            let selfsignedCert = {
                 cert: (0, node_fs_1.readFileSync)(this.WEBDAV_SSL_CERTS_PATH.cert),
                 key: (0, node_fs_1.readFileSync)(this.WEBDAV_SSL_CERTS_PATH.privateKey),
             };
+            const { validTo } = new node_crypto_1.X509Certificate(selfsignedCert.cert);
+            const dateToday = new Date();
+            const dateValid = new Date(validTo);
+            if (dateToday > dateValid) {
+                const newCerts = this.generateNewSelfsignedCerts();
+                selfsignedCert = {
+                    cert: newCerts.cert,
+                    key: newCerts.key,
+                };
+            }
+            return selfsignedCert;
         }
     }
     static saveWebdavSSLCerts(pems) {

package/dist/utils/webdav.utils.d.ts

@@ -1,8 +1,22 @@
 import { Request } from 'express';
 import { WebDavRequestedResource } from '../types/webdav.types';
+import { DriveFile } from '../services/database/drive-file/drive-file.domain';
+import { DriveFolder } from '../services/database/drive-folder/drive-folder.domain';
 import { DriveDatabaseManager } from '../services/database/drive-database-manager.service';
+import { DriveFolderService } from '../services/drive/drive-folder.service';
+import { DriveFileService } from '../services/drive/drive-file.service';
+import { DriveFileItem, DriveFolderItem } from '../types/drive.types';
 export declare class WebDavUtils {
     static joinURL(...pathComponents: string[]): string;
-    static getParentPath(fromPath: string): string;
-    static getRequestedResource(req: Request, driveDatabaseManager: DriveDatabaseManager): Promise<WebDavRequestedResource>;
+    static removeHostFromURL(completeURL: string): string;
+    static getRequestedResource(urlObject: string | Request): Promise<WebDavRequestedResource>;
+    static getDatabaseItemFromResource(resource: WebDavRequestedResource, driveDatabaseManager: DriveDatabaseManager): Promise<DriveFileItem | DriveFolderItem | null>;
+    static setDatabaseItem(type: 'file' | 'folder', driveItem: DriveFileItem | DriveFolderItem, driveDatabaseManager: DriveDatabaseManager, relativePath: string): Promise<DriveFolder | DriveFile | undefined>;
+    static getDriveItemFromResource(resource: WebDavRequestedResource, driveFolderService?: DriveFolderService, driveFileService?: DriveFileService): Promise<DriveFileItem | DriveFolderItem | undefined>;
+    static getAndSearchItemFromResource({ resource, driveDatabaseManager, driveFolderService, driveFileService, }: {
+        resource: WebDavRequestedResource;
+        driveDatabaseManager: DriveDatabaseManager;
+        driveFolderService?: DriveFolderService;
+        driveFileService?: DriveFileService;
+    }): Promise<DriveFileItem | DriveFolderItem>;
 }