@internxt/cli 1.3.2 → 1.4.1

package/dist/commands/add-cert.d.ts

@@ -1,8 +1,15 @@
 import { Command } from '@oclif/core';
 export default class AddCert extends Command {
+    static readonly args: {};
     static readonly description = "Add a self-signed certificate to the trusted store for macOS, Linux, and Windows.";
-    static examples: string[];
-    run(): Promise<void>;
-    catch(error: Error): Promise<void>;
+    static readonly aliases: never[];
+    static readonly examples: string[];
+    static readonly flags: {};
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        message: string;
+    } | undefined>;
+    catch: (error: Error) => Promise<never>;
     private executeCommand;
 }

package/dist/commands/add-cert.js

@@ -1,66 +1,52 @@
 "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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const child_process_1 = require("child_process");
 const config_service_1 = require("../services/config.service");
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
 const cli_utils_1 = require("../utils/cli.utils");
 const errors_utils_1 = require("../utils/errors.utils");
 class AddCert extends core_1.Command {
+    static args = {};
     static description = 'Add a self-signed certificate to the trusted store for macOS, Linux, and Windows.';
+    static aliases = [];
     static examples = ['<%= config.bin %> <%= command.id %>'];
-    async run() {
+    static flags = {};
+    static enableJsonFlag = true;
+    run = async () => {
         try {
-            const certPath = path.join(config_service_1.ConfigService.WEBDAV_SSL_CERTS_DIR, 'cert.crt');
-            const platform = os.platform();
-            const scriptBasePath = path.join(__dirname, '../../scripts');
+            const certPath = node_path_1.default.join(config_service_1.ConfigService.WEBDAV_SSL_CERTS_DIR, 'cert.crt');
+            const platform = node_os_1.default.platform();
+            const scriptBasePath = node_path_1.default.join(__dirname, '../../scripts');
             let command = '';
             if (platform === 'win32') {
-                command = `powershell -ExecutionPolicy Bypass -File "${path.join(scriptBasePath, 'add-cert.ps1')}" -certPath "${certPath}"`;
+                command = `powershell -ExecutionPolicy Bypass -File "${node_path_1.default.join(scriptBasePath, 'add-cert.ps1')}" -certPath "${certPath}"`;
             }
             else if (platform === 'darwin' || platform === 'linux') {
-                command = `bash "${path.join(scriptBasePath, 'add-cert.sh')}" "${certPath}"`;
+                command = `bash "${node_path_1.default.join(scriptBasePath, 'add-cert.sh')}" "${certPath}"`;
             }
             else {
                 throw new Error(`Unsupported OS: ${platform}`);
             }
             await this.executeCommand(command);
-            cli_utils_1.CLIUtils.success('Certificate successfully added to the trusted store.');
+            const message = 'Certificate successfully added to the trusted store.';
+            cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+            return { success: true, message };
         }
         catch (error) {
             await this.catch(error);
         }
-    }
-    async catch(error) {
-        errors_utils_1.ErrorUtils.report(error, { command: this.id });
-        cli_utils_1.CLIUtils.error(error.message);
+    };
+    catch = async (error) => {
+        errors_utils_1.ErrorUtils.report(this.error.bind(this), error, { command: this.id });
+        cli_utils_1.CLIUtils.error(this.log.bind(this), error.message);
         this.exit(1);
-    }
-    executeCommand(command) {
+    };
+    executeCommand = (command) => {
         return new Promise((resolve, reject) => {
             (0, child_process_1.exec)(command, (error, stdout, stderr) => {
                 if (error) {
@@ -73,6 +59,6 @@ class AddCert extends core_1.Command {
                 }
             });
         });
-    }
+    };
 }
 exports.default = AddCert;

package/dist/commands/config.d.ts

@@ -2,17 +2,20 @@ import { Command } from '@oclif/core';
 export default class Config extends Command {
     static readonly args: {};
     static readonly description = "Display useful information from the user logged into the Internxt CLI.";
+    static readonly aliases: never[];
     static readonly examples: string[];
-    static readonly flags: {
-        columns: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
-        csv: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        extended: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        filter: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
-        'no-header': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        'no-truncate': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
-        sort: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
-    };
-    catch(error: Error): Promise<void>;
-    run(): Promise<void>;
+    static readonly flags: {};
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        config: {
+            [k: string]: string;
+        };
+        message?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        config?: undefined;
+    }>;
+    catch: (error: Error) => Promise<never>;
 }

package/dist/commands/config.js

@@ -9,42 +9,38 @@ const format_utils_1 = require("../utils/format.utils");
 class Config extends core_1.Command {
     static args = {};
     static description = 'Display useful information from the user logged into the Internxt CLI.';
+    static aliases = [];
     static examples = ['<%= config.bin %> <%= command.id %>'];
-    static flags = {
-        ...core_1.ux.table.flags(),
-    };
-    async catch(error) {
-        errors_utils_1.ErrorUtils.report(error, { command: this.id });
-        cli_utils_1.CLIUtils.error(error.message);
-        this.exit(1);
-    }
-    async run() {
-        const { flags } = await this.parse(Config);
+    static flags = {};
+    static enableJsonFlag = true;
+    run = async () => {
         const userCredentials = await config_service_1.ConfigService.instance.readUser();
         if (userCredentials?.user) {
+            const usedSpace = format_utils_1.FormatUtils.humanFileSize((await usage_service_1.UsageService.instance.fetchUsage()).total);
+            const availableSpace = format_utils_1.FormatUtils.formatLimit(await usage_service_1.UsageService.instance.fetchSpaceLimit());
             const configList = [
                 { key: 'Email', value: userCredentials.user.email },
-                { key: 'Root folder ID', value: userCredentials.root_folder_uuid },
-                { key: 'Used space', value: format_utils_1.FormatUtils.humanFileSize((await usage_service_1.UsageService.instance.fetchUsage()).total) },
-                { key: 'Available space', value: format_utils_1.FormatUtils.formatLimit(await usage_service_1.UsageService.instance.fetchSpaceLimit()) },
+                { key: 'Root folder ID', value: userCredentials.user.rootFolderId },
+                { key: 'Used space', value: usedSpace },
+                { key: 'Available space', value: availableSpace },
+            ];
+            const header = [
+                { value: 'key', alias: 'Key' },
+                { value: 'value', alias: 'Value' },
             ];
-            core_1.ux.table(configList, {
-                key: {
-                    header: 'Key',
-                    get: (row) => row.key,
-                },
-                value: {
-                    header: 'Value',
-                    get: (row) => row.value,
-                },
-            }, {
-                printLine: this.log.bind(this),
-                ...flags,
-            });
+            cli_utils_1.CLIUtils.table(this.log.bind(this), header, configList);
+            return { success: true, config: Object.fromEntries(configList.map(({ key, value }) => [key, value])) };
         }
         else {
-            cli_utils_1.CLIUtils.error('You are not logged in');
+            const message = 'You are not logged in.';
+            cli_utils_1.CLIUtils.error(this.log.bind(this), message);
+            return { success: false, message };
         }
-    }
+    };
+    catch = async (error) => {
+        errors_utils_1.ErrorUtils.report(this.error.bind(this), error, { command: this.id });
+        cli_utils_1.CLIUtils.error(this.log.bind(this), error.message);
+        this.exit(1);
+    };
 }
 exports.default = Config;

package/dist/commands/create-folder.d.ts

@@ -1,13 +1,21 @@
 import { Command } from '@oclif/core';
-import { DriveFolderItem } from '../types/drive.types';
 export default class CreateFolder extends Command {
-    static description: string;
-    static examples: string[];
-    static flags: {
-        name: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    static readonly args: {};
+    static readonly description = "Create a folder in your Internxt Drive";
+    static readonly aliases: never[];
+    static readonly examples: string[];
+    static readonly flags: {
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
-    catch(error: Error): Promise<void>;
-    getParentFolder(uuid: string): Promise<DriveFolderItem>;
-    run(): Promise<void>;
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        message: string;
+        folder: import("@internxt/sdk/dist/drive/storage/types").CreateFolderResponse;
+    }>;
+    catch: (error: Error) => Promise<never>;
+    private getFolderName;
+    private getFolderUuid;
 }

package/dist/commands/create-folder.js

@@ -1,44 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
-const auth_service_1 = require("../services/auth.service");
 const errors_utils_1 = require("../utils/errors.utils");
 const cli_utils_1 = require("../utils/cli.utils");
 const drive_folder_service_1 = require("../services/drive/drive-folder.service");
 const config_service_1 = require("../services/config.service");
+const validation_service_1 = require("../services/validation.service");
+const command_types_1 = require("../types/command.types");
 class CreateFolder extends core_1.Command {
+    static args = {};
     static description = 'Create a folder in your Internxt Drive';
+    static aliases = [];
     static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
-        name: core_1.Flags.string({ description: 'The new folder name', required: true }),
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        name: core_1.Flags.string({
+            char: 'n',
+            description: 'The new name for the folder',
+            required: false,
+        }),
         id: core_1.Flags.string({
-            description: 'The folder id to create the folder in, defaults to your root folder',
+            char: 'i',
+            description: 'The ID of the folder where the new folder will be created. Defaults to your root folder if not specified.',
             required: false,
+            parse: cli_utils_1.CLIUtils.parseEmpty,
         }),
     };
-    async catch(error) {
-        errors_utils_1.ErrorUtils.report(error, { command: this.id });
-        cli_utils_1.CLIUtils.error(error.message);
-        this.exit(1);
-    }
-    getParentFolder(uuid) {
-        return drive_folder_service_1.DriveFolderService.instance.getFolderMetaByUuid(uuid);
-    }
-    async run() {
+    static enableJsonFlag = true;
+    run = async () => {
         const { flags } = await this.parse(CreateFolder);
-        const folderName = flags.name;
-        const user = await auth_service_1.AuthService.instance.getUser();
-        let parentFolder;
-        if (flags.id) {
-            parentFolder = await this.getParentFolder(flags.id);
-            if (!parentFolder) {
-                throw new Error(`Folder with id ${flags.id} not found`);
-            }
+        const nonInteractive = flags['non-interactive'];
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        const folderName = await this.getFolderName(flags['name'], nonInteractive);
+        let folderUuid = await this.getFolderUuid(flags['id'], nonInteractive);
+        if (folderUuid.trim().length === 0) {
+            folderUuid = userCredentials.user.rootFolderId;
         }
         cli_utils_1.CLIUtils.doing('Creating folder...');
         const [createNewFolder, requestCanceler] = drive_folder_service_1.DriveFolderService.instance.createFolder({
-            folderName,
-            parentFolderId: parentFolder ? parentFolder.id : user.root_folder_id,
+            plainName: folderName,
+            parentFolderUuid: folderUuid,
         });
         process.on('SIGINT', () => {
             requestCanceler.cancel('SIGINT received');
@@ -46,7 +49,47 @@ class CreateFolder extends core_1.Command {
         });
         const newFolder = await createNewFolder;
         cli_utils_1.CLIUtils.done();
-        cli_utils_1.CLIUtils.success(`Folder ${newFolder.plainName} created successfully, view it at view it at ${config_service_1.ConfigService.instance.get('DRIVE_URL')}/folder/${newFolder.uuid}`);
-    }
+        const message = `Folder ${newFolder.plainName} created successfully, view it at ${config_service_1.ConfigService.instance.get('DRIVE_URL')}/folder/${newFolder.uuid}`;
+        cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+        return { success: true, message, folder: newFolder };
+    };
+    catch = async (error) => {
+        errors_utils_1.ErrorUtils.report(this.error.bind(this), error, { command: this.id });
+        cli_utils_1.CLIUtils.error(this.log.bind(this), error.message);
+        this.exit(1);
+    };
+    getFolderName = async (folderNameFlag, nonInteractive) => {
+        const folderName = await cli_utils_1.CLIUtils.getValueFromFlag({
+            value: folderNameFlag,
+            name: CreateFolder.flags['name'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What would you like to name the new folder?',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateStringIsNotEmpty,
+            error: new command_types_1.EmptyFolderNameError(),
+        }, this.log.bind(this));
+        return folderName;
+    };
+    getFolderUuid = async (folderUuidFlag, nonInteractive) => {
+        const folderUuid = await cli_utils_1.CLIUtils.getValueFromFlag({
+            value: folderUuidFlag,
+            name: CreateFolder.flags['id'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the ID of the folder where you would like to create the new folder? (leave empty for the root folder)',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
+            error: new command_types_1.NotValidFolderUuidError(),
+            canBeEmpty: true,
+        }, this.log.bind(this));
+        return folderUuid;
+    };
 }
 exports.default = CreateFolder;

package/dist/commands/delete-permanently-file.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class DeletePermanentlyFile extends Command {
+    static readonly args: {};
+    static readonly description = "Deletes permanently a file. This action cannot be undone.";
+    static readonly aliases: string[];
+    static readonly examples: string[];
+    static readonly flags: {
+        id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    catch: (error: Error) => Promise<never>;
+    private getFileUuid;
+}

package/dist/commands/delete-permanently-file.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const config_service_1 = require("../services/config.service");
+const cli_utils_1 = require("../utils/cli.utils");
+const command_types_1 = require("../types/command.types");
+const validation_service_1 = require("../services/validation.service");
+const drive_file_service_1 = require("../services/drive/drive-file.service");
+const errors_utils_1 = require("../utils/errors.utils");
+const trash_service_1 = require("../services/drive/trash.service");
+class DeletePermanentlyFile extends core_1.Command {
+    static args = {};
+    static description = 'Deletes permanently a file. This action cannot be undone.';
+    static aliases = ['delete:permanently:file'];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        id: core_1.Flags.string({
+            char: 'i',
+            description: 'The file id to be permanently deleted.',
+            required: false,
+        }),
+    };
+    static enableJsonFlag = true;
+    run = async () => {
+        const { flags } = await this.parse(DeletePermanentlyFile);
+        const nonInteractive = flags['non-interactive'];
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        const fileUuid = await this.getFileUuid(flags['id'], nonInteractive);
+        const driveFile = await drive_file_service_1.DriveFileService.instance.getFileMetadata(fileUuid);
+        if (!driveFile) {
+            throw new Error('File not found');
+        }
+        await trash_service_1.TrashService.instance.deleteFile({ fileId: driveFile.id, folderId: driveFile.folderId });
+        const message = 'File permanently deleted successfully';
+        cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+        return { success: true, message };
+    };
+    catch = async (error) => {
+        errors_utils_1.ErrorUtils.report(this.error.bind(this), error, { command: this.id });
+        cli_utils_1.CLIUtils.error(this.log.bind(this), error.message);
+        this.exit(1);
+    };
+    getFileUuid = async (fileUuidFlag, nonInteractive) => {
+        const fileUuid = await cli_utils_1.CLIUtils.getValueFromFlag({
+            value: fileUuidFlag,
+            name: DeletePermanentlyFile.flags['id'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the file id you want to permanently delete? (This action cannot be undone)',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
+            error: new command_types_1.NotValidFileUuidError(),
+        }, this.log.bind(this));
+        return fileUuid;
+    };
+}
+exports.default = DeletePermanentlyFile;

package/dist/commands/delete-permanently-folder.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class DeletePermanentlyFolder extends Command {
+    static readonly args: {};
+    static readonly description = "Deletes permanently a folder. This action cannot be undone.";
+    static readonly aliases: string[];
+    static readonly examples: string[];
+    static readonly flags: {
+        id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    catch: (error: Error) => Promise<never>;
+    private getFolderUuid;
+}

package/dist/commands/delete-permanently-folder.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const config_service_1 = require("../services/config.service");
+const cli_utils_1 = require("../utils/cli.utils");
+const command_types_1 = require("../types/command.types");
+const validation_service_1 = require("../services/validation.service");
+const errors_utils_1 = require("../utils/errors.utils");
+const trash_service_1 = require("../services/drive/trash.service");
+const drive_folder_service_1 = require("../services/drive/drive-folder.service");
+class DeletePermanentlyFolder extends core_1.Command {
+    static args = {};
+    static description = 'Deletes permanently a folder. This action cannot be undone.';
+    static aliases = ['delete:permanently:folder'];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        id: core_1.Flags.string({
+            char: 'i',
+            description: 'The folder id to be permanently deleted.',
+            required: false,
+        }),
+    };
+    static enableJsonFlag = true;
+    run = async () => {
+        const { flags } = await this.parse(DeletePermanentlyFolder);
+        const nonInteractive = flags['non-interactive'];
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        const folderUuid = await this.getFolderUuid(flags['id'], nonInteractive);
+        const driveFolder = await drive_folder_service_1.DriveFolderService.instance.getFolderMetaByUuid(folderUuid);
+        if (!driveFolder) {
+            throw new Error('Folder not found');
+        }
+        await trash_service_1.TrashService.instance.deleteFolder(driveFolder.id);
+        const message = 'Folder permanently deleted successfully';
+        cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+        return { success: true, message };
+    };
+    catch = async (error) => {
+        errors_utils_1.ErrorUtils.report(this.error.bind(this), error, { command: this.id });
+        cli_utils_1.CLIUtils.error(this.log.bind(this), error.message);
+        this.exit(1);
+    };
+    getFolderUuid = async (folderUuidFlag, nonInteractive) => {
+        const folderUuid = await cli_utils_1.CLIUtils.getValueFromFlag({
+            value: folderUuidFlag,
+            name: DeletePermanentlyFolder.flags['id'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the folder id you want to permanently delete? (This action cannot be undone)',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
+            error: new command_types_1.NotValidFolderUuidError(),
+        }, this.log.bind(this));
+        return folderUuid;
+    };
+}
+exports.default = DeletePermanentlyFolder;

package/dist/commands/download-file.d.ts

@@ -0,0 +1,26 @@
+import { Command } from '@oclif/core';
+import { DriveFileItem } from '../types/drive.types';
+export default class DownloadFile extends Command {
+    static readonly args: {};
+    static readonly description = "Download and decrypts a file from Internxt Drive to a directory. The file name will be the same as the file name in your Drive.";
+    static readonly aliases: string[];
+    static readonly examples: string[];
+    static readonly flags: {
+        id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        directory: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        overwrite: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        message: string;
+        file: DriveFileItem;
+    }>;
+    catch: (error: Error) => Promise<never>;
+    private getFileUuid;
+    private getDirectory;
+    private getFileMetadata;
+    private getDownloadPath;
+    private prepareNetwork;
+}