@internxt/cli 0.1.4

package/dist/services/realms/drive-folders.realm.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveFoldersRealm = exports.DriveFolderRealmSchema = void 0;
+const realm_1 = __importDefault(require("realm"));
+class DriveFolderRealmSchema extends realm_1.default.Object {
+    id;
+    name;
+    uuid;
+    relative_path;
+    parent_id;
+    created_at;
+    updated_at;
+    status;
+    static schema = {
+        name: 'DriveFolder',
+        properties: {
+            id: 'int',
+            name: 'string',
+            uuid: { type: 'string', indexed: true },
+            relative_path: { type: 'string', indexed: true },
+            parent_id: { type: 'int', indexed: true, default: -1 },
+            created_at: 'date',
+            updated_at: 'date',
+            status: 'string',
+        },
+        primaryKey: 'id',
+    };
+}
+exports.DriveFolderRealmSchema = DriveFolderRealmSchema;
+class DriveFoldersRealm {
+    realm;
+    constructor(realm) {
+        this.realm = realm;
+    }
+    findByRelativePath(relativePath) {
+        const object = this.realm
+            .objects('DriveFolder')
+            .filtered('relative_path = $0', relativePath)
+            .find((folder) => folder.relative_path === relativePath);
+        return object ?? null;
+    }
+    findByParentId(parentId) {
+        const parentFolder = this.realm.objectForPrimaryKey('DriveFolder', parentId ?? -1);
+        return parentFolder;
+    }
+    createOrReplace(driveFolder, relativePath) {
+        const existingObject = this.realm.objectForPrimaryKey('DriveFolder', driveFolder.id);
+        this.realm.write(() => {
+            if (existingObject) {
+                this.realm.delete(existingObject);
+            }
+            this.realm.create('DriveFolder', {
+                id: driveFolder.id,
+                name: driveFolder.name,
+                uuid: driveFolder.uuid,
+                parent_id: driveFolder.parentId ?? -1,
+                created_at: driveFolder.createdAt,
+                updated_at: driveFolder.updatedAt,
+                status: 'EXISTS',
+                relative_path: relativePath,
+            });
+        });
+    }
+}
+exports.DriveFoldersRealm = DriveFoldersRealm;

package/dist/services/realms/drive-realm-manager.service.d.ts

@@ -0,0 +1,15 @@
+import { DriveFileItem, DriveFolderItem } from '../../types/drive.types';
+import { DriveFileRealmSchema, DriveFilesRealm } from './drive-files.realm';
+import { DriveFolderRealmSchema, DriveFoldersRealm } from './drive-folders.realm';
+import Realm from 'realm';
+export declare class DriveRealmManager {
+    private driveFilesRealm;
+    private driveFoldersRealm;
+    constructor(driveFilesRealm: DriveFilesRealm, driveFoldersRealm: DriveFoldersRealm);
+    static getRealm(): Realm.ProgressRealmPromise;
+    findByRelativePath(relativePath: string): DriveFolderRealmSchema | DriveFileRealmSchema | null;
+    createFolder(driveFolder: DriveFolderItem): void;
+    createFile(driveFile: DriveFileItem): void;
+    buildRelativePathForFile(fileName: string, parentId: number | null): string;
+    buildRelativePathForFolder(folderName: string, parentId: number | null): string;
+}

package/dist/services/realms/drive-realm-manager.service.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveRealmManager = void 0;
+const drive_files_realm_1 = require("./drive-files.realm");
+const drive_folders_realm_1 = require("./drive-folders.realm");
+const webdav_utils_1 = require("../../utils/webdav.utils");
+const config_service_1 = require("../config.service");
+const realm_1 = __importDefault(require("realm"));
+class DriveRealmManager {
+    driveFilesRealm;
+    driveFoldersRealm;
+    constructor(driveFilesRealm, driveFoldersRealm) {
+        this.driveFilesRealm = driveFilesRealm;
+        this.driveFoldersRealm = driveFoldersRealm;
+    }
+    static getRealm() {
+        return realm_1.default.open({
+            path: config_service_1.ConfigService.DRIVE_REALM_FILE,
+            schema: [drive_files_realm_1.DriveFileRealmSchema, drive_folders_realm_1.DriveFolderRealmSchema],
+            deleteRealmIfMigrationNeeded: true,
+        });
+    }
+    findByRelativePath(relativePath) {
+        const driveFile = this.driveFilesRealm.findByRelativePath(relativePath);
+        if (driveFile)
+            return driveFile;
+        let folderRelativePath = relativePath;
+        if (!relativePath.endsWith('/'))
+            folderRelativePath = relativePath.concat('/');
+        const driveFolder = this.driveFoldersRealm.findByRelativePath(folderRelativePath);
+        if (driveFolder)
+            return driveFolder;
+        return null;
+    }
+    createFolder(driveFolder) {
+        const relativePath = this.buildRelativePathForFolder(driveFolder.name, driveFolder.parentId ?? null);
+        return this.driveFoldersRealm.createOrReplace(driveFolder, relativePath);
+    }
+    createFile(driveFile) {
+        const relativePath = this.buildRelativePathForFile(driveFile.type ? `${driveFile.name}.${driveFile.type}` : driveFile.name, driveFile.folderId);
+        return this.driveFilesRealm.createOrReplace(driveFile, relativePath);
+    }
+    buildRelativePathForFile(fileName, parentId) {
+        const parentFolder = this.driveFoldersRealm.findByParentId(parentId);
+        if (!parentFolder) {
+            return webdav_utils_1.WebDavUtils.joinURL('/', fileName);
+        }
+        const parentPath = this.buildRelativePathForFile(parentFolder.name, parentFolder.parent_id ?? null);
+        return webdav_utils_1.WebDavUtils.joinURL(parentPath, fileName);
+    }
+    buildRelativePathForFolder(folderName, parentId) {
+        const parentFolder = this.driveFoldersRealm.findByParentId(parentId);
+        if (!parentFolder) {
+            return webdav_utils_1.WebDavUtils.joinURL('/', folderName, '/');
+        }
+        const parentPath = this.buildRelativePathForFolder(parentFolder.name, parentFolder.parent_id ?? null);
+        return webdav_utils_1.WebDavUtils.joinURL(parentPath, folderName, '/');
+    }
+}
+exports.DriveRealmManager = DriveRealmManager;

package/dist/services/sdk-manager.service.d.ts

@@ -0,0 +1,28 @@
+import { Auth, Drive, photos, Network as NetworkModule } from '@internxt/sdk';
+import { ApiSecurity, AppDetails } from '@internxt/sdk/dist/shared';
+export type SdkManagerApiSecurity = ApiSecurity & {
+    newToken: string;
+};
+export declare class SdkManager {
+    static readonly instance: SdkManager;
+    private static apiSecurity?;
+    static readonly init: (apiSecurity: SdkManagerApiSecurity) => void;
+    static readonly clean: () => void;
+    static readonly getApiSecurity: (config?: {
+        throwErrorOnMissingCredentials: boolean;
+    }) => SdkManagerApiSecurity;
+    static readonly getAppDetails: () => AppDetails;
+    getAuthV2(): Auth;
+    getAuth(): Auth;
+    getPayments(): Drive.Payments;
+    getUsers(): Drive.Users;
+    getReferrals(): Drive.Referrals;
+    getStorage(useNewApi?: boolean): Drive.Storage;
+    getTrash(): Drive.Trash;
+    getPhotos(): photos.Photos;
+    getShare(): Drive.Share;
+    getNetwork(credentials: {
+        user: string;
+        pass: string;
+    }): NetworkModule.Network;
+}

package/dist/services/sdk-manager.service.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SdkManager = void 0;
+const sdk_1 = require("@internxt/sdk");
+const drive_1 = require("@internxt/sdk/dist/drive");
+const config_service_1 = require("./config.service");
+const package_json_1 = __importDefault(require("../../package.json"));
+const network_utils_1 = require("../utils/network.utils");
+class SdkManager {
+    static instance = new SdkManager();
+    static apiSecurity;
+    static init = (apiSecurity) => {
+        SdkManager.apiSecurity = apiSecurity;
+    };
+    static clean = () => {
+        SdkManager.apiSecurity = undefined;
+    };
+    static getApiSecurity = (config = { throwErrorOnMissingCredentials: true }) => {
+        if (!SdkManager.apiSecurity && config.throwErrorOnMissingCredentials)
+            throw new Error('Api security properties not found in SdkManager');
+        return SdkManager.apiSecurity;
+    };
+    static getAppDetails = () => {
+        return {
+            clientName: package_json_1.default.name,
+            clientVersion: package_json_1.default.version,
+        };
+    };
+    getAuthV2() {
+        const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
+        const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
+        const appDetails = SdkManager.getAppDetails();
+        return sdk_1.Auth.client(DRIVE_NEW_API_URL, appDetails, apiSecurity);
+    }
+    getAuth() {
+        const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_API_URL');
+        const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
+        const appDetails = SdkManager.getAppDetails();
+        return sdk_1.Auth.client(DRIVE_API_URL, appDetails, apiSecurity);
+    }
+    getPayments() {
+        const PAYMENTS_API_URL = config_service_1.ConfigService.instance.get('PAYMENTS_API_URL');
+        const newToken = SdkManager.getApiSecurity().newToken;
+        const appDetails = SdkManager.getAppDetails();
+        return sdk_1.Drive.Payments.client(PAYMENTS_API_URL, appDetails, {
+            token: newToken,
+        });
+    }
+    getUsers() {
+        const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_API_URL');
+        const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
+        const appDetails = SdkManager.getAppDetails();
+        return sdk_1.Drive.Users.client(DRIVE_API_URL, appDetails, apiSecurity);
+    }
+    getReferrals() {
+        const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_API_URL');
+        const apiSecurity = SdkManager.getApiSecurity();
+        const appDetails = SdkManager.getAppDetails();
+        return sdk_1.Drive.Referrals.client(DRIVE_API_URL, appDetails, apiSecurity);
+    }
+    getStorage(useNewApi = false) {
+        const DRIVE_API_URL = useNewApi
+            ? config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL')
+            : config_service_1.ConfigService.instance.get('DRIVE_API_URL');
+        const apiSecurity = SdkManager.getApiSecurity();
+        const appDetails = SdkManager.getAppDetails();
+        return sdk_1.Drive.Storage.client(DRIVE_API_URL, appDetails, {
+            token: useNewApi ? apiSecurity.newToken : apiSecurity.token,
+        });
+    }
+    getTrash() {
+        const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
+        const newToken = SdkManager.getApiSecurity().newToken;
+        const appDetails = SdkManager.getAppDetails();
+        return drive_1.Trash.client(DRIVE_NEW_API_URL, appDetails, {
+            token: newToken,
+        });
+    }
+    getPhotos() {
+        const PHOTOS_API_URL = config_service_1.ConfigService.instance.get('PHOTOS_API_URL');
+        const newToken = SdkManager.getApiSecurity().newToken;
+        return new sdk_1.photos.Photos(PHOTOS_API_URL, newToken);
+    }
+    getShare() {
+        const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
+        const newToken = SdkManager.getApiSecurity().newToken;
+        const appDetails = SdkManager.getAppDetails();
+        return sdk_1.Drive.Share.client(DRIVE_NEW_API_URL, appDetails, {
+            token: newToken,
+        });
+    }
+    getNetwork(credentials) {
+        const appDetails = SdkManager.getAppDetails();
+        const auth = network_utils_1.NetworkUtils.getAuthFromCredentials({
+            user: credentials.user,
+            pass: credentials.pass,
+        });
+        return sdk_1.Network.Network.client(config_service_1.ConfigService.instance.get('NETWORK_URL'), appDetails, {
+            bridgeUser: auth.username,
+            userId: auth.password,
+        });
+    }
+}
+exports.SdkManager = SdkManager;

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

@@ -0,0 +1,6 @@
+export declare class UsageService {
+    static readonly instance: UsageService;
+    static readonly INFINITE_LIMIT: number;
+    fetchTotalUsage: () => Promise<number>;
+    fetchSpaceLimit: () => Promise<number>;
+}

package/dist/services/usage.service.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageService = void 0;
+const sdk_manager_service_1 = require("./sdk-manager.service");
+class UsageService {
+    static instance = new UsageService();
+    static INFINITE_LIMIT = 99 * Math.pow(1024, 4);
+    fetchTotalUsage = async () => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        const photosClient = sdk_manager_service_1.SdkManager.instance.getPhotos();
+        const [driveUsage, { usage: photosUsage }] = await Promise.all([
+            storageClient.spaceUsage(),
+            photosClient.photos.getUsage(),
+        ]);
+        return driveUsage.total + photosUsage;
+    };
+    fetchSpaceLimit = async () => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        const spaceLimit = await storageClient.spaceLimit();
+        return spaceLimit.maxSpaceBytes;
+    };
+}
+exports.UsageService = UsageService;

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

@@ -0,0 +1,7 @@
+export declare class ValidationService {
+    static readonly instance: ValidationService;
+    validateEmail: (email: string) => boolean;
+    validate2FA: (code: string) => boolean;
+    validateMnemonic: (mnemonic: string) => boolean;
+    validateUUIDv4: (uuid: string) => boolean;
+}

package/dist/services/validation.service.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationService = void 0;
+const lib_1 = require("@internxt/lib");
+const bip39_1 = require("bip39");
+class ValidationService {
+    static instance = new ValidationService();
+    validateEmail = (email) => {
+        return lib_1.auth.isValidEmail(email);
+    };
+    validate2FA = (code) => {
+        return /^\d{6}$/.test(code);
+    };
+    validateMnemonic = (mnemonic) => {
+        return (0, bip39_1.validateMnemonic)(mnemonic);
+    };
+    validateUUIDv4 = (uuid) => {
+        return /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i.test(uuid);
+    };
+}
+exports.ValidationService = ValidationService;

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

@@ -0,0 +1,42 @@
+import { UserSettings } from '@internxt/sdk/dist/shared/types/userSettings';
+export interface LoginCredentials {
+    user: UserSettings;
+    token: string;
+    newToken: string;
+    mnemonic: string;
+}
+export interface CLICredentials extends LoginCredentials {
+    root_folder_uuid: string;
+}
+export declare class NotValidEmailError extends Error {
+    constructor();
+}
+export declare class EmptyPasswordError extends Error {
+    constructor();
+}
+export declare class NotValidTwoFactorCodeError extends Error {
+    constructor();
+}
+export declare class NotValidFolderUuidError extends Error {
+    constructor();
+}
+export declare class NotValidItemUuidError extends Error {
+    constructor();
+}
+export declare class ItemNotFoundError extends Error {
+    constructor();
+}
+export declare class NoRootFolderIdFoundError extends Error {
+    constructor();
+}
+export declare class MissingCredentialsError extends Error {
+    constructor();
+}
+export type PaginatedItem = {
+    plainName: string;
+    uuid: string;
+    isFolder: boolean;
+    type: string;
+    size: bigint;
+    updatedAt: Date;
+};

package/dist/types/command.types.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingCredentialsError = exports.NoRootFolderIdFoundError = exports.ItemNotFoundError = exports.NotValidItemUuidError = exports.NotValidFolderUuidError = exports.NotValidTwoFactorCodeError = exports.EmptyPasswordError = exports.NotValidEmailError = void 0;
+class NotValidEmailError extends Error {
+    constructor() {
+        super('Email is not valid');
+        Object.setPrototypeOf(this, NotValidEmailError.prototype);
+    }
+}
+exports.NotValidEmailError = NotValidEmailError;
+class EmptyPasswordError extends Error {
+    constructor() {
+        super('Password can not be empty');
+        Object.setPrototypeOf(this, EmptyPasswordError.prototype);
+    }
+}
+exports.EmptyPasswordError = EmptyPasswordError;
+class NotValidTwoFactorCodeError extends Error {
+    constructor() {
+        super('Two factor auth code is not valid (it must be 6 digit long)');
+        Object.setPrototypeOf(this, NotValidTwoFactorCodeError.prototype);
+    }
+}
+exports.NotValidTwoFactorCodeError = NotValidTwoFactorCodeError;
+class NotValidFolderUuidError extends Error {
+    constructor() {
+        super('Folder UUID is not valid (it must be a valid v4 UUID)');
+        Object.setPrototypeOf(this, NotValidFolderUuidError.prototype);
+    }
+}
+exports.NotValidFolderUuidError = NotValidFolderUuidError;
+class NotValidItemUuidError extends Error {
+    constructor() {
+        super('Item UUID is not valid (it must be a valid v4 UUID)');
+        Object.setPrototypeOf(this, NotValidItemUuidError.prototype);
+    }
+}
+exports.NotValidItemUuidError = NotValidItemUuidError;
+class ItemNotFoundError extends Error {
+    constructor() {
+        super('Item not found');
+        Object.setPrototypeOf(this, ItemNotFoundError.prototype);
+    }
+}
+exports.ItemNotFoundError = ItemNotFoundError;
+class NoRootFolderIdFoundError extends Error {
+    constructor() {
+        super('No root folder id found on your account');
+        Object.setPrototypeOf(this, NoRootFolderIdFoundError.prototype);
+    }
+}
+exports.NoRootFolderIdFoundError = NoRootFolderIdFoundError;
+class MissingCredentialsError extends Error {
+    constructor() {
+        super('Missing credentials, login first');
+        Object.setPrototypeOf(this, MissingCredentialsError.prototype);
+    }
+}
+exports.MissingCredentialsError = MissingCredentialsError;

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

@@ -0,0 +1,13 @@
+export interface ConfigKeys {
+    readonly DRIVE_URL: string;
+    readonly DRIVE_API_URL: string;
+    readonly DRIVE_NEW_API_URL: string;
+    readonly PAYMENTS_API_URL: string;
+    readonly PHOTOS_API_URL: string;
+    readonly APP_CRYPTO_SECRET: string;
+    readonly APP_CRYPTO_SECRET2: string;
+    readonly APP_MAGIC_IV: string;
+    readonly APP_MAGIC_SALT: string;
+    readonly NETWORK_URL: string;
+    readonly WEBDAV_SERVER_PORT: string;
+}

package/dist/types/config.types.js

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

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

@@ -0,0 +1,14 @@
+import { DriveFileData, DriveFolderData } from '@internxt/sdk/dist/drive/storage/types';
+export type DriveFileItem = Pick<DriveFileData, 'name' | 'bucket' | 'fileId' | 'id' | 'uuid' | 'folderId' | 'status'> & {
+    encryptedName: string;
+    size: number;
+    createdAt: Date;
+    updatedAt: Date;
+    type?: string;
+};
+export type DriveFolderItem = Pick<DriveFolderData, 'name' | 'bucket' | 'id' | 'parentId'> & {
+    encryptedName: string;
+    uuid: string;
+    createdAt: Date;
+    updatedAt: Date;
+};

package/dist/types/drive.types.js

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

package/dist/types/keys.types.d.ts

@@ -0,0 +1,16 @@
+export declare class BadEncodedPrivateKeyError extends Error {
+    constructor();
+}
+export declare class WrongIterationsToEncryptPrivateKeyError extends Error {
+    constructor();
+}
+export declare class CorruptedEncryptedPrivateKeyError extends Error {
+    constructor();
+}
+export declare class KeysDoNotMatchError extends Error {
+    constructor();
+}
+export interface AesInit {
+    iv: string;
+    salt: string;
+}

package/dist/types/keys.types.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeysDoNotMatchError = exports.CorruptedEncryptedPrivateKeyError = exports.WrongIterationsToEncryptPrivateKeyError = exports.BadEncodedPrivateKeyError = void 0;
+class BadEncodedPrivateKeyError extends Error {
+    constructor() {
+        super('Private key is bad encoded');
+        Object.setPrototypeOf(this, BadEncodedPrivateKeyError.prototype);
+    }
+}
+exports.BadEncodedPrivateKeyError = BadEncodedPrivateKeyError;
+class WrongIterationsToEncryptPrivateKeyError extends Error {
+    constructor() {
+        super('Private key was encrypted using the wrong iterations number');
+        Object.setPrototypeOf(this, WrongIterationsToEncryptPrivateKeyError.prototype);
+    }
+}
+exports.WrongIterationsToEncryptPrivateKeyError = WrongIterationsToEncryptPrivateKeyError;
+class CorruptedEncryptedPrivateKeyError extends Error {
+    constructor() {
+        super('Private key is corrupted');
+        Object.setPrototypeOf(this, CorruptedEncryptedPrivateKeyError.prototype);
+    }
+}
+exports.CorruptedEncryptedPrivateKeyError = CorruptedEncryptedPrivateKeyError;
+class KeysDoNotMatchError extends Error {
+    constructor() {
+        super('Keys do not match');
+        Object.setPrototypeOf(this, KeysDoNotMatchError.prototype);
+    }
+}
+exports.KeysDoNotMatchError = KeysDoNotMatchError;

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

@@ -0,0 +1,11 @@
+export interface NetworkCredentials {
+    user: string;
+    pass: string;
+}
+export type UploadProgressCallback = (progress: number) => void;
+export interface NetworkOperationBaseOptions {
+    progressCallback: UploadProgressCallback;
+    abortController?: AbortController;
+}
+export type UploadOptions = NetworkOperationBaseOptions;
+export type DownloadOptions = NetworkOperationBaseOptions;

package/dist/types/network.types.js

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

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

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { Request, Response } from 'express';
+import { ParsedPath } from 'path';
+export declare abstract class WebDavMethodHandler {
+    abstract handle(request: Request, response: Response): Promise<void>;
+}
+export type WebDavMethodHandlerOptions = {
+    debug: boolean;
+};
+export type WebDavRequestedResource = {
+    type: 'file' | 'folder';
+    url: string;
+    name: string;
+    path: ParsedPath;
+};

package/dist/types/webdav.types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebDavMethodHandler = void 0;
+class WebDavMethodHandler {
+}
+exports.WebDavMethodHandler = WebDavMethodHandler;

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

@@ -0,0 +1,32 @@
+import { ux } from '@oclif/core';
+export declare class CLIUtils {
+    static clearPreviousLine(): void;
+    static warning(message: string): void;
+    static error(message: string): void;
+    static doing(message: string): void;
+    static success(message: string): void;
+    static done(): void;
+    static readonly CommonFlags: {
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static readonly getValueFromFlag: (flag: {
+        value?: string;
+        name: string;
+        error: Error;
+        canBeEmpty?: boolean;
+    }, nonInteractive: boolean, validate: (value: string) => boolean) => string | undefined;
+    static readonly promptWithAttempts: (prompt: {
+        message: string;
+        options?: ux.IPromptOptions;
+        error: Error;
+    }, maxAttempts: number, validate: (value: string) => boolean) => Promise<string>;
+    static timer(): {
+        stop: () => number;
+    };
+    static readonly prompt: (prompt: {
+        message: string;
+        options?: ux.IPromptOptions;
+        error: Error;
+    }, validate?: ((value: string) => boolean) | undefined) => Promise<string>;
+    static readonly parseEmpty: (input: string) => Promise<string>;
+}