@internxt/cli 0.1.4

package/dist/commands/list.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const config_service_1 = require("../services/config.service");
+const drive_folder_service_1 = require("../services/drive/drive-folder.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 format_utils_1 = require("../utils/format.utils");
+const errors_utils_1 = require("../utils/errors.utils");
+class List extends core_1.Command {
+    static args = {};
+    static description = 'Lists the content of a folder id.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        id: core_1.Flags.string({
+            char: 'f',
+            description: 'The folder id to list. Leave empty for the root folder.',
+            required: false,
+            parse: cli_utils_1.CLIUtils.parseEmpty,
+        }),
+        ...core_1.ux.table.flags(),
+    };
+    async run() {
+        const { flags } = await this.parse(List);
+        const nonInteractive = flags['non-interactive'];
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        let folderUuid = await this.getFolderUuid(flags['id'], nonInteractive);
+        if (folderUuid.trim().length === 0) {
+            folderUuid = userCredentials.root_folder_uuid;
+        }
+        const { folders, files } = await drive_folder_service_1.DriveFolderService.instance.getFolderContent(folderUuid);
+        const allItems = [
+            ...folders.map((folder) => {
+                return {
+                    isFolder: true,
+                    plainName: folder.plainName,
+                    uuid: folder.uuid,
+                    type: '',
+                    size: BigInt(0),
+                    updatedAt: folder.updatedAt,
+                };
+            }),
+            ...files.map((file) => {
+                return {
+                    isFolder: false,
+                    plainName: file.plainName,
+                    uuid: file.uuid,
+                    type: file.type,
+                    size: file.size,
+                    updatedAt: 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);
+        this.exit(1);
+    }
+    getFolderUuid = async (folderUuidFlag, nonInteractive) => {
+        let folderUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: folderUuidFlag,
+            name: List.flags['id'].name,
+            error: new command_types_1.NotValidFolderUuidError(),
+            canBeEmpty: true,
+        }, nonInteractive, (folderUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(folderUuid));
+        if (!folderUuid && folderUuid !== '') {
+            folderUuid = (await this.getFolderUuidInteractively()).trim();
+        }
+        return folderUuid;
+    };
+    getFolderUuidInteractively = () => {
+        return cli_utils_1.CLIUtils.prompt({
+            message: 'What is the folder id you want to list? (leave empty for the root folder)',
+            options: { required: false },
+            error: new command_types_1.NotValidFolderUuidError(),
+        });
+    };
+}
+exports.default = List;

package/dist/commands/login.d.ts

@@ -0,0 +1,21 @@
+import { Command } from '@oclif/core';
+export default class Login extends Command {
+    static readonly args: {};
+    static readonly description = "Logs into an Internxt account. If the account is two-factor protected, then an extra code will be required.";
+    static readonly examples: string[];
+    static readonly flags: {
+        email: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        password: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        twofactor: 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>;
+    getEmail: (emailFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    getPassword: (passwordFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    getTwoFactorCode: (twoFactorFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    private static readonly MAX_ATTEMPTS;
+    getEmailInteractively: () => Promise<string>;
+    getPasswordInteractively: () => Promise<string>;
+    getTwoFactorCodeInteractively: () => Promise<string>;
+}

package/dist/commands/login.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const command_types_1 = require("../types/command.types");
+const auth_service_1 = require("../services/auth.service");
+const config_service_1 = require("../services/config.service");
+const validation_service_1 = require("../services/validation.service");
+const cli_utils_1 = require("../utils/cli.utils");
+const errors_utils_1 = require("../utils/errors.utils");
+const drive_folder_service_1 = require("../services/drive/drive-folder.service");
+const sdk_manager_service_1 = require("../services/sdk-manager.service");
+const drive_database_manager_service_1 = require("../services/database/drive-database-manager.service");
+class Login extends core_1.Command {
+    static args = {};
+    static description = 'Logs into an Internxt account. If the account is two-factor protected, then an extra code will be required.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        email: core_1.Flags.string({
+            char: 'e',
+            aliases: ['mail'],
+            env: 'INXT_EMAIL',
+            description: 'The email to log in',
+            required: false,
+        }),
+        password: core_1.Flags.string({
+            char: 'p',
+            aliases: ['pass'],
+            env: 'INXT_PASSWORD',
+            description: 'The plain password to log in',
+            required: false,
+        }),
+        twofactor: core_1.Flags.string({
+            char: 'w',
+            aliases: ['two', 'two-factor'],
+            env: 'INXT_TWOFACTORCODE',
+            description: 'The two factor auth code (only needed if the account is two-factor protected)',
+            required: false,
+            helpValue: '123456',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Login);
+        const nonInteractive = flags['non-interactive'];
+        const email = await this.getEmail(flags['email'], nonInteractive);
+        const password = await this.getPassword(flags['password'], nonInteractive);
+        const is2FANeeded = await auth_service_1.AuthService.instance.is2FANeeded(email);
+        let twoFactorCode;
+        if (is2FANeeded) {
+            twoFactorCode = await this.getTwoFactorCode(flags['twofactor'], nonInteractive);
+        }
+        const loginCredentials = await auth_service_1.AuthService.instance.doLogin(email, password, twoFactorCode);
+        sdk_manager_service_1.SdkManager.init({
+            token: loginCredentials.token,
+            newToken: loginCredentials.newToken,
+        });
+        const rootMeta = await drive_folder_service_1.DriveFolderService.instance.getFolderMetaById(loginCredentials.user.root_folder_id);
+        await config_service_1.ConfigService.instance.saveUser(Object.assign(loginCredentials, { root_folder_uuid: rootMeta.uuid }));
+        await drive_database_manager_service_1.DriveDatabaseManager.init();
+        await drive_database_manager_service_1.DriveDatabaseManager.clean();
+        cli_utils_1.CLIUtils.success(`Succesfully logged in to: ${loginCredentials.user.email} `);
+    }
+    async catch(error) {
+        errors_utils_1.ErrorUtils.report(error, { command: this.id });
+        cli_utils_1.CLIUtils.error(error.message);
+        this.exit(1);
+    }
+    getEmail = async (emailFlag, nonInteractive) => {
+        let email = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: emailFlag,
+            name: Login.flags['email'].name,
+            error: new command_types_1.NotValidEmailError(),
+        }, nonInteractive, validation_service_1.ValidationService.instance.validateEmail);
+        if (!email) {
+            email = await this.getEmailInteractively();
+        }
+        return email;
+    };
+    getPassword = async (passwordFlag, nonInteractive) => {
+        let password = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: passwordFlag,
+            name: Login.flags['password'].name,
+            error: new command_types_1.EmptyPasswordError(),
+        }, nonInteractive, (password) => password.trim().length > 0);
+        if (!password) {
+            password = await this.getPasswordInteractively();
+        }
+        return password;
+    };
+    getTwoFactorCode = async (twoFactorFlag, nonInteractive) => {
+        let twoFactor = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: twoFactorFlag,
+            name: Login.flags['twofactor'].name,
+            error: new command_types_1.NotValidTwoFactorCodeError(),
+        }, nonInteractive, validation_service_1.ValidationService.instance.validate2FA);
+        if (!twoFactor) {
+            twoFactor = await this.getTwoFactorCodeInteractively();
+        }
+        return twoFactor;
+    };
+    static MAX_ATTEMPTS = 3;
+    getEmailInteractively = () => {
+        return cli_utils_1.CLIUtils.promptWithAttempts({
+            message: 'What is your email?',
+            options: { required: true },
+            error: new command_types_1.NotValidEmailError(),
+        }, Login.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateEmail);
+    };
+    getPasswordInteractively = () => {
+        return cli_utils_1.CLIUtils.promptWithAttempts({
+            message: 'What is your password?',
+            options: { type: 'hide', required: true },
+            error: new command_types_1.EmptyPasswordError(),
+        }, Login.MAX_ATTEMPTS, (password) => password.trim().length > 0);
+    };
+    getTwoFactorCodeInteractively = () => {
+        return cli_utils_1.CLIUtils.promptWithAttempts({
+            message: 'What is your two-factor token?',
+            options: { type: 'mask', required: true },
+            error: new command_types_1.NotValidTwoFactorCodeError(),
+        }, Login.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validate2FA);
+    };
+}
+exports.default = Login;

package/dist/commands/logout.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class Logout extends Command {
+    static readonly args: {};
+    static readonly description = "Logs out the current internxt user that is logged into the Internxt CLI.";
+    static readonly examples: string[];
+    static readonly flags: {};
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+}

package/dist/commands/logout.js

@@ -0,0 +1,28 @@
+"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 errors_utils_1 = require("../utils/errors.utils");
+class Logout extends core_1.Command {
+    static args = {};
+    static description = 'Logs out the current internxt user that is logged into the Internxt CLI.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {};
+    async run() {
+        const user = await config_service_1.ConfigService.instance.readUser();
+        if (user) {
+            await config_service_1.ConfigService.instance.clearUser();
+            cli_utils_1.CLIUtils.success('User logged out correctly');
+        }
+        else {
+            cli_utils_1.CLIUtils.error('You are not logged in');
+        }
+    }
+    async catch(error) {
+        errors_utils_1.ErrorUtils.report(error, { command: this.id });
+        cli_utils_1.CLIUtils.error(error.message);
+        this.exit(1);
+    }
+}
+exports.default = Logout;

package/dist/commands/logs.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Logs extends Command {
+    static readonly description = "Displays the Internxt CLI logs directory path";
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/logs.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const config_service_1 = require("../services/config.service");
+class Logs extends core_1.Command {
+    static description = 'Displays the Internxt CLI logs directory path';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        this.log(`Internxt CLI logs are at ${config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR}`);
+    }
+}
+exports.default = Logs;

package/dist/commands/move.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class Move extends Command {
+    static readonly args: {};
+    static readonly description = "Move a folder/file into a destination folder.";
+    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>;
+    getItemUuid: (itemUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    getDestinationFolderUuid: (destinationFolderUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    private static readonly MAX_ATTEMPTS;
+    getItemUuidInteractively: () => Promise<string>;
+    getDestinationFolderUuidInteractively: () => Promise<string>;
+}

package/dist/commands/move.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const config_service_1 = require("../services/config.service");
+const drive_folder_service_1 = require("../services/drive/drive-folder.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");
+class Move extends core_1.Command {
+    static args = {};
+    static description = 'Move a folder/file into a destination folder.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        id: core_1.Flags.string({
+            char: 'i',
+            description: 'The item id to be moved (it can be a file id or a folder id).',
+            required: false,
+        }),
+        destination: core_1.Flags.string({
+            char: 'd',
+            description: 'The destination folder id where the item is going to be moved.',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Move);
+        const nonInteractive = flags['non-interactive'];
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        const itemUuid = await this.getItemUuid(flags['id'], nonInteractive);
+        const destinationFolderUuid = await this.getDestinationFolderUuid(flags['destination'], nonInteractive);
+        let item;
+        let isFolder = false;
+        try {
+            if (!item) {
+                item = await drive_file_service_1.DriveFileService.instance.getFileMetadata(itemUuid);
+                isFolder = false;
+            }
+        }
+        catch {
+        }
+        try {
+            if (!item) {
+                item = await drive_folder_service_1.DriveFolderService.instance.getFolderMetaByUuid(itemUuid);
+                isFolder = true;
+            }
+        }
+        catch {
+        }
+        if (!item)
+            throw new command_types_1.ItemNotFoundError();
+        if (isFolder) {
+            await drive_folder_service_1.DriveFolderService.instance.moveFolder({ folderUuid: item.uuid, destinationFolderUuid });
+        }
+        else {
+            await drive_file_service_1.DriveFileService.instance.moveFile({ fileUuid: item.uuid, destinationFolderUuid });
+        }
+        cli_utils_1.CLIUtils.success(`${isFolder ? 'Folder' : 'File'} moved successfully to: ${destinationFolderUuid}`);
+    }
+    async catch(error) {
+        errors_utils_1.ErrorUtils.report(error, { command: this.id });
+        cli_utils_1.CLIUtils.error(error.message);
+        this.exit(1);
+    }
+    getItemUuid = async (itemUuidFlag, nonInteractive) => {
+        let itemUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: itemUuidFlag,
+            name: Move.flags['id'].name,
+            error: new command_types_1.NotValidItemUuidError(),
+            canBeEmpty: true,
+        }, nonInteractive, (itemUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(itemUuid));
+        if (!itemUuid) {
+            itemUuid = (await this.getItemUuidInteractively()).trim();
+        }
+        return itemUuid;
+    };
+    getDestinationFolderUuid = async (destinationFolderUuidFlag, nonInteractive) => {
+        let destinationFolderUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: destinationFolderUuidFlag,
+            name: Move.flags['destination'].name,
+            error: new command_types_1.NotValidFolderUuidError(),
+            canBeEmpty: true,
+        }, nonInteractive, (folderUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(folderUuid));
+        if (!destinationFolderUuid) {
+            destinationFolderUuid = (await this.getDestinationFolderUuidInteractively()).trim();
+        }
+        return destinationFolderUuid;
+    };
+    static MAX_ATTEMPTS = 3;
+    getItemUuidInteractively = () => {
+        return cli_utils_1.CLIUtils.promptWithAttempts({
+            message: 'What is the item id you want to move?',
+            options: { required: true },
+            error: new command_types_1.NotValidItemUuidError(),
+        }, Move.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateUUIDv4);
+    };
+    getDestinationFolderUuidInteractively = () => {
+        return cli_utils_1.CLIUtils.promptWithAttempts({
+            message: 'What is the destination folder id?',
+            options: { required: true },
+            error: new command_types_1.NotValidFolderUuidError(),
+        }, Move.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateUUIDv4);
+    };
+}
+exports.default = Move;

package/dist/commands/trash.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class Trash extends Command {
+    static readonly args: {};
+    static readonly description = "Moves a given folder/file to the trash.";
+    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>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+    getItemUuid: (itemUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    private static readonly MAX_ATTEMPTS;
+    getItemUuidInteractively: () => Promise<string>;
+}

package/dist/commands/trash.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const config_service_1 = require("../services/config.service");
+const drive_folder_service_1 = require("../services/drive/drive-folder.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 Trash extends core_1.Command {
+    static args = {};
+    static description = 'Moves a given folder/file to the trash.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        id: core_1.Flags.string({
+            char: 'i',
+            description: 'The item id to be trashed (it can be a file id or a folder id).',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Trash);
+        const nonInteractive = flags['non-interactive'];
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        const itemUuid = await this.getItemUuid(flags['id'], nonInteractive);
+        let item;
+        let isFolder = false;
+        try {
+            if (!item) {
+                item = await drive_file_service_1.DriveFileService.instance.getFileMetadata(itemUuid);
+                isFolder = false;
+            }
+        }
+        catch {
+        }
+        try {
+            if (!item) {
+                item = await drive_folder_service_1.DriveFolderService.instance.getFolderMetaByUuid(itemUuid);
+                isFolder = true;
+            }
+        }
+        catch {
+        }
+        if (!item)
+            throw new command_types_1.ItemNotFoundError();
+        if (isFolder) {
+            await trash_service_1.TrashService.instance.trashItems({ items: [{ uuid: item.uuid, type: 'folder' }] });
+        }
+        else {
+            await trash_service_1.TrashService.instance.trashItems({ items: [{ uuid: item.uuid, type: 'file' }] });
+        }
+        cli_utils_1.CLIUtils.success(`${isFolder ? 'Folder' : 'File'} trashed successfully, you can restore or delete it permanently on: https://drive.internxt.com/trash`);
+    }
+    async catch(error) {
+        errors_utils_1.ErrorUtils.report(error, { command: this.id });
+        cli_utils_1.CLIUtils.error(error.message);
+        this.exit(1);
+    }
+    getItemUuid = async (itemUuidFlag, nonInteractive) => {
+        let itemUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: itemUuidFlag,
+            name: Trash.flags['id'].name,
+            error: new command_types_1.NotValidItemUuidError(),
+            canBeEmpty: true,
+        }, nonInteractive, (itemUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(itemUuid));
+        if (!itemUuid) {
+            itemUuid = (await this.getItemUuidInteractively()).trim();
+        }
+        return itemUuid;
+    };
+    static MAX_ATTEMPTS = 3;
+    getItemUuidInteractively = () => {
+        return cli_utils_1.CLIUtils.promptWithAttempts({
+            message: 'What is the item id you want to trash?',
+            options: { required: true },
+            error: new command_types_1.NotValidItemUuidError(),
+        }, Trash.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateUUIDv4);
+    };
+}
+exports.default = Trash;

package/dist/commands/upload.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class Upload extends Command {
+    static readonly description = "Upload a file to Internxt Drive";
+    static readonly examples: string[];
+    static readonly enableJsonFlag = true;
+    static readonly flags: {
+        file: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    catch(error: Error): Promise<void>;
+    run(): Promise<{
+        fileId: string;
+        uuid: string;
+    }>;
+}