@internxt/cli 1.3.3 → 1.4.2

package/dist/commands/trash-file.js

@@ -0,0 +1,58 @@
+"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");
+class TrashFile extends core_1.Command {
+    static args = {};
+    static description = 'Moves a given file to the trash.';
+    static aliases = ['trash: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 trashed.',
+            required: false,
+        }),
+    };
+    static enableJsonFlag = true;
+    run = async () => {
+        const { flags } = await this.parse(TrashFile);
+        const nonInteractive = flags['non-interactive'];
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        const uuid = await this.getFileUuid(flags['id'], nonInteractive);
+        await trash_service_1.TrashService.instance.trashItems({ items: [{ uuid, type: 'file' }] });
+        const message = 'File trashed successfully.';
+        cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+        return { success: true, message, file: { uuid } };
+    };
+    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: TrashFile.flags['id'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the file id you want to trash?',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
+            error: new command_types_1.NotValidFileUuidError(),
+        }, this.log.bind(this));
+        return fileUuid;
+    };
+}
+exports.default = TrashFile;

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

@@ -0,0 +1,21 @@
+import { Command } from '@oclif/core';
+export default class TrashFolder extends Command {
+    static readonly args: {};
+    static readonly description = "Moves a given folder to the trash.";
+    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;
+        folder: {
+            uuid: string;
+        };
+    }>;
+    catch: (error: Error) => Promise<never>;
+    private getFolderUuid;
+}

package/dist/commands/trash-folder.js

@@ -0,0 +1,58 @@
+"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");
+class TrashFolder extends core_1.Command {
+    static args = {};
+    static description = 'Moves a given folder to the trash.';
+    static aliases = ['trash: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 trashed.',
+            required: false,
+        }),
+    };
+    static enableJsonFlag = true;
+    run = async () => {
+        const { flags } = await this.parse(TrashFolder);
+        const nonInteractive = flags['non-interactive'];
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        const uuid = await this.getFolderUuid(flags['id'], nonInteractive);
+        await trash_service_1.TrashService.instance.trashItems({ items: [{ uuid, type: 'folder' }] });
+        const message = 'Folder trashed successfully.';
+        cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+        return { success: true, message, folder: { uuid } };
+    };
+    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: TrashFolder.flags['id'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the folder id you want to trash?',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
+            error: new command_types_1.NotValidFolderUuidError(),
+        }, this.log.bind(this));
+        return folderUuid;
+    };
+}
+exports.default = TrashFolder;

package/dist/commands/trash-list.d.ts

@@ -2,19 +2,18 @@ import { Command } from '@oclif/core';
 export default class TrashList extends Command {
     static readonly args: {};
     static readonly description = "Lists the content of the trash.";
-    static readonly examples: string[];
     static readonly aliases: string[];
+    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>;
-        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
-    catch(error: Error): Promise<void>;
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        list: {
+            folders: import("@internxt/sdk/dist/drive/storage/types").FetchPaginatedFolder[];
+            files: import("@internxt/sdk/dist/drive/storage/types").FetchPaginatedFile[];
+        };
+    }>;
+    catch: (error: Error) => Promise<never>;
 }

package/dist/commands/trash-list.js

@@ -10,13 +10,17 @@ const trash_service_1 = require("../services/drive/trash.service");
 class TrashList extends core_1.Command {
     static args = {};
     static description = 'Lists the content of the trash.';
-    static examples = ['<%= config.bin %> <%= command.id %>'];
     static aliases = ['trash:list'];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
-        ...cli_utils_1.CLIUtils.CommonFlags,
-        ...core_1.ux.table.flags(),
+        extended: core_1.Flags.boolean({
+            char: 'e',
+            description: 'Displays additional information in the trash list.',
+            required: false,
+        }),
     };
-    async run() {
+    static enableJsonFlag = true;
+    run = async () => {
         const { flags } = await this.parse(TrashList);
         const userCredentials = await config_service_1.ConfigService.instance.readUser();
         if (!userCredentials)
@@ -25,71 +29,38 @@ class TrashList extends core_1.Command {
         const allItems = [
             ...folders.map((folder) => {
                 return {
-                    isFolder: true,
-                    plainName: folder.plainName,
-                    uuid: folder.uuid,
-                    type: '',
-                    size: BigInt(0),
-                    updatedAt: folder.updatedAt,
+                    type: 'folder',
+                    name: folder.plainName,
+                    id: folder.uuid,
+                    size: '-',
+                    modified: format_utils_1.FormatUtils.formatDate(folder.updatedAt),
                 };
             }),
             ...files.map((file) => {
                 return {
-                    isFolder: false,
-                    plainName: file.plainName,
-                    uuid: file.uuid,
-                    type: file.type,
-                    size: file.size,
-                    updatedAt: file.updatedAt,
+                    type: 'file',
+                    name: file.type && file.type.length > 0 ? `${file.plainName}.${file.type}` : file.plainName,
+                    id: file.uuid,
+                    size: format_utils_1.FormatUtils.humanFileSize(Number(file.size)),
+                    modified: format_utils_1.FormatUtils.formatDate(file.updatedAt),
                 };
             }),
         ];
-        core_1.ux.table(allItems, {
-            type: {
-                header: 'Type',
-                get: (row) => (row.isFolder ? 'folder' : 'file'),
-            },
-            name: {
-                header: 'Name',
-                get: (row) => (row.isFolder ? row.plainName : `${row.plainName}.${row.type}`),
-            },
-            updatedAt: {
-                header: 'Modified',
-                get: (row) => {
-                    if (flags.output) {
-                        return row.updatedAt;
-                    }
-                    else {
-                        return format_utils_1.FormatUtils.formatDate(row.updatedAt);
-                    }
-                },
-                extended: true,
-            },
-            size: {
-                header: 'Size',
-                get: (row) => {
-                    if (flags.output) {
-                        return row.isFolder ? '0' : row.size;
-                    }
-                    else {
-                        return row.isFolder ? '' : format_utils_1.FormatUtils.humanFileSize(Number(row.size));
-                    }
-                },
-                extended: true,
-            },
-            uuid: {
-                header: 'ID',
-                get: (row) => row.uuid,
-            },
-        }, {
-            printLine: this.log.bind(this),
-            ...flags,
-        });
-    }
-    async catch(error) {
-        errors_utils_1.ErrorUtils.report(error, { command: this.id });
-        cli_utils_1.CLIUtils.error(error.message);
+        const headers = [
+            { value: 'type', alias: 'Type' },
+            { value: 'name', alias: 'Name' },
+            { value: 'id', alias: 'Id' },
+        ];
+        if (flags.extended) {
+            headers.push({ value: 'modified', alias: 'Modified' }, { value: 'size', alias: 'Size' });
+        }
+        cli_utils_1.CLIUtils.table(this.log.bind(this), headers, allItems);
+        return { success: true, list: { folders, files } };
+    };
+    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 = TrashList;

package/dist/commands/trash-restore-file.d.ts

@@ -2,18 +2,20 @@ import { Command } from '@oclif/core';
 export default class TrashRestoreFile extends Command {
     static readonly args: {};
     static readonly description = "Restore a trashed file into a destination folder.";
-    static readonly examples: string[];
     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>;
         destination: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
-    catch(error: Error): Promise<void>;
-    getFileUuid: (fileUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
-    getDestinationFolderUuid: (destinationFolderUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
-    private static readonly MAX_ATTEMPTS;
-    getFileUuidInteractively: () => Promise<string>;
-    getDestinationFolderUuidInteractively: () => Promise<string>;
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        message: string;
+        file: import("@internxt/sdk/dist/drive/storage/types").FileMeta;
+    }>;
+    catch: (error: Error) => Promise<never>;
+    private getFileUuid;
+    private getDestinationFolderUuid;
 }

package/dist/commands/trash-restore-file.js

@@ -10,8 +10,8 @@ const errors_utils_1 = require("../utils/errors.utils");
 class TrashRestoreFile extends core_1.Command {
     static args = {};
     static description = 'Restore a trashed file into a destination folder.';
-    static examples = ['<%= config.bin %> <%= command.id %>'];
     static aliases = ['trash:restore:file'];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
         ...cli_utils_1.CLIUtils.CommonFlags,
         id: core_1.Flags.string({
@@ -26,7 +26,8 @@ class TrashRestoreFile extends core_1.Command {
             parse: cli_utils_1.CLIUtils.parseEmpty,
         }),
     };
-    async run() {
+    static enableJsonFlag = true;
+    run = async () => {
         const { flags } = await this.parse(TrashRestoreFile);
         const nonInteractive = flags['non-interactive'];
         const userCredentials = await config_service_1.ConfigService.instance.readUser();
@@ -35,53 +36,50 @@ class TrashRestoreFile extends core_1.Command {
         const fileUuid = await this.getFileUuid(flags['id'], nonInteractive);
         let destinationFolderUuid = await this.getDestinationFolderUuid(flags['destination'], nonInteractive);
         if (destinationFolderUuid.trim().length === 0) {
-            destinationFolderUuid = userCredentials.root_folder_uuid;
+            destinationFolderUuid = userCredentials.user.rootFolderId;
         }
-        await drive_file_service_1.DriveFileService.instance.moveFile({ fileUuid, destinationFolderUuid });
-        cli_utils_1.CLIUtils.success(`File restored successfully to: ${destinationFolderUuid}`);
-    }
-    async catch(error) {
-        errors_utils_1.ErrorUtils.report(error, { command: this.id });
-        cli_utils_1.CLIUtils.error(error.message);
+        const file = await drive_file_service_1.DriveFileService.instance.moveFile({ fileUuid, destinationFolderUuid });
+        const message = `File restored successfully to: ${destinationFolderUuid}`;
+        cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+        return { success: true, message, file };
+    };
+    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) => {
-        let fileUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+        const fileUuid = await cli_utils_1.CLIUtils.getValueFromFlag({
             value: fileUuidFlag,
             name: TrashRestoreFile.flags['id'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the file id you want to restore?',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
             error: new command_types_1.NotValidFileUuidError(),
-            canBeEmpty: true,
-        }, nonInteractive, (fileUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(fileUuid));
-        if (!fileUuid) {
-            fileUuid = (await this.getFileUuidInteractively()).trim();
-        }
+        }, this.log.bind(this));
         return fileUuid;
     };
     getDestinationFolderUuid = async (destinationFolderUuidFlag, nonInteractive) => {
-        let destinationFolderUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+        const destinationFolderUuid = await cli_utils_1.CLIUtils.getValueFromFlag({
             value: destinationFolderUuidFlag,
             name: TrashRestoreFile.flags['destination'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the destination folder id? (leave empty for the root folder)',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
             error: new command_types_1.NotValidFolderUuidError(),
             canBeEmpty: true,
-        }, nonInteractive, (folderUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(folderUuid));
-        if (!destinationFolderUuid) {
-            destinationFolderUuid = (await this.getDestinationFolderUuidInteractively()).trim();
-        }
+        }, this.log.bind(this));
         return destinationFolderUuid;
     };
-    static MAX_ATTEMPTS = 3;
-    getFileUuidInteractively = () => {
-        return cli_utils_1.CLIUtils.promptWithAttempts({
-            message: 'What is the file id you want to restore?',
-            options: { required: true },
-            error: new command_types_1.NotValidFileUuidError(),
-        }, TrashRestoreFile.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateUUIDv4);
-    };
-    getDestinationFolderUuidInteractively = () => {
-        return cli_utils_1.CLIUtils.prompt({
-            message: 'What is the destination folder id? (leave empty for the root folder)',
-            options: { required: false },
-        });
-    };
 }
 exports.default = TrashRestoreFile;

package/dist/commands/trash-restore-folder.d.ts

@@ -2,18 +2,20 @@ import { Command } from '@oclif/core';
 export default class TrashRestoreFolder extends Command {
     static readonly args: {};
     static readonly description = "Restore a trashed folder into a destination folder.";
-    static readonly examples: string[];
     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>;
         destination: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
-    catch(error: Error): Promise<void>;
-    getFolderUuid: (folderUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
-    getDestinationFolderUuid: (destinationFolderUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
-    private static readonly MAX_ATTEMPTS;
-    getFolderUuidInteractively: () => Promise<string>;
-    getDestinationFolderUuidInteractively: () => Promise<string>;
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        message: string;
+        folder: import("@internxt/sdk/dist/drive/storage/types").FolderMeta;
+    }>;
+    catch: (error: Error) => Promise<never>;
+    private getFolderUuid;
+    private getDestinationFolderUuid;
 }

package/dist/commands/trash-restore-folder.js

@@ -10,8 +10,8 @@ const errors_utils_1 = require("../utils/errors.utils");
 class TrashRestoreFolder extends core_1.Command {
     static args = {};
     static description = 'Restore a trashed folder into a destination folder.';
-    static examples = ['<%= config.bin %> <%= command.id %>'];
     static aliases = ['trash:restore:folder'];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
         ...cli_utils_1.CLIUtils.CommonFlags,
         id: core_1.Flags.string({
@@ -26,7 +26,8 @@ class TrashRestoreFolder extends core_1.Command {
             parse: cli_utils_1.CLIUtils.parseEmpty,
         }),
     };
-    async run() {
+    static enableJsonFlag = true;
+    run = async () => {
         const { flags } = await this.parse(TrashRestoreFolder);
         const nonInteractive = flags['non-interactive'];
         const userCredentials = await config_service_1.ConfigService.instance.readUser();
@@ -35,53 +36,50 @@ class TrashRestoreFolder extends core_1.Command {
         const folderUuid = await this.getFolderUuid(flags['id'], nonInteractive);
         let destinationFolderUuid = await this.getDestinationFolderUuid(flags['destination'], nonInteractive);
         if (destinationFolderUuid.trim().length === 0) {
-            destinationFolderUuid = userCredentials.root_folder_uuid;
+            destinationFolderUuid = userCredentials.user.rootFolderId;
         }
-        await drive_folder_service_1.DriveFolderService.instance.moveFolder({ folderUuid, destinationFolderUuid });
-        cli_utils_1.CLIUtils.success(`Folder restored successfully to: ${destinationFolderUuid}`);
-    }
-    async catch(error) {
-        errors_utils_1.ErrorUtils.report(error, { command: this.id });
-        cli_utils_1.CLIUtils.error(error.message);
+        const folder = await drive_folder_service_1.DriveFolderService.instance.moveFolder({ folderUuid, destinationFolderUuid });
+        const message = `Folder restored successfully to: ${destinationFolderUuid}`;
+        cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+        return { success: true, message, folder };
+    };
+    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) => {
-        let folderUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+        const folderUuid = await cli_utils_1.CLIUtils.getValueFromFlag({
             value: folderUuidFlag,
             name: TrashRestoreFolder.flags['id'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the folder id you want to restore?',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
             error: new command_types_1.NotValidFolderUuidError(),
-            canBeEmpty: true,
-        }, nonInteractive, (folderUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(folderUuid));
-        if (!folderUuid) {
-            folderUuid = (await this.getFolderUuidInteractively()).trim();
-        }
+        }, this.log.bind(this));
         return folderUuid;
     };
     getDestinationFolderUuid = async (destinationFolderUuidFlag, nonInteractive) => {
-        let destinationFolderUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+        const destinationFolderUuid = await cli_utils_1.CLIUtils.getValueFromFlag({
             value: destinationFolderUuidFlag,
             name: TrashRestoreFolder.flags['destination'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the destination folder id? (leave empty for the root folder)',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
             error: new command_types_1.NotValidFolderUuidError(),
             canBeEmpty: true,
-        }, nonInteractive, (folderUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(folderUuid));
-        if (!destinationFolderUuid) {
-            destinationFolderUuid = (await this.getDestinationFolderUuidInteractively()).trim();
-        }
+        }, this.log.bind(this));
         return destinationFolderUuid;
     };
-    static MAX_ATTEMPTS = 3;
-    getFolderUuidInteractively = () => {
-        return cli_utils_1.CLIUtils.promptWithAttempts({
-            message: 'What is the folder id you want to restore?',
-            options: { required: true },
-            error: new command_types_1.NotValidFolderUuidError(),
-        }, TrashRestoreFolder.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateUUIDv4);
-    };
-    getDestinationFolderUuidInteractively = () => {
-        return cli_utils_1.CLIUtils.prompt({
-            message: 'What is the destination folder id? (leave empty for the root folder)',
-            options: { required: false },
-        });
-    };
 }
 exports.default = TrashRestoreFolder;

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

@@ -0,0 +1,21 @@
+import { Command } from '@oclif/core';
+export default class UploadFile extends Command {
+    static readonly args: {};
+    static readonly description = "Upload a file to Internxt Drive";
+    static readonly aliases: string[];
+    static readonly examples: string[];
+    static readonly flags: {
+        file: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        destination: 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;
+        file: import("../types/drive.types").DriveFileItem;
+    }>;
+    catch: (error: Error) => Promise<never>;
+    private getDestinationFolderUuid;
+    private getFilePath;
+}