@internxt/cli 1.5.8 → 1.6.1

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadFacade = void 0;
+const node_path_1 = require("node:path");
+const cli_utils_1 = require("../../../utils/cli.utils");
+const logger_utils_1 = require("../../../utils/logger.utils");
+const local_filesystem_service_1 = require("../../local-filesystem/local-filesystem.service");
+const upload_folder_service_1 = require("./upload-folder.service");
+const upload_file_service_1 = require("./upload-file.service");
+const async_utils_1 = require("../../../utils/async.utils");
+class UploadFacade {
+    static instance = new UploadFacade();
+    async uploadFolder({ localPath, destinationFolderUuid, loginUserDetails, jsonFlag, onProgress }) {
+        const timer = cli_utils_1.CLIUtils.timer();
+        const network = cli_utils_1.CLIUtils.prepareNetwork({ jsonFlag, loginUserDetails });
+        const scanResult = await local_filesystem_service_1.LocalFilesystemService.instance.scanLocalDirectory(localPath);
+        logger_utils_1.logger.info(`Scanned folder ${localPath}: found ${scanResult.totalItems} items, total size ${scanResult.totalBytes} bytes.`);
+        const currentProgress = { itemsUploaded: 0, bytesUploaded: 0 };
+        const emitProgress = () => {
+            const itemProgress = currentProgress.itemsUploaded / scanResult.totalItems;
+            const sizeProgress = currentProgress.bytesUploaded / scanResult.totalBytes;
+            const percentage = Math.floor((itemProgress * 0.5 + sizeProgress * 0.5) * 100);
+            onProgress({ percentage });
+        };
+        const folderMap = await upload_folder_service_1.UploadFolderService.instance.createFolders({
+            foldersToCreate: scanResult.folders,
+            destinationFolderUuid,
+            currentProgress,
+            emitProgress,
+        });
+        if (folderMap.size === 0) {
+            throw new Error('Failed to create folders, cannot upload files');
+        }
+        await async_utils_1.AsyncUtils.sleep(500);
+        const totalBytes = await upload_file_service_1.UploadFileService.instance.uploadFilesInChunks({
+            network,
+            filesToUpload: scanResult.files,
+            folderMap,
+            bucket: loginUserDetails.bucket,
+            destinationFolderUuid,
+            currentProgress,
+            emitProgress,
+        });
+        const rootFolderName = (0, node_path_1.basename)(localPath);
+        const rootFolderId = folderMap.get(rootFolderName) ?? '';
+        return {
+            totalBytes,
+            rootFolderId,
+            uploadTimeMs: timer.stop(),
+        };
+    }
+}
+exports.UploadFacade = UploadFacade;

package/dist/services/network/upload/upload-file.service.d.ts

@@ -0,0 +1,7 @@
+import { UploadFilesInBatchesParams, UploadFileWithRetryParams } from './upload.types';
+export declare class UploadFileService {
+    static readonly instance: UploadFileService;
+    uploadFilesInChunks({ network, filesToUpload, folderMap, bucket, destinationFolderUuid, currentProgress, emitProgress, }: UploadFilesInBatchesParams): Promise<number>;
+    uploadFileWithRetry({ file, network, bucket, parentFolderUuid, }: UploadFileWithRetryParams): Promise<string | null>;
+    private chunkArray;
+}

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadFileService = void 0;
+const logger_utils_1 = require("../../../utils/logger.utils");
+const upload_types_1 = require("./upload.types");
+const drive_file_service_1 = require("../../drive/drive-file.service");
+const node_path_1 = require("node:path");
+const errors_utils_1 = require("../../../utils/errors.utils");
+const promises_1 = require("node:fs/promises");
+const types_1 = require("@internxt/sdk/dist/drive/storage/types");
+const thumbnail_utils_1 = require("../../../utils/thumbnail.utils");
+class UploadFileService {
+    static instance = new UploadFileService();
+    async uploadFilesInChunks({ network, filesToUpload, folderMap, bucket, destinationFolderUuid, currentProgress, emitProgress, }) {
+        let bytesUploaded = 0;
+        const chunks = this.chunkArray(filesToUpload, upload_types_1.MAX_CONCURRENT_UPLOADS);
+        for (const chunk of chunks) {
+            await Promise.allSettled(chunk.map(async (file) => {
+                const parentPath = (0, node_path_1.dirname)(file.relativePath);
+                const parentFolderUuid = parentPath === '.' || parentPath === '' ? destinationFolderUuid : folderMap.get(parentPath);
+                if (!parentFolderUuid) {
+                    logger_utils_1.logger.warn(`Parent folder not found for ${file.relativePath}, skipping...`);
+                    return null;
+                }
+                const createdFileUuid = await this.uploadFileWithRetry({
+                    file,
+                    network,
+                    bucket,
+                    parentFolderUuid,
+                });
+                if (createdFileUuid) {
+                    bytesUploaded += file.size;
+                    currentProgress.bytesUploaded += file.size;
+                    currentProgress.itemsUploaded++;
+                }
+                emitProgress();
+            }));
+        }
+        return bytesUploaded;
+    }
+    async uploadFileWithRetry({ file, network, bucket, parentFolderUuid, }) {
+        for (let attempt = 0; attempt <= upload_types_1.MAX_RETRIES; attempt++) {
+            try {
+                const stats = await (0, promises_1.stat)(file.absolutePath);
+                if (!stats.size) {
+                    logger_utils_1.logger.warn(`Skipping empty file: ${file.relativePath}`);
+                    return null;
+                }
+                const fileType = (0, node_path_1.extname)(file.absolutePath).replaceAll('.', '');
+                const { fileStream, bufferStream } = (0, thumbnail_utils_1.createFileStreamWithBuffer)({
+                    path: file.absolutePath,
+                    fileType,
+                });
+                const fileId = await new Promise((resolve, reject) => {
+                    network.uploadFile(fileStream, stats.size, bucket, (err, res) => {
+                        if (err) {
+                            return reject(err);
+                        }
+                        resolve(res);
+                    }, () => { });
+                });
+                const createdDriveFile = await drive_file_service_1.DriveFileService.instance.createFile({
+                    plainName: file.name,
+                    type: fileType,
+                    size: stats.size,
+                    folderUuid: parentFolderUuid,
+                    fileId,
+                    bucket,
+                    encryptVersion: types_1.EncryptionVersion.Aes03,
+                    creationTime: stats.birthtime?.toISOString(),
+                    modificationTime: stats.mtime?.toISOString(),
+                });
+                if (bufferStream) {
+                    void (0, thumbnail_utils_1.tryUploadThumbnail)({
+                        bufferStream,
+                        fileType,
+                        userBucket: bucket,
+                        fileUuid: createdDriveFile.uuid,
+                        networkFacade: network,
+                    });
+                }
+                return createdDriveFile.fileId;
+            }
+            catch (error) {
+                if ((0, errors_utils_1.isAlreadyExistsError)(error)) {
+                    const msg = `File ${file.name} already exists, skipping...`;
+                    logger_utils_1.logger.info(msg);
+                    return null;
+                }
+                if (attempt < upload_types_1.MAX_RETRIES) {
+                    const delay = upload_types_1.DELAYS_MS[attempt];
+                    const retryMsg = `Failed to upload file ${file.name}, retrying in ${delay}ms...`;
+                    logger_utils_1.logger.warn(`${retryMsg} (attempt ${attempt + 1}/${upload_types_1.MAX_RETRIES + 1})`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+                else {
+                    logger_utils_1.logger.error(`Failed to upload file ${file.name} after ${upload_types_1.MAX_RETRIES + 1} attempts`);
+                    return null;
+                }
+            }
+        }
+        return null;
+    }
+    chunkArray(array, chunkSize) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += chunkSize) {
+            chunks.push(array.slice(i, i + chunkSize));
+        }
+        return chunks;
+    }
+}
+exports.UploadFileService = UploadFileService;

package/dist/services/network/upload/upload-folder.service.d.ts

@@ -0,0 +1,6 @@
+import { CreateFoldersParams, CreateFolderWithRetryParams } from './upload.types';
+export declare class UploadFolderService {
+    static readonly instance: UploadFolderService;
+    createFolders({ foldersToCreate, destinationFolderUuid, currentProgress, emitProgress, }: CreateFoldersParams): Promise<Map<string, string>>;
+    createFolderWithRetry({ folderName, parentFolderUuid }: CreateFolderWithRetryParams): Promise<string | null>;
+}

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadFolderService = void 0;
+const node_path_1 = require("node:path");
+const errors_utils_1 = require("../../../utils/errors.utils");
+const logger_utils_1 = require("../../../utils/logger.utils");
+const drive_folder_service_1 = require("../../drive/drive-folder.service");
+const upload_types_1 = require("./upload.types");
+class UploadFolderService {
+    static instance = new UploadFolderService();
+    async createFolders({ foldersToCreate, destinationFolderUuid, currentProgress, emitProgress, }) {
+        const folderMap = new Map();
+        for (const folder of foldersToCreate) {
+            const parentPath = (0, node_path_1.dirname)(folder.relativePath);
+            const parentUuid = parentPath === '.' ? destinationFolderUuid : folderMap.get(parentPath);
+            if (!parentUuid) {
+                logger_utils_1.logger.warn(`Parent folder not found for ${folder.relativePath}, skipping...`);
+                continue;
+            }
+            const createdFolderUuid = await this.createFolderWithRetry({
+                folderName: folder.name,
+                parentFolderUuid: parentUuid,
+            });
+            if (createdFolderUuid) {
+                folderMap.set(folder.relativePath, createdFolderUuid);
+                currentProgress.itemsUploaded++;
+                emitProgress();
+            }
+        }
+        return folderMap;
+    }
+    async createFolderWithRetry({ folderName, parentFolderUuid }) {
+        for (let attempt = 0; attempt <= upload_types_1.MAX_RETRIES; attempt++) {
+            try {
+                const [createFolderPromise] = drive_folder_service_1.DriveFolderService.instance.createFolder({
+                    plainName: folderName,
+                    parentFolderUuid,
+                });
+                const createdFolder = await createFolderPromise;
+                return createdFolder.uuid;
+            }
+            catch (error) {
+                if ((0, errors_utils_1.isAlreadyExistsError)(error)) {
+                    logger_utils_1.logger.info(`Folder ${folderName} already exists, skipping...`);
+                    return null;
+                }
+                if (attempt < upload_types_1.MAX_RETRIES) {
+                    const delay = upload_types_1.DELAYS_MS[attempt];
+                    logger_utils_1.logger.warn(`Failed to create folder ${folderName},
+                retrying in ${delay}ms... (attempt ${attempt + 1}/${upload_types_1.MAX_RETRIES + 1})`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+                else {
+                    logger_utils_1.logger.error(`Failed to create folder ${folderName} after ${upload_types_1.MAX_RETRIES + 1} attempts`);
+                    throw error;
+                }
+            }
+        }
+        return null;
+    }
+}
+exports.UploadFolderService = UploadFolderService;

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

@@ -0,0 +1,53 @@
+import { LoginUserDetails } from '../../../types/command.types';
+import { FileSystemNode } from '../../local-filesystem/local-filesystem.types';
+import { NetworkFacade } from '../network-facade.service';
+export interface UploadResult {
+    totalBytes: number;
+    rootFolderId: string;
+    uploadTimeMs: number;
+}
+export interface UploadFolderParams {
+    localPath: string;
+    destinationFolderUuid: string;
+    loginUserDetails: LoginUserDetails;
+    jsonFlag?: boolean;
+    onProgress: (progress: UploadProgress) => void;
+}
+export interface UploadProgress {
+    percentage: number;
+    currentFile?: string;
+}
+export interface CreateFoldersParams {
+    foldersToCreate: FileSystemNode[];
+    destinationFolderUuid: string;
+    currentProgress: {
+        itemsUploaded: number;
+        bytesUploaded: number;
+    };
+    emitProgress: () => void;
+}
+export interface CreateFolderWithRetryParams {
+    folderName: string;
+    parentFolderUuid: string;
+}
+export interface UploadFilesInBatchesParams {
+    network: NetworkFacade;
+    filesToUpload: FileSystemNode[];
+    folderMap: Map<string, string>;
+    bucket: string;
+    destinationFolderUuid: string;
+    currentProgress: {
+        itemsUploaded: number;
+        bytesUploaded: number;
+    };
+    emitProgress: () => void;
+}
+export interface UploadFileWithRetryParams {
+    file: FileSystemNode;
+    network: NetworkFacade;
+    bucket: string;
+    parentFolderUuid: string;
+}
+export declare const MAX_CONCURRENT_UPLOADS = 5;
+export declare const DELAYS_MS: number[];
+export declare const MAX_RETRIES = 2;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_RETRIES = exports.DELAYS_MS = exports.MAX_CONCURRENT_UPLOADS = void 0;
+exports.MAX_CONCURRENT_UPLOADS = 5;
+exports.DELAYS_MS = [500, 1000, 2000];
+exports.MAX_RETRIES = 2;

package/dist/services/thumbnail.service.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThumbnailService = void 0;
 const node_stream_1 = require("node:stream");
@@ -42,7 +9,7 @@ let sharpDependency = null;
 const getSharp = async () => {
     if (!sharpDependency) {
         try {
-            sharpDependency = (await Promise.resolve().then(() => __importStar(require('sharp')))).default;
+            sharpDependency = (await import('sharp')).default;
         }
         catch {
             return null;

package/dist/services/universal-link.service.d.ts

@@ -0,0 +1,10 @@
+import { LoginCredentials } from '../types/command.types';
+export declare class UniversalLinkService {
+    static readonly instance: UniversalLinkService;
+    getUserCredentials: (userSession: {
+        mnemonic: string;
+        token: string;
+    }) => Promise<LoginCredentials>;
+    buildLoginUrl: (redirectUri: string) => string;
+    loginSSO: (jsonFlag: boolean, reporter: (message: string) => void, hostIp?: string, forcedPort?: number) => Promise<LoginCredentials>;
+}

package/dist/services/universal-link.service.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniversalLinkService = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+const open_1 = __importDefault(require("open"));
+const config_service_1 = require("./config.service");
+const auth_service_1 = require("./auth.service");
+const cli_utils_1 = require("../utils/cli.utils");
+class UniversalLinkService {
+    static instance = new UniversalLinkService();
+    getUserCredentials = async (userSession) => {
+        const clearMnemonic = Buffer.from(userSession.mnemonic, 'base64').toString('utf-8');
+        const clearToken = Buffer.from(userSession.token, 'base64').toString('utf-8');
+        const loginCredentials = await auth_service_1.AuthService.instance.refreshUserToken(clearToken, clearMnemonic);
+        return {
+            user: {
+                ...loginCredentials.user,
+                mnemonic: clearMnemonic,
+            },
+            token: clearToken,
+        };
+    };
+    buildLoginUrl = (redirectUri) => {
+        const loginURL = `${config_service_1.ConfigService.instance.get('DRIVE_WEB_URL')}/login`;
+        const params = new URLSearchParams({
+            universalLink: 'true',
+            redirectUri: redirectUri,
+        });
+        return `${loginURL}?${params.toString()}`;
+    };
+    loginSSO = async (jsonFlag, reporter, hostIp = '127.0.0.1', forcedPort = 0) => {
+        return new Promise((resolve, reject) => {
+            const server = node_http_1.default.createServer(async (req, res) => {
+                if (!req.url)
+                    return;
+                const parsedUrl = new URL(req.url, `http://${req.headers.host}`);
+                const driveUrl = config_service_1.ConfigService.instance.get('DRIVE_WEB_URL');
+                try {
+                    const mnemonic = parsedUrl.searchParams.get('mnemonic');
+                    const token = parsedUrl.searchParams.get('newToken');
+                    if (!mnemonic || !token) {
+                        throw new Error('Login has failed, please try again');
+                    }
+                    const loginCredentials = await this.getUserCredentials({ mnemonic, token });
+                    res.writeHead(302, {
+                        Location: `${driveUrl}/auth-link-ok`,
+                    });
+                    res.end();
+                    resolve(loginCredentials);
+                }
+                catch (error) {
+                    res.writeHead(302, {
+                        Location: `${driveUrl}/auth-link-error`,
+                    });
+                    res.end();
+                    reject(error);
+                }
+                finally {
+                    server.closeAllConnections();
+                    server.close();
+                }
+            });
+            server.listen(forcedPort, async () => {
+                const { port } = server.address();
+                const redirectUri = Buffer.from(`http://${hostIp}:${port}/callback`).toString('base64');
+                const loginUrl = this.buildLoginUrl(redirectUri);
+                cli_utils_1.CLIUtils.log(reporter, 'Opening browser for login...');
+                cli_utils_1.CLIUtils.log(reporter, 'If the browser doesn’t open automatically, visit:');
+                const printLoginUrl = jsonFlag ? `{ "loginUrl": "${loginUrl}" }` : loginUrl;
+                cli_utils_1.CLIUtils.consoleLog(printLoginUrl);
+                try {
+                    await (0, open_1.default)(loginUrl);
+                }
+                catch {
+                    cli_utils_1.CLIUtils.warning(reporter, 'Could not open browser automatically.');
+                }
+                cli_utils_1.CLIUtils.log(reporter, 'Waiting for authentication...');
+            });
+        });
+    };
+}
+exports.UniversalLinkService = UniversalLinkService;

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

@@ -26,8 +26,6 @@ export interface LoginUserDetails {
 export interface LoginCredentials {
     user: LoginUserDetails;
     token: string;
-    lastLoggedInAt: string;
-    lastTokenRefreshAt: string;
 }
 export interface WebdavConfig {
     host: string;
@@ -51,6 +49,9 @@ export declare class NotValidFolderUuidError extends Error {
 export declare class NotValidFileUuidError extends Error {
     constructor();
 }
+export declare class NotValidFileIdError extends Error {
+    constructor();
+}
 export declare class NoRootFolderIdFoundError extends Error {
     constructor();
 }

package/dist/types/command.types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotValidFileError = exports.NotValidDirectoryError = exports.NotValidPortError = exports.EmptyFolderNameError = exports.EmptyFileNameError = exports.InvalidCredentialsError = exports.ExpiredCredentialsError = exports.MissingCredentialsError = exports.NoRootFolderIdFoundError = exports.NotValidFileUuidError = exports.NotValidFolderUuidError = exports.NotValidTwoFactorCodeError = exports.EmptyPasswordError = exports.NotValidEmailError = void 0;
+exports.NotValidFileError = exports.NotValidDirectoryError = exports.NotValidPortError = exports.EmptyFolderNameError = exports.EmptyFileNameError = exports.InvalidCredentialsError = exports.ExpiredCredentialsError = exports.MissingCredentialsError = exports.NoRootFolderIdFoundError = exports.NotValidFileIdError = exports.NotValidFileUuidError = exports.NotValidFolderUuidError = exports.NotValidTwoFactorCodeError = exports.EmptyPasswordError = exports.NotValidEmailError = void 0;
 class NotValidEmailError extends Error {
     constructor() {
         super('Email is not valid');
@@ -36,6 +36,13 @@ class NotValidFileUuidError extends Error {
     }
 }
 exports.NotValidFileUuidError = NotValidFileUuidError;
+class NotValidFileIdError extends Error {
+    constructor() {
+        super('FileId is not valid');
+        Object.setPrototypeOf(this, NotValidFileIdError.prototype);
+    }
+}
+exports.NotValidFileIdError = NotValidFileIdError;
 class NoRootFolderIdFoundError extends Error {
     constructor() {
         super('No root folder id found on your account');

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

@@ -1,5 +1,6 @@
 import { DriveFolderData, FileMeta } from '@internxt/sdk/dist/drive/storage/types';
 export type DriveFileItem = Omit<FileMeta, 'plainName' | 'userId' | 'encryptVersion' | 'size' | 'createdAt' | 'updatedAt' | 'creationTime' | 'modificationTime' | 'type'> & {
+    itemType: 'file';
     size: number;
     createdAt: Date;
     updatedAt: Date;
@@ -8,6 +9,7 @@ export type DriveFileItem = Omit<FileMeta, 'plainName' | 'userId' | 'encryptVers
     type?: string | null;
 };
 export type DriveFolderItem = Pick<DriveFolderData, 'name' | 'bucket' | 'id' | 'parentId'> & {
+    itemType: 'folder';
     encryptedName: string;
     uuid: string;
     createdAt: Date;

package/dist/types/fast-xml-parser.types.d.ts

@@ -0,0 +1,59 @@
+type strnumOptions = {
+    hex: boolean;
+    leadingZeros: boolean;
+    skipLike?: RegExp;
+    eNotation?: boolean;
+};
+export type X2jOptions = {
+    preserveOrder?: boolean;
+    attributeNamePrefix?: string;
+    attributesGroupName?: false | string;
+    textNodeName?: string;
+    ignoreAttributes?: boolean | (string | RegExp)[] | ((attrName: string, jPath: string) => boolean);
+    removeNSPrefix?: boolean;
+    allowBooleanAttributes?: boolean;
+    parseTagValue?: boolean;
+    parseAttributeValue?: boolean;
+    trimValues?: boolean;
+    cdataPropName?: false | string;
+    commentPropName?: false | string;
+    tagValueProcessor?: (tagName: string, tagValue: string, jPath: string, hasAttributes: boolean, isLeafNode: boolean) => unknown;
+    attributeValueProcessor?: (attrName: string, attrValue: string, jPath: string) => unknown;
+    numberParseOptions?: strnumOptions;
+    stopNodes?: string[];
+    unpairedTags?: string[];
+    alwaysCreateTextNode?: boolean;
+    isArray?: (tagName: string, jPath: string, isLeafNode: boolean, isAttribute: boolean) => boolean;
+    processEntities?: boolean;
+    htmlEntities?: boolean;
+    ignoreDeclaration?: boolean;
+    ignorePiTags?: boolean;
+    transformTagName?: ((tagName: string) => string) | false;
+    transformAttributeName?: ((attributeName: string) => string) | false;
+    updateTag?: (tagName: string, jPath: string, attrs: {
+        [k: string]: string;
+    }) => string | boolean;
+    captureMetaData?: boolean;
+};
+export type XmlBuilderOptions = {
+    attributeNamePrefix?: string;
+    attributesGroupName?: false | string;
+    textNodeName?: string;
+    ignoreAttributes?: boolean | (string | RegExp)[] | ((attrName: string, jPath: string) => boolean);
+    cdataPropName?: false | string;
+    commentPropName?: false | string;
+    format?: boolean;
+    indentBy?: string;
+    arrayNodeName?: string;
+    suppressEmptyNode?: boolean;
+    suppressUnpairedNode?: boolean;
+    suppressBooleanAttributes?: boolean;
+    preserveOrder?: boolean;
+    unpairedTags?: string[];
+    stopNodes?: string[];
+    tagValueProcessor?: (name: string, value: unknown) => unknown;
+    attributeValueProcessor?: (name: string, value: unknown) => unknown;
+    processEntities?: boolean;
+    oneListGroup?: boolean;
+};
+export {};

package/dist/types/fast-xml-parser.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -7,7 +7,6 @@ export type WebDavMethodHandlerOptions = {
     debug: boolean;
 };
 export type WebDavRequestedResource = {
-    type: 'file' | 'folder';
     url: string;
     name: string;
     path: ParsedPath;

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

@@ -1,6 +1,7 @@
 import cliProgress from 'cli-progress';
 import { Header } from 'tty-table';
-import { PromptOptions } from '../types/command.types';
+import { LoginUserDetails, PromptOptions } from '../types/command.types';
+import { NetworkFacade } from '../services/network/network-facade.service';
 export declare class CLIUtils {
     static readonly clearPreviousLine: (jsonFlag?: boolean) => void;
     static readonly warning: (reporter: (message: string) => void, message: string) => void;
@@ -15,7 +16,7 @@ export declare class CLIUtils {
     static readonly table: (reporter: (message: string) => void, header: Header[], rows: object[]) => void;
     static readonly generateTableHeaderFromType: <T extends object>() => Header[];
     static readonly CommonFlags: {
-        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static readonly getValueFromFlag: (flag: {
         value?: string;
@@ -32,6 +33,12 @@ export declare class CLIUtils {
         error: Error;
         canBeEmpty?: boolean;
     }, reporter: (message: string) => void) => Promise<string>;
+    static readonly getDestinationFolderUuid: ({ destinationFolderUuidFlag, destinationFlagName, nonInteractive, reporter, }: {
+        destinationFolderUuidFlag: string | undefined;
+        destinationFlagName: string;
+        nonInteractive: boolean;
+        reporter: (message: string) => void;
+    }) => Promise<string | undefined>;
     private static readonly promptWithAttempts;
     static readonly timer: () => {
         stop: () => number;
@@ -43,6 +50,10 @@ export declare class CLIUtils {
         jsonFlag?: boolean;
     }) => void;
     static readonly parseEmpty: (input: string) => Promise<string>;
+    static readonly prepareNetwork: ({ jsonFlag, loginUserDetails, }: {
+        jsonFlag?: boolean;
+        loginUserDetails: LoginUserDetails;
+    }) => NetworkFacade;
 }
 export declare class NoFlagProvidedError extends Error {
     constructor(flag: string);