@internxt/cli 0.1.4

package/dist/utils/cli.utils.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIUtils = void 0;
+const core_1 = require("@oclif/core");
+class CLIUtils {
+    static clearPreviousLine() {
+        process.stdout.write('\x1b[1A');
+        process.stdout.clearLine(0);
+    }
+    static warning(message) {
+        core_1.ux.log(core_1.ux.colorize('#a67805', `⚠ Warning: ${message}`));
+    }
+    static error(message) {
+        core_1.ux.log(core_1.ux.colorize('red', `⚠ Error: ${message}`));
+    }
+    static doing(message) {
+        core_1.ux.action.start(message, undefined, {});
+    }
+    static success(message) {
+        core_1.ux.log(core_1.ux.colorize('green', `✓ ${message}`));
+    }
+    static done() {
+        core_1.ux.action.stop(core_1.ux.colorize('green', 'done ✓'));
+    }
+    static CommonFlags = {
+        'non-interactive': core_1.Flags.boolean({
+            char: 'n',
+            env: 'INXT_NONINTERACTIVE',
+            helpGroup: 'helper',
+            description: 'Blocks the cli from being interactive. If passed, the cli will not request data through the console and will throw errors directly',
+            required: false,
+        }),
+    };
+    static getValueFromFlag = (flag, nonInteractive, validate) => {
+        if (flag.canBeEmpty) {
+            if (!flag.value || flag.value.trim().length === 0) {
+                return '';
+            }
+        }
+        if (flag.value) {
+            const isValid = validate(flag.value);
+            if (isValid) {
+                return flag.value;
+            }
+            else if (nonInteractive) {
+                throw flag.error;
+            }
+            else {
+                CLIUtils.error(flag.error.message);
+            }
+        }
+        else if (nonInteractive) {
+            throw new NoFlagProvidedError(flag.name);
+        }
+    };
+    static promptWithAttempts = async (prompt, maxAttempts, validate) => {
+        let isValid = false;
+        let currentAttempts = 0;
+        let promptValue = '';
+        do {
+            promptValue = await core_1.ux.prompt(prompt.message, prompt.options);
+            isValid = validate(promptValue);
+            if (!isValid) {
+                currentAttempts++;
+                if (currentAttempts < maxAttempts) {
+                    CLIUtils.warning(prompt.error.message + ', please type it again');
+                }
+            }
+        } while (!isValid && currentAttempts < maxAttempts);
+        if (!isValid) {
+            throw prompt.error;
+        }
+        else {
+            return promptValue;
+        }
+    };
+    static timer() {
+        const start = new Date();
+        return {
+            stop: () => {
+                const end = new Date();
+                const time = end.getTime() - start.getTime();
+                return time;
+            },
+        };
+    }
+    static prompt = async (prompt, validate) => {
+        const promptValue = await core_1.ux.prompt(prompt.message, prompt.options);
+        if (validate) {
+            const isValid = validate(promptValue);
+            if (!isValid) {
+                throw prompt.error;
+            }
+        }
+        return promptValue;
+    };
+    static parseEmpty = async (input) => (input.trim().length === 0 ? ' ' : input);
+}
+exports.CLIUtils = CLIUtils;
+class NoFlagProvidedError extends Error {
+    constructor(flag) {
+        super(`No ${flag} flag has been provided`);
+        Object.setPrototypeOf(this, NoFlagProvidedError.prototype);
+    }
+}

package/dist/utils/crypto.utils.d.ts

@@ -0,0 +1,6 @@
+export declare class CryptoUtils {
+    static getAesInit(): {
+        iv: string;
+        salt: string;
+    };
+}

package/dist/utils/crypto.utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoUtils = void 0;
+const config_service_1 = require("../services/config.service");
+class CryptoUtils {
+    static getAesInit() {
+        return { iv: config_service_1.ConfigService.instance.get('APP_MAGIC_IV'), salt: config_service_1.ConfigService.instance.get('APP_MAGIC_SALT') };
+    }
+}
+exports.CryptoUtils = CryptoUtils;

package/dist/utils/drive.utils.d.ts

@@ -0,0 +1,6 @@
+import { FileMeta, FolderMeta } from '@internxt/sdk/dist/drive/storage/types';
+import { DriveFileItem, DriveFolderItem } from '../types/drive.types';
+export declare class DriveUtils {
+    static driveFileMetaToItem(fileMeta: FileMeta): DriveFileItem;
+    static driveFolderMetaToItem(folderMeta: FolderMeta): DriveFolderItem;
+}

package/dist/utils/drive.utils.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveUtils = void 0;
+class DriveUtils {
+    static driveFileMetaToItem(fileMeta) {
+        return {
+            uuid: fileMeta.uuid ?? '',
+            status: fileMeta.status,
+            folderId: fileMeta.folder_id,
+            size: fileMeta.size,
+            encryptedName: fileMeta.name,
+            name: fileMeta.plainName ?? fileMeta.name,
+            bucket: fileMeta.bucket,
+            createdAt: new Date(fileMeta.createdAt),
+            updatedAt: new Date(fileMeta.updatedAt),
+            fileId: fileMeta.fileId,
+            id: fileMeta.id,
+            type: fileMeta.type,
+        };
+    }
+    static driveFolderMetaToItem(folderMeta) {
+        return {
+            uuid: folderMeta.uuid,
+            id: folderMeta.id,
+            bucket: folderMeta.bucket,
+            name: folderMeta.plainName ?? folderMeta.name,
+            encryptedName: folderMeta.name,
+            parentId: folderMeta.parentId,
+            createdAt: new Date(folderMeta.createdAt),
+            updatedAt: new Date(folderMeta.updatedAt),
+        };
+    }
+}
+exports.DriveUtils = DriveUtils;

package/dist/utils/errors.utils.d.ts

@@ -0,0 +1,19 @@
+export declare class ErrorUtils {
+    static report(error: unknown, props?: Record<string, unknown>): void;
+}
+export declare class NotFoundError extends Error {
+    statusCode: number;
+    constructor(message: string);
+}
+export declare class BadRequestError extends Error {
+    statusCode: number;
+    constructor(message: string);
+}
+export declare class UnsupportedMediaTypeError extends Error {
+    statusCode: number;
+    constructor(message: string);
+}
+export declare class NotImplementedError extends Error {
+    statusCode: number;
+    constructor(message: string);
+}

package/dist/utils/errors.utils.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotImplementedError = exports.UnsupportedMediaTypeError = exports.BadRequestError = exports.NotFoundError = exports.ErrorUtils = void 0;
+class ErrorUtils {
+    static report(error, props = {}) {
+        if (error instanceof Error) {
+            console.error(`[REPORTED_ERROR]: ${error.message}\nProperties => ${JSON.stringify(props, null, 2)}\nStack => ${error.stack}`);
+        }
+        else {
+            console.error(`[REPORTED_ERROR]: ${JSON.stringify(error)}\nProperties => ${JSON.stringify(props, null, 2)}\n`);
+        }
+    }
+}
+exports.ErrorUtils = ErrorUtils;
+class NotFoundError extends Error {
+    statusCode = 404;
+    constructor(message) {
+        super(message);
+        this.name = 'NotFoundError';
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+}
+exports.NotFoundError = NotFoundError;
+class BadRequestError extends Error {
+    statusCode = 400;
+    constructor(message) {
+        super(message);
+        this.name = 'BadRequestError';
+        Object.setPrototypeOf(this, BadRequestError.prototype);
+    }
+}
+exports.BadRequestError = BadRequestError;
+class UnsupportedMediaTypeError extends Error {
+    statusCode = 415;
+    constructor(message) {
+        super(message);
+        this.name = 'UnsupportedMediaTypeError';
+        Object.setPrototypeOf(this, UnsupportedMediaTypeError.prototype);
+    }
+}
+exports.UnsupportedMediaTypeError = UnsupportedMediaTypeError;
+class NotImplementedError extends Error {
+    statusCode = 501;
+    constructor(message) {
+        super(message);
+        this.name = 'NotImplementedError';
+        Object.setPrototypeOf(this, NotImplementedError.prototype);
+    }
+}
+exports.NotImplementedError = NotImplementedError;

package/dist/utils/format.utils.d.ts

@@ -0,0 +1,6 @@
+export declare class FormatUtils {
+    static readonly humanFileSize: (size: number) => string;
+    static readonly formatDate: (date: string | Date) => string;
+    static readonly formatDateForWebDav: (date: string | Date) => string;
+    static readonly formatLimit: (limit: number) => string;
+}

package/dist/utils/format.utils.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatUtils = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+const usage_service_1 = require("../services/usage.service");
+dayjs_1.default.extend(utc_1.default);
+class FormatUtils {
+    static humanFileSize = (size) => {
+        const i = size == 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024));
+        return Number((size / Math.pow(1024, i)).toFixed(2)) * 1 + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][i];
+    };
+    static formatDate = (date) => {
+        return (0, dayjs_1.default)(date).format('D MMMM, YYYY [at] HH:mm');
+    };
+    static formatDateForWebDav = (date) => {
+        return dayjs_1.default.utc(date).format('ddd, DD MMM YYYY HH:mm:ss [GMT]');
+    };
+    static formatLimit = (limit) => {
+        let result = '...';
+        if (limit > 0) {
+            result = limit === usage_service_1.UsageService.INFINITE_LIMIT ? 'infinity' : this.humanFileSize(limit);
+        }
+        return result;
+    };
+}
+exports.FormatUtils = FormatUtils;

package/dist/utils/hash.utils.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Hash } from 'crypto';
+import { Transform, TransformCallback, TransformOptions } from 'stream';
+export declare class HashStream extends Transform {
+    hasher: Hash;
+    finalHash: Buffer;
+    constructor(opts?: TransformOptions);
+    _transform(chunk: Buffer, enc: BufferEncoding, cb: TransformCallback): void;
+    _flush(cb: (err: Error | null) => void): Hash;
+    reset(): void;
+    readHash(): Buffer;
+    getHash(): Buffer;
+}

package/dist/utils/hash.utils.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashStream = void 0;
+const crypto_1 = require("crypto");
+const stream_1 = require("stream");
+class HashStream extends stream_1.Transform {
+    hasher;
+    finalHash;
+    constructor(opts) {
+        super(opts);
+        this.hasher = (0, crypto_1.createHash)('sha256');
+        this.finalHash = Buffer.alloc(0);
+    }
+    _transform(chunk, enc, cb) {
+        this.hasher.update(chunk);
+        cb(null, chunk);
+    }
+    _flush(cb) {
+        return this.hasher.end(cb);
+    }
+    reset() {
+        this.hasher = (0, crypto_1.createHash)('sha256');
+    }
+    readHash() {
+        if (!this.finalHash.length) {
+            this.finalHash = this.hasher.read();
+        }
+        return this.finalHash;
+    }
+    getHash() {
+        if (!this.finalHash.length) {
+            this.readHash();
+        }
+        return (0, crypto_1.createHash)('ripemd160').update(this.finalHash).digest();
+    }
+}
+exports.HashStream = HashStream;

package/dist/utils/logger.utils.d.ts

@@ -0,0 +1,3 @@
+import winston from 'winston';
+export declare const logger: winston.Logger;
+export declare const webdavLogger: winston.Logger;

package/dist/utils/logger.utils.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webdavLogger = exports.logger = void 0;
+const winston_1 = __importDefault(require("winston"));
+const config_service_1 = require("../services/config.service");
+exports.logger = winston_1.default.createLogger({
+    level: 'info',
+    format: winston_1.default.format.json(),
+    defaultMeta: { service: 'internxt-cli' },
+    transports: [
+        new winston_1.default.transports.File({
+            filename: 'internxt-cli-error.log',
+            level: 'error',
+            dirname: config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR,
+        }),
+        new winston_1.default.transports.File({
+            filename: 'internxt-cli-combined.log',
+            dirname: config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR,
+        }),
+    ],
+});
+exports.webdavLogger = winston_1.default.createLogger({
+    level: 'info',
+    format: winston_1.default.format.json(),
+    defaultMeta: { service: 'internxt-webdav' },
+    transports: [
+        new winston_1.default.transports.File({
+            filename: 'internxt-webdav-error.log',
+            level: 'error',
+            dirname: config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR,
+        }),
+        new winston_1.default.transports.File({
+            filename: 'internxt-webdav-combined.log',
+            dirname: config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR,
+        }),
+    ],
+});
+if (process.env.NODE_ENV !== 'production') {
+    exports.webdavLogger.add(new winston_1.default.transports.Console({
+        format: winston_1.default.format.simple(),
+    }));
+}
+if (process.env.NODE_ENV !== 'production') {
+    exports.logger.add(new winston_1.default.transports.Console({
+        format: winston_1.default.format.simple(),
+    }));
+}

package/dist/utils/network.utils.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { NetworkCredentials } from '../types/network.types';
+import selfsigned from 'selfsigned';
+export declare class NetworkUtils {
+    static getAuthFromCredentials(creds: NetworkCredentials): {
+        username: string;
+        password: string;
+    };
+    static readonly WEBDAV_SSL_CERTS_PATH: {
+        cert: string;
+        privateKey: string;
+    };
+    static getWebdavSSLCerts(): {
+        cert: string;
+        key: string;
+    } | {
+        cert: Buffer;
+        key: Buffer;
+    };
+    static saveWebdavSSLCerts(pems: selfsigned.GenerateResult): void;
+    static generateSelfSignedSSLCerts(): selfsigned.GenerateResult;
+}

package/dist/utils/network.utils.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkUtils = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const selfsigned_1 = __importDefault(require("selfsigned"));
+const config_service_1 = require("../services/config.service");
+class NetworkUtils {
+    static getAuthFromCredentials(creds) {
+        return {
+            username: creds.user,
+            password: (0, node_crypto_1.createHash)('SHA256').update(Buffer.from(creds.pass)).digest().toString('hex'),
+        };
+    }
+    static WEBDAV_SSL_CERTS_PATH = {
+        cert: node_path_1.default.join(config_service_1.ConfigService.WEBDAV_SSL_CERTS_DIR, 'cert.crt'),
+        privateKey: node_path_1.default.join(config_service_1.ConfigService.WEBDAV_SSL_CERTS_DIR, 'priv.key'),
+    };
+    static getWebdavSSLCerts() {
+        if (!(0, node_fs_1.existsSync)(this.WEBDAV_SSL_CERTS_PATH.cert) || !(0, node_fs_1.existsSync)(this.WEBDAV_SSL_CERTS_PATH.privateKey)) {
+            const newCerts = this.generateSelfSignedSSLCerts();
+            this.saveWebdavSSLCerts(newCerts);
+            return {
+                cert: newCerts.cert,
+                key: newCerts.private,
+            };
+        }
+        else {
+            return {
+                cert: (0, node_fs_1.readFileSync)(this.WEBDAV_SSL_CERTS_PATH.cert),
+                key: (0, node_fs_1.readFileSync)(this.WEBDAV_SSL_CERTS_PATH.privateKey),
+            };
+        }
+    }
+    static saveWebdavSSLCerts(pems) {
+        (0, node_fs_1.writeFileSync)(this.WEBDAV_SSL_CERTS_PATH.cert, pems.cert, 'utf8');
+        (0, node_fs_1.writeFileSync)(this.WEBDAV_SSL_CERTS_PATH.privateKey, pems.private, 'utf8');
+    }
+    static generateSelfSignedSSLCerts() {
+        const attrs = [{ name: 'commonName', value: config_service_1.ConfigService.WEBDAV_LOCAL_URL }];
+        const pems = selfsigned_1.default.generate(attrs, { days: 365, algorithm: 'sha256', keySize: 2048 });
+        return pems;
+    }
+}
+exports.NetworkUtils = NetworkUtils;

package/dist/utils/pm2.utils.d.ts

@@ -0,0 +1,10 @@
+export type WebDavProcessStatus = 'online' | 'unknown' | 'errored';
+export declare class PM2Utils {
+    private static WEBDAV_APP_NAME;
+    static connect(): Promise<void>;
+    static killWebDavServer(): Promise<void>;
+    static webdavServerStatus(): Promise<{
+        status: WebDavProcessStatus;
+    }>;
+    static startWebDavServer(): Promise<void>;
+}

package/dist/utils/pm2.utils.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM2Utils = void 0;
+const path_1 = __importDefault(require("path"));
+const pm2_1 = __importDefault(require("pm2"));
+class PM2Utils {
+    static WEBDAV_APP_NAME = 'Internxt CLI WebDav';
+    static connect() {
+        return new Promise((resolve, reject) => {
+            pm2_1.default.connect((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    static killWebDavServer() {
+        return new Promise((resolve) => {
+            pm2_1.default.delete(this.WEBDAV_APP_NAME, () => {
+                resolve();
+            });
+        });
+    }
+    static webdavServerStatus() {
+        return new Promise((resolve, reject) => {
+            pm2_1.default.describe(this.WEBDAV_APP_NAME, (err, processDescription) => {
+                if (err) {
+                    reject(err);
+                }
+                else if (processDescription.length === 0) {
+                    reject(new Error('WebDav server is not running'));
+                }
+                else {
+                    const process = processDescription[0];
+                    resolve({
+                        status: (process.pm2_env?.status ?? 'unknown'),
+                    });
+                }
+            });
+        });
+    }
+    static startWebDavServer() {
+        return new Promise((resolve, reject) => {
+            pm2_1.default.start({
+                wait_ready: true,
+                script: path_1.default.join(__dirname, '../webdav/index.js'),
+                name: this.WEBDAV_APP_NAME,
+            }, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+}
+exports.PM2Utils = PM2Utils;

package/dist/utils/stream.utils.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { ReadStream, WriteStream } from 'fs';
+export declare class StreamUtils {
+    static readStreamToReadableStream(readStream: ReadStream): ReadableStream<Uint8Array>;
+    static writeStreamToWritableStream(writeStream: WriteStream): WritableStream<Uint8Array>;
+    static joinReadableBinaryStreams(streams: ReadableStream<Uint8Array>[]): ReadableStream<Uint8Array>;
+}

package/dist/utils/stream.utils.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamUtils = void 0;
+class StreamUtils {
+    static readStreamToReadableStream(readStream) {
+        const readable = new ReadableStream({
+            async start(controller) {
+                readStream.on('data', (chunk) => {
+                    controller.enqueue(Buffer.from(chunk));
+                });
+                readStream.on('end', () => {
+                    controller.close();
+                });
+            },
+        });
+        return readable;
+    }
+    static writeStreamToWritableStream(writeStream) {
+        const writable = new WritableStream({
+            write(chunk) {
+                writeStream.write(chunk);
+            },
+        });
+        return writable;
+    }
+    static joinReadableBinaryStreams(streams) {
+        const streamsCopy = streams.map((s) => s);
+        let keepReading = true;
+        const flush = () => streamsCopy.forEach((s) => s.cancel());
+        const stream = new ReadableStream({
+            async pull(controller) {
+                if (!keepReading)
+                    return flush();
+                const downStream = streamsCopy.shift();
+                if (!downStream) {
+                    return controller.close();
+                }
+                const reader = downStream.getReader();
+                let done = false;
+                while (!done && keepReading) {
+                    const status = await reader.read();
+                    if (!status.done) {
+                        controller.enqueue(status.value);
+                    }
+                    done = status.done;
+                }
+                reader.releaseLock();
+            },
+            cancel() {
+                keepReading = false;
+            },
+        });
+        return stream;
+    }
+}
+exports.StreamUtils = StreamUtils;

package/dist/utils/webdav.utils.d.ts

@@ -0,0 +1,7 @@
+import { Request } from 'express';
+import { WebDavRequestedResource } from '../types/webdav.types';
+import { DriveDatabaseManager } from '../services/database/drive-database-manager.service';
+export declare class WebDavUtils {
+    static joinURL(...pathComponents: string[]): string;
+    static getRequestedResource(req: Request, driveDatabaseManager: DriveDatabaseManager): Promise<WebDavRequestedResource>;
+}

package/dist/utils/webdav.utils.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebDavUtils = void 0;
+const path_1 = __importDefault(require("path"));
+const drive_folder_domain_1 = require("../services/database/drive-folder/drive-folder.domain");
+const drive_file_domain_1 = require("../services/database/drive-file/drive-file.domain");
+class WebDavUtils {
+    static joinURL(...pathComponents) {
+        return path_1.default.posix.join(...pathComponents);
+    }
+    static async getRequestedResource(req, driveDatabaseManager) {
+        const decodedUrl = decodeURI(req.url);
+        const parsedPath = path_1.default.parse(decodedUrl);
+        let isFolder = req.url.endsWith('/');
+        if (!isFolder) {
+            const findDatabaseItem = await driveDatabaseManager.findByRelativePath(decodedUrl);
+            if (findDatabaseItem) {
+                if (findDatabaseItem instanceof drive_file_domain_1.DriveFile) {
+                    isFolder = false;
+                }
+                else if (findDatabaseItem instanceof drive_folder_domain_1.DriveFolder) {
+                    isFolder = true;
+                }
+            }
+        }
+        if (isFolder) {
+            return {
+                url: decodedUrl,
+                type: 'folder',
+                name: parsedPath.name,
+                path: parsedPath,
+            };
+        }
+        else {
+            return {
+                type: 'file',
+                url: decodedUrl,
+                name: parsedPath.name,
+                path: parsedPath,
+            };
+        }
+    }
+}
+exports.WebDavUtils = WebDavUtils;

package/dist/utils/xml.utils.d.ts

@@ -0,0 +1,8 @@
+import { X2jOptions, XmlBuilderOptions } from 'fast-xml-parser';
+export declare class XMLUtils {
+    static readonly DEFAULT_NAMESPACE_LETTER = "D";
+    static toJSON(xml: string, options?: X2jOptions): any;
+    static toXML(object: object, options?: XmlBuilderOptions): any;
+    static toWebDavXML(object: object, options: XmlBuilderOptions): string;
+    static addDefaultNamespace(key: string): string;
+}