@internxt/cli 1.6.1 → 1.6.3

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

@@ -1,7 +1,25 @@
+import { Readable } from 'node:stream';
 import { StorageTypes } from '@internxt/sdk/dist/drive';
 import { NetworkFacade } from './network/network-facade.service';
+import { BufferStream } from '../utils/stream.utils';
 export declare class ThumbnailService {
     static readonly instance: ThumbnailService;
-    uploadThumbnail: (fileContent: Buffer, fileType: string, userBucket: string, file_id: string, networkFacade: NetworkFacade) => Promise<StorageTypes.Thumbnail | undefined>;
+    private static readonly MAX_THUMBNAIL_TIMEOUT;
+    uploadThumbnail: (fileContent: Buffer, fileType: string, userBucket: string, file_id: string, networkFacade: NetworkFacade, fileSize: number) => Promise<StorageTypes.Thumbnail | undefined>;
     private readonly getThumbnailFromImageBuffer;
+    tryUploadThumbnail: ({ bufferStream, fileType, bucket, fileUuid, networkFacade, size, }: {
+        bufferStream?: BufferStream;
+        fileType: string;
+        bucket: string;
+        fileUuid: string;
+        networkFacade: NetworkFacade;
+        size: number;
+    }) => Promise<void>;
+    createFileStreamWithBuffer: ({ path, fileType, }: {
+        path: string;
+        fileType: string;
+    }) => {
+        bufferStream?: BufferStream;
+        fileStream: Readable;
+    };
 }

package/dist/services/thumbnail.service.js

@@ -2,9 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThumbnailService = void 0;
 const node_stream_1 = require("node:stream");
+const node_fs_1 = require("node:fs");
 const drive_file_service_1 = require("./drive/drive-file.service");
 const drive_1 = require("@internxt/sdk/dist/drive");
 const thumbnail_utils_1 = require("../utils/thumbnail.utils");
+const stream_utils_1 = require("../utils/stream.utils");
+const errors_utils_1 = require("../utils/errors.utils");
+const async_utils_1 = require("../utils/async.utils");
 let sharpDependency = null;
 const getSharp = async () => {
     if (!sharpDependency) {
@@ -19,9 +23,10 @@ const getSharp = async () => {
 };
 class ThumbnailService {
     static instance = new ThumbnailService();
-    uploadThumbnail = async (fileContent, fileType, userBucket, file_id, networkFacade) => {
+    static MAX_THUMBNAIL_TIMEOUT = 30000;
+    uploadThumbnail = async (fileContent, fileType, userBucket, file_id, networkFacade, fileSize) => {
         let thumbnailBuffer;
-        if ((0, thumbnail_utils_1.isImageThumbnailable)(fileType)) {
+        if (thumbnail_utils_1.ThumbnailUtils.isImageThumbnailable(fileType, fileSize)) {
             thumbnailBuffer = await this.getThumbnailFromImageBuffer(fileContent);
         }
         if (thumbnailBuffer) {
@@ -62,5 +67,27 @@ class ThumbnailService {
                 .toBuffer();
         }
     };
+    tryUploadThumbnail = async ({ bufferStream, fileType, bucket, fileUuid, networkFacade, size, }) => {
+        try {
+            const thumbnailBuffer = bufferStream?.getBuffer();
+            if (thumbnailBuffer) {
+                await async_utils_1.AsyncUtils.withTimeout(ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, bucket, fileUuid, networkFacade, size), ThumbnailService.MAX_THUMBNAIL_TIMEOUT, 'Thumbnail upload timeout');
+            }
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error);
+        }
+    };
+    createFileStreamWithBuffer = ({ path, fileType, }) => {
+        const readable = (0, node_fs_1.createReadStream)(path);
+        if (thumbnail_utils_1.ThumbnailUtils.isFileThumbnailable(fileType)) {
+            const bufferStream = new stream_utils_1.BufferStream();
+            return {
+                bufferStream,
+                fileStream: readable.pipe(bufferStream),
+            };
+        }
+        return { fileStream: readable };
+    };
 }
 exports.ThumbnailService = ThumbnailService;

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

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

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

@@ -14,11 +14,22 @@ class 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);
+        const clearPrivateKey = Buffer.from(userSession.privateKey, 'base64').toString('utf-8');
+        const loginCredentials = await auth_service_1.AuthService.instance.refreshUserToken(clearToken, clearMnemonic, clearPrivateKey);
         return {
             user: {
                 ...loginCredentials.user,
                 mnemonic: clearMnemonic,
+                keys: {
+                    ecc: {
+                        privateKey: clearPrivateKey,
+                        publicKey: loginCredentials.user.keys.ecc.publicKey,
+                    },
+                    kyber: {
+                        privateKey: loginCredentials.user.keys.kyber.privateKey,
+                        publicKey: loginCredentials.user.keys.kyber.publicKey,
+                    },
+                },
             },
             token: clearToken,
         };
@@ -41,10 +52,11 @@ class UniversalLinkService {
                 try {
                     const mnemonic = parsedUrl.searchParams.get('mnemonic');
                     const token = parsedUrl.searchParams.get('newToken');
-                    if (!mnemonic || !token) {
+                    const privateKey = parsedUrl.searchParams.get('privateKey');
+                    if (!mnemonic || !token || !privateKey) {
                         throw new Error('Login has failed, please try again');
                     }
-                    const loginCredentials = await this.getUserCredentials({ mnemonic, token });
+                    const loginCredentials = await this.getUserCredentials({ mnemonic, token, privateKey });
                     res.writeHead(302, {
                         Location: `${driveUrl}/auth-link-ok`,
                     });

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

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

package/dist/services/usage.service.js

@@ -8,7 +8,7 @@ class UsageService {
     fetchUsage = async () => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const driveUsage = await storageClient.spaceUsageV2();
-        return driveUsage;
+        return driveUsage.total;
     };
     fetchSpaceLimit = async () => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();

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

@@ -9,6 +9,11 @@ export declare class ValidationService {
     validateStringIsNotEmpty: (str: string) => boolean;
     validateDirectoryExists: (path: string) => Promise<boolean>;
     validateFileExists: (path: string) => Promise<boolean>;
+    validateJwtAndCheckExpiration: (token?: string) => number | null;
+    checkTokenExpiration: (expirationTimestamp: number) => {
+        expired: boolean;
+        refreshRequired: boolean;
+    };
     validateTokenAndCheckExpiration: (token?: string) => {
         isValid: boolean;
         expiration: {

package/dist/services/validation.service.js

@@ -31,36 +31,50 @@ class ValidationService {
         return str.trim().length > 0;
     };
     validateDirectoryExists = async (path) => {
-        const directoryStat = await promises_1.default.stat(path);
-        return directoryStat.isDirectory();
+        try {
+            const directoryStat = await promises_1.default.stat(path);
+            return directoryStat.isDirectory();
+        }
+        catch {
+            return false;
+        }
     };
     validateFileExists = async (path) => {
-        const fileStat = await promises_1.default.stat(path);
-        return fileStat.isFile();
-    };
-    validateTokenAndCheckExpiration = (token) => {
-        if (!token || typeof token !== 'string') {
-            return { isValid: false, expiration: { expired: true, refreshRequired: false } };
+        try {
+            const fileStat = await promises_1.default.stat(path);
+            return fileStat.isFile();
         }
-        const parts = token.split('.');
-        if (parts.length !== 3) {
-            return { isValid: false, expiration: { expired: true, refreshRequired: false } };
+        catch {
+            return false;
+        }
+    };
+    validateJwtAndCheckExpiration = (token) => {
+        if (!token || typeof token !== 'string' || token.split('.').length !== 3) {
+            return null;
         }
         try {
-            const payload = JSON.parse(atob(parts[1]));
-            if (typeof payload.exp !== 'number') {
-                return { isValid: false, expiration: { expired: true, refreshRequired: false } };
-            }
-            const currentTime = Math.floor(Date.now() / 1000);
-            const twoDaysInSeconds = 2 * 24 * 60 * 60;
-            const remainingSeconds = payload.exp - currentTime;
-            const expired = remainingSeconds <= 0;
-            const refreshRequired = remainingSeconds > 0 && remainingSeconds <= twoDaysInSeconds;
-            return { isValid: true, expiration: { expired, refreshRequired } };
+            const payload = JSON.parse(atob(token.split('.')[1]));
+            return typeof payload.exp === 'number' ? payload.exp : null;
         }
         catch {
-            return { isValid: false, expiration: { expired: true, refreshRequired: false } };
+            return null;
         }
     };
+    checkTokenExpiration = (expirationTimestamp) => {
+        const TWO_DAYS_IN_SECONDS = 2 * 24 * 60 * 60;
+        const currentTime = Math.floor(Date.now() / 1000);
+        const remainingSeconds = expirationTimestamp - currentTime;
+        return {
+            expired: remainingSeconds <= 0,
+            refreshRequired: remainingSeconds > 0 && remainingSeconds <= TWO_DAYS_IN_SECONDS,
+        };
+    };
+    validateTokenAndCheckExpiration = (token) => {
+        const expiration = this.validateJwtAndCheckExpiration(token);
+        return {
+            isValid: expiration !== null,
+            expiration: expiration ? this.checkTokenExpiration(expiration) : { expired: true, refreshRequired: false },
+        };
+    };
 }
 exports.ValidationService = ValidationService;

package/dist/{webdav/services → services/webdav}/webdav-folder.service.d.ts

@@ -1,12 +1,6 @@
-import { ConfigService } from '../../services/config.service';
-import { DriveFolderService } from '../../services/drive/drive-folder.service';
 import { DriveFolderItem } from '../../types/drive.types';
 export declare class WebDavFolderService {
-    private readonly dependencies;
-    constructor(dependencies: {
-        driveFolderService: DriveFolderService;
-        configService: ConfigService;
-    });
+    static readonly instance: WebDavFolderService;
     getDriveFolderItemFromPath: (path: string) => Promise<DriveFolderItem | undefined>;
     createFolder: ({ folderName, parentFolderUuid, }: {
         folderName: string;

package/dist/{webdav/services → services/webdav}/webdav-folder.service.js

@@ -1,25 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebDavFolderService = void 0;
+const config_service_1 = require("../../services/config.service");
+const drive_folder_service_1 = require("../../services/drive/drive-folder.service");
 const errors_utils_1 = require("../../utils/errors.utils");
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const async_utils_1 = require("../../utils/async.utils");
 const auth_service_1 = require("../../services/auth.service");
 const drive_utils_1 = require("../../utils/drive.utils");
 class WebDavFolderService {
-    dependencies;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
+    static instance = new WebDavFolderService();
     getDriveFolderItemFromPath = async (path) => {
         const { url } = await webdav_utils_1.WebDavUtils.getRequestedResource(path, false);
-        return await webdav_utils_1.WebDavUtils.getDriveFolderFromResource({
-            url,
-            driveFolderService: this.dependencies.driveFolderService,
-        });
+        return await webdav_utils_1.WebDavUtils.getDriveFolderFromResource(url);
     };
     createFolder = async ({ folderName, parentFolderUuid, }) => {
-        const [createFolderPromise] = this.dependencies.driveFolderService.createFolder({
+        const [createFolderPromise] = await drive_folder_service_1.DriveFolderService.instance.createFolder({
             plainName: folderName,
             parentFolderUuid: parentFolderUuid,
         });
@@ -28,7 +24,7 @@ class WebDavFolderService {
         return drive_utils_1.DriveUtils.createFolderResponseToItem(newFolder);
     };
     createParentPathOrThrow = async (parentPath) => {
-        const { createFullPath } = await this.dependencies.configService.readWebdavConfig();
+        const { createFullPath } = await config_service_1.ConfigService.instance.readWebdavConfig();
         if (!createFullPath) {
             throw new errors_utils_1.ConflictError(`Parent folders not found on Internxt Drive at ${webdav_utils_1.WebDavUtils.decodeUrl(parentPath, false)},
         createFullPath flag is set to: ${createFullPath}`);

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

@@ -1,3 +1,5 @@
+import { WorkspaceData } from '@internxt/sdk/dist/workspaces';
+import { NetworkCredentials } from './network.types';
 export interface LoginUserDetails {
     userId: string;
     uuid: string;
@@ -23,9 +25,21 @@ export interface LoginUserDetails {
     avatar: string | null;
     emailVerified: boolean;
 }
+export interface WorkspaceCredentialsDetails {
+    id: string;
+    bucket: string;
+    workspaceUserId: string;
+    credentials: NetworkCredentials;
+    token: string;
+}
+export interface Workspace {
+    workspaceData: WorkspaceData;
+    workspaceCredentials: WorkspaceCredentialsDetails;
+}
 export interface LoginCredentials {
     user: LoginUserDetails;
     token: string;
+    workspace?: Workspace;
 }
 export interface WebdavConfig {
     host: string;
@@ -33,6 +47,10 @@ export interface WebdavConfig {
     protocol: 'http' | 'https';
     timeoutMinutes: number;
     createFullPath: boolean;
+    customAuth: boolean;
+    username: string;
+    password: string;
+    deleteFilesPermanently: boolean;
 }
 export declare class NotValidEmailError extends Error {
     constructor();
@@ -70,6 +88,12 @@ export declare class EmptyFileNameError extends Error {
 export declare class EmptyFolderNameError extends Error {
     constructor();
 }
+export declare class EmptyCustomAuthUsernameError extends Error {
+    constructor();
+}
+export declare class EmptyCustomAuthPasswordError extends Error {
+    constructor();
+}
 export declare class NotValidPortError extends Error {
     constructor();
 }
@@ -79,6 +103,12 @@ export declare class NotValidDirectoryError extends Error {
 export declare class NotValidFileError extends Error {
     constructor();
 }
+export declare class NotValidWorkspaceUuidError extends Error {
+    constructor();
+}
+export declare class MissingCredentialsWhenUsingAuthError extends Error {
+    constructor();
+}
 export interface PaginatedItem {
     name: string;
     type: string;
@@ -87,8 +117,21 @@ export interface PaginatedItem {
     modified: string;
 }
 export interface PromptOptions {
-    type: 'input' | 'password' | 'mask' | 'confirm';
+    type: 'input' | 'password' | 'mask' | 'confirm' | 'list';
     confirm?: {
         default: boolean;
     };
+    choices?: {
+        values: string[];
+        default?: number;
+    };
+}
+export interface PaginatedWorkspace {
+    name: string;
+    id: string;
+    usedSpace: string;
+    availableSpace: string;
+    owner: string;
+    address: string;
+    created: string;
 }

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.NotValidFileIdError = exports.NotValidFileUuidError = exports.NotValidFolderUuidError = exports.NotValidTwoFactorCodeError = exports.EmptyPasswordError = exports.NotValidEmailError = void 0;
+exports.MissingCredentialsWhenUsingAuthError = exports.NotValidWorkspaceUuidError = exports.NotValidFileError = exports.NotValidDirectoryError = exports.NotValidPortError = exports.EmptyCustomAuthPasswordError = exports.EmptyCustomAuthUsernameError = 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');
@@ -85,6 +85,20 @@ class EmptyFolderNameError extends Error {
     }
 }
 exports.EmptyFolderNameError = EmptyFolderNameError;
+class EmptyCustomAuthUsernameError extends Error {
+    constructor() {
+        super('Custom auth username can not be empty');
+        Object.setPrototypeOf(this, EmptyCustomAuthUsernameError.prototype);
+    }
+}
+exports.EmptyCustomAuthUsernameError = EmptyCustomAuthUsernameError;
+class EmptyCustomAuthPasswordError extends Error {
+    constructor() {
+        super('Custom auth password can not be empty');
+        Object.setPrototypeOf(this, EmptyCustomAuthPasswordError.prototype);
+    }
+}
+exports.EmptyCustomAuthPasswordError = EmptyCustomAuthPasswordError;
 class NotValidPortError extends Error {
     constructor() {
         super('Port should be a number between 1 and 65535');
@@ -106,3 +120,17 @@ class NotValidFileError extends Error {
     }
 }
 exports.NotValidFileError = NotValidFileError;
+class NotValidWorkspaceUuidError extends Error {
+    constructor() {
+        super('Workspace UUID is not valid (it must be a valid v4 UUID)');
+        Object.setPrototypeOf(this, NotValidWorkspaceUuidError.prototype);
+    }
+}
+exports.NotValidWorkspaceUuidError = NotValidWorkspaceUuidError;
+class MissingCredentialsWhenUsingAuthError extends Error {
+    constructor() {
+        super('When using custom WebDAV authentication, both username and password must be provided');
+        Object.setPrototypeOf(this, MissingCredentialsWhenUsingAuthError.prototype);
+    }
+}
+exports.MissingCredentialsWhenUsingAuthError = MissingCredentialsWhenUsingAuthError;

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

@@ -1,4 +1,5 @@
 export interface ConfigKeys {
+    readonly NODE_ENV: string;
     readonly DRIVE_WEB_URL: string;
     readonly DRIVE_NEW_API_URL: string;
     readonly APP_CRYPTO_SECRET: string;

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

@@ -1,19 +1,20 @@
-import { DriveFolderData, FileMeta } from '@internxt/sdk/dist/drive/storage/types';
-export type DriveFileItem = Omit<FileMeta, 'plainName' | 'userId' | 'encryptVersion' | 'size' | 'createdAt' | 'updatedAt' | 'creationTime' | 'modificationTime' | 'type'> & {
+import { FileMeta, FolderMeta } from '@internxt/sdk/dist/drive/storage/types';
+export type DriveFileItem = Pick<FileMeta, 'uuid' | 'name' | 'bucket' | 'folderUuid' | 'status'> & {
     itemType: 'file';
     size: number;
     createdAt: Date;
     updatedAt: Date;
     creationTime: Date;
     modificationTime: Date;
-    type?: string | null;
+    type: string | null;
+    fileId: string | null;
 };
-export type DriveFolderItem = Pick<DriveFolderData, 'name' | 'bucket' | 'id' | 'parentId'> & {
+export type DriveFolderItem = Pick<FolderMeta, 'uuid' | 'name' | 'bucket'> & {
     itemType: 'folder';
-    encryptedName: string;
-    uuid: string;
     createdAt: Date;
     updatedAt: Date;
+    creationTime: Date;
+    modificationTime: Date;
     status: 'EXISTS' | 'TRASHED';
     parentUuid: string | null;
 };

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

@@ -1,7 +1,13 @@
+import { NetworkFacade } from '../services/network/network-facade.service';
 export interface NetworkCredentials {
     user: string;
     pass: string;
 }
+export interface NetworkOptions {
+    networkFacade: NetworkFacade;
+    bucket: string;
+    mnemonic: string;
+}
 export type DownloadProgressCallback = (downloadedBytes: number) => void;
 export type UploadProgressCallback = (uploadedBytes: number) => void;
 export interface NetworkOperationBaseOptions {

package/dist/utils/async.utils.d.ts

@@ -1,3 +1,4 @@
 export declare class AsyncUtils {
-    static sleep(ms: number): Promise<void>;
+    static readonly sleep: (ms: number) => Promise<void>;
+    static readonly withTimeout: <T>(promise: Promise<T>, timeoutMs: number, errorMessage?: string) => Promise<T>;
 }

package/dist/utils/async.utils.js

@@ -2,8 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncUtils = void 0;
 class AsyncUtils {
-    static sleep(ms) {
+    static sleep = (ms) => {
         return new Promise((resolve) => setTimeout(resolve, ms));
-    }
+    };
+    static withTimeout = async (promise, timeoutMs, errorMessage = 'Operation timed out') => {
+        let timeoutId;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+                reject(new Error(errorMessage));
+            }, timeoutMs);
+        });
+        return Promise.race([promise, timeoutPromise]).finally(() => {
+            clearTimeout(timeoutId);
+        });
+    };
 }
 exports.AsyncUtils = AsyncUtils;

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

@@ -1,22 +1,24 @@
 import cliProgress from 'cli-progress';
 import { Header } from 'tty-table';
-import { LoginUserDetails, PromptOptions } from '../types/command.types';
-import { NetworkFacade } from '../services/network/network-facade.service';
+import { LoginCredentials, LoginUserDetails, PromptOptions } from '../types/command.types';
+import { NetworkCredentials, NetworkOptions } from '../types/network.types';
+export type LogReporter = (message: string) => void;
 export declare class CLIUtils {
     static readonly clearPreviousLine: (jsonFlag?: boolean) => void;
-    static readonly warning: (reporter: (message: string) => void, message: string) => void;
-    static readonly error: (reporter: (message: string) => void, message: string) => void;
-    static readonly success: (reporter: (message: string) => void, message: string) => void;
-    static readonly log: (reporter: (message: string) => void, message: string) => void;
+    static readonly warning: (reporter: LogReporter, message: string) => void;
+    static readonly error: (reporter: LogReporter, message: string) => void;
+    static readonly success: (reporter: LogReporter, message: string) => void;
+    static readonly log: (reporter: LogReporter, message: string) => void;
     static readonly consoleLog: (message: string) => void;
     static readonly doing: (message: string, jsonFlag?: boolean) => void;
     static readonly done: (jsonFlag?: boolean) => void;
     static readonly failed: (jsonFlag?: boolean) => void;
     static readonly progress: (opts: cliProgress.Options, jsonFlag?: boolean) => cliProgress.SingleBar | undefined;
-    static readonly table: (reporter: (message: string) => void, header: Header[], rows: object[]) => void;
+    static readonly table: (reporter: LogReporter, header: Header[], rows: object[]) => void;
     static readonly generateTableHeaderFromType: <T extends object>() => Header[];
     static readonly CommonFlags: {
         'non-interactive': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static readonly getValueFromFlag: (flag: {
         value?: string;
@@ -32,28 +34,34 @@ export declare class CLIUtils {
         validate: (value: string) => Promise<boolean> | boolean;
         error: Error;
         canBeEmpty?: boolean;
-    }, reporter: (message: string) => void) => Promise<string>;
+    }, reporter: LogReporter) => Promise<string>;
     static readonly getDestinationFolderUuid: ({ destinationFolderUuidFlag, destinationFlagName, nonInteractive, reporter, }: {
         destinationFolderUuidFlag: string | undefined;
         destinationFlagName: string;
         nonInteractive: boolean;
-        reporter: (message: string) => void;
-    }) => Promise<string | undefined>;
+        reporter: LogReporter;
+    }) => Promise<string>;
     private static readonly promptWithAttempts;
     static readonly timer: () => {
         stop: () => number;
     };
+    static readonly formatDuration: (milliseconds: number) => string;
+    static readonly formatBytesToString: (bytes: number) => string;
+    static readonly calculateThroughputMBps: (bytes: number, milliseconds: number) => number;
     static readonly catchError: ({ error, logReporter, command, jsonFlag, }: {
         error: Error;
         command?: string;
-        logReporter: (message: string) => void;
+        logReporter: LogReporter;
         jsonFlag?: boolean;
     }) => void;
     static readonly parseEmpty: (input: string) => Promise<string>;
-    static readonly prepareNetwork: ({ jsonFlag, loginUserDetails, }: {
-        jsonFlag?: boolean;
-        loginUserDetails: LoginUserDetails;
-    }) => NetworkFacade;
+    static readonly prepareNetwork: (loginUserDetails: LoginUserDetails) => Promise<NetworkOptions>;
+    static readonly fallbackToRootFolderIdIfEmpty: (folderId: string) => Promise<string>;
+    static readonly getNetworkCreds: (userCredentials: LoginCredentials["user"]) => Promise<{
+        bucket: string;
+        credentials: NetworkCredentials;
+        mnemonic: string;
+    }>;
 }
 export declare class NoFlagProvidedError extends Error {
     constructor(flag: string);