tnp-core 21.0.166 → 21.0.167

package/full-dts/utils-cli.d.ts

@@ -0,0 +1,41 @@
+export declare namespace UtilsCli {
+    /**
+     * Taon CLI specyfic mehtod for mesuring script execution time:
+     * from beginning of script to this moment.
+     */
+    const getTimeFromThisCLIScriptStart: () => {
+        ms: string;
+        sec: string;
+        min: string;
+    };
+}
+/**
+ * Easy way to connect CLI commands to cli class methods.
+ *
+ * Example:
+ * in clic class
+ *
+ * $FirstCli {
+ *   static [UtilsCliClassMethod.staticClassNameProperty] = '$FirstCli';
+ *
+ *   @UtilsCliClassMethod.decoratorMethod('doSomething')
+ *   doSomething() {
+ *     console.log('doing something');
+ *   }
+ * }
+ *
+ * UtilsCliClassMethod.getFrom($FirstCli.prototype.doSomething) // "firstcli:dosomething"
+ *
+ */
+export declare namespace UtilsCliClassMethod {
+    const decoratorMethod: (methodName: string) => MethodDecorator;
+    const getFrom: <ARGS_TO_PARSE extends object = any>(ClassPrototypeMethodFnHere: Function, options?: {
+        globalMethod?: boolean;
+        /**
+         * arguments to parse into CLI format
+         * Example: { projectName: "myproj", envName: "prod" } => "--projectName=myproj --envName=prod"
+         * TODO @LAST add support for DEEP args parsing with lodash-walk-object
+         */
+        argsToParse?: ARGS_TO_PARSE;
+    }) => string;
+}

package/full-dts/utils-dot-file.d.ts

@@ -0,0 +1,17 @@
+export declare namespace UtilsDotFile {
+    const setValueToDotFile: (dotFileAbsPath: string | string[], key: string, value: string | number | boolean) => void;
+    const setCommentToKeyInDotFile: (dotFileAbsPath: string | string[], key: string, comment: string) => void;
+    const getValueFromDotFile: (dotFileAbsPath: string | string[], key: string) => string | number | boolean;
+    const addCommentAtTheBeginningOfDotFile: (dotFileAbsPath: string | string[], comment: string) => void;
+    const setValuesKeysFromObject: (dotFileAbsPath: string | string[], obj: Record<string, string | number | boolean>, options?: {
+        /**
+         * if true, it will overwrite existing keys
+         */
+        setAsNewFile?: boolean;
+    }) => void;
+    const getValuesKeysAsJsonObject: <T = Record<string, string | number | boolean>>(dotFileAbsPath: string | string[]) => T;
+    /**
+     * @returns key|comment pairs as json object
+     */
+    const getCommentsKeysAsJsonObject: <T = Record<string, string | undefined>>(dotFileAbsPath: string | string[]) => T;
+}

package/full-dts/utils-env.d.ts

@@ -0,0 +1,101 @@
+export declare namespace UtilsEnv {
+    enum EnvironmentName {
+        /**
+         * Default environment, typically for artifact without application
+         * or for storing common data
+         */
+        __ = "__",
+        /**
+         * Local development environment, typically the developer's machine.
+         */
+        LOCALHOST = "localhost",
+        /**
+         * Development environment used by engineers to deploy and test new features.
+         */
+        DEV = "dev",
+        /**
+         * Staging environment used for final validations before production.
+         */
+        STAGE = "stage",
+        /**
+         * Production environment serving live users.
+         */
+        PROD = "prod",
+        /**
+         * Cloudflare full backend/frontend deployment
+         */
+        CLOUDFLARE = "cloudflare",
+        /**
+         * Taon cloud full backend/frontend deployment
+         */
+        CLOUD = "cloud",
+        /**
+         *  Automated test environment for running unit, integration, or automated tests.
+         */
+        TEST = "test",
+        /**
+         * Quality assurance environment designated for manual and exploratory testing.
+         */
+        QA = "qa",
+        /**
+         * Sandbox environment for experimenting and integration without affecting other environments.
+         */
+        SANDBOX = "sandbox",
+        /**
+         * User Acceptance Testing environment where clients or stakeholders validate the release candidate.
+         */
+        UAT = "uat",
+        /**
+         * Pre-production environment, closely mirroring production for final testing and validation.
+         */
+        PREPROD = "preprod",
+        /**
+         * Demonstration environment specifically configured for client presentations and demos.
+         */
+        DEMO = "demo",
+        /**
+         * Documentation environment for hosting and managing project documentation.
+         */
+        DOCS = "docs",
+        /**
+         * Demonstration environment ONLY html files, typically used for static pages or documentation.
+         * This environment is not intended for dynamic content or server-side processing.
+         * Perfect to github pages or similar.
+         * It is not intended for production use and should not be used for any critical applications or services.
+         */
+        STATIC_PAGES = "static-pages",
+        /**
+         * Continuous Integration environment used by CI/CD pipelines for automated builds and deployments.
+         */
+        CI = "ci",
+        /**
+         * Training environment dedicated to internal team onboarding and training activities.
+         */
+        TRAINING = "training",
+        /**
+         * Staging environment used for final validations before production.
+         */
+        STAGING = "staging"
+    }
+    type EnvironmentNameTaon = `${EnvironmentName}`;
+    const EnvironmentNameArr: readonly EnvironmentNameTaon[];
+    function getTsFileName({ artifactName, envName, envNumber, }: {
+        artifactName: string;
+        envName: string;
+        envNumber?: string | number;
+    }): string;
+    /**
+     * @returns envName, envNumber from string that is container
+     * environment. Examples:
+     * - env.angular-node-app.dev.ts > envName: 'dev' , envNumber: undefined
+     * - env.angular-node-app.dev0.ts > envName: 'dev' , envNumber: 0
+     * - env.angular-node-app.dev3.ts > envName: 'dev' , envNumber: 3
+     * - env.prod.ts > envName: 'prod' , envNumber: undefined
+     * - env.prod2.tsx > envName: 'prod' , envNumber: 2
+     * - prod4 > envName: 'prod' , envNumber: 4
+     */
+    function splitEnv(value: string): {
+        envName: string | EnvironmentNameTaon;
+        envNumber?: number | undefined;
+    };
+}

package/full-dts/utils-etc-hosts.d.ts

@@ -0,0 +1,28 @@
+import 'reflect-metadata';
+import { Subject } from 'rxjs';
+export declare namespace UtilsEtcHosts {
+    const SIMULATE_DOMAIN_TAG = "@simulatedDomainByTaon";
+    interface EtchostEntry {
+        lineIp: string;
+        domains: string[];
+        comment: string;
+    }
+    const getPath: () => string;
+    const getLines: () => string[];
+    const getTokensData: (line: string) => {
+        comment: string;
+        domains: string[];
+        lineIp: string;
+    };
+    const specificEntryExists: (domain: string, ip: string) => boolean;
+    const getEntriesByDomain: (domain: string) => UtilsEtcHosts.EtchostEntry[];
+    const getEntryByComment: (commentOfEntry: string) => UtilsEtcHosts.EtchostEntry[];
+    /**
+     * Returns all host entries for a given IP address.
+     */
+    const getEntriesByIp: (ip: string) => UtilsEtcHosts.EtchostEntry[];
+    const removeEntryByDomain: (domain: string) => void;
+    const simulateDomain: (domainOrDomains: string | string[], options?: {
+        triggerRevertChangesToEtcHosts?: Subject<void>;
+    }) => Promise<void>;
+}

package/full-dts/utils-exec-proc-vscode.d.ts

@@ -0,0 +1,62 @@
+import type { CancellationToken, OutputChannel, Progress } from 'vscode';
+export type ExecVscodeProgress = {
+    value?: number;
+    message?: string;
+    type?: 'info' | 'warning' | 'error' | 'event';
+};
+export type ExecAsyncVscodeOptions = {
+    command: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    outputChannel?: OutputChannel;
+    progress?: Progress<{
+        message?: string;
+        increment?: number;
+    }>;
+    cancellationToken?: CancellationToken;
+    showCommand?: boolean;
+    showOutput?: boolean;
+    /**
+     * Maximum stdout or stderr buffered by exec().
+     *
+     * exec() can terminate the child when this is exceeded.
+     */
+    maxBuffer?: number;
+    /**
+     * Called for every ordinary stdout line.
+     */
+    onStdoutLine?: (line: string) => void;
+    /**
+     * Called for every ordinary stderr line.
+     */
+    onStderrLine?: (line: string) => void;
+    /**
+     * Parses a structured progress line.
+     *
+     * Return undefined when the line is ordinary output.
+     */
+    parseProgress?: (line: string) => ExecVscodeProgress | undefined;
+};
+export type ExecAsyncVscodeResult = {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+};
+export declare class ExecAsyncVscodeError extends Error {
+    readonly command: string;
+    readonly cwd?: string;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly exitCode?: number;
+    readonly signal?: NodeJS.Signals;
+    constructor(options: {
+        command: string;
+        cwd?: string;
+        stdout: string;
+        stderr: string;
+        exitCode?: number;
+        signal?: NodeJS.Signals;
+        cause?: unknown;
+    });
+}
+export declare function execAsyncVscode(options: ExecAsyncVscodeOptions): Promise<ExecAsyncVscodeResult>;

package/full-dts/utils-exec-proc.d.ts

@@ -0,0 +1,100 @@
+import 'reflect-metadata';
+/**
+ * Async api for executing child processes
+ * (proper handling of stdout / stderr and options)
+ */
+export declare namespace UtilsExecProc {
+    interface ExecProcOptions {
+        cwd?: string;
+        shell?: boolean | string;
+        /**
+         * default true
+         * true -> good for long outputs
+         * false -> good for short outputs (speed things up)
+         */
+        biggerBuffer?: boolean;
+        /**
+         * default true
+         */
+        showOutputColor?: boolean;
+        /**
+         * default true
+         */
+        showOutput?: boolean | 'stdoutOnly' | 'stderrOnly';
+        /**
+         * default process.env
+         */
+        env?: {
+            [key: string]: string;
+        };
+    }
+    interface ExecProcWaitUntilDoneOrThrow {
+        shell?: boolean | string;
+        /**
+         * default [0]
+         */
+        successCode?: number[];
+        /**
+         * in stdout or stderr
+         */
+        successOutputMessage?: string | string[] | {
+            stdout?: string | string[];
+            stderr?: string | string[];
+        };
+        /**
+         * in stdout or stderr
+         */
+        failOutputMessage?: string | string[] | {
+            stdout?: string | string[];
+            stderr?: string | string[];
+        };
+    }
+    /**
+     * This class expose function that are usually needed when working
+     * with child processes (without digging into low level child_process module)
+     */
+    class ExecProcResult {
+        protected readonly command: string;
+        protected readonly args: string[];
+        protected readonly execProcOptions: ExecProcOptions;
+        private stdoutFromCommand;
+        private stderrFromCommand;
+        private child;
+        private get maxBuffer();
+        private get env();
+        constructor(command: string, args: string[], execProcOptions?: ExecProcOptions);
+        getOutput(options?: {
+            shell?: boolean | string;
+            skipThrowingError?: boolean;
+        }): Promise<{
+            stdout: string;
+            stderr: string;
+        }>;
+        getStdoutWithoutShowingOrThrow(options?: {
+            shell?: boolean | string;
+        }): Promise<string>;
+        waitUntilDoneOrThrow(options?: ExecProcWaitUntilDoneOrThrow): Promise<boolean>;
+    }
+    /**
+     * @TODO @IN_PROGRESS
+     */
+    export const spawnAsync: (command: string, options?: ExecProcOptions) => ExecProcResult;
+    /**
+     * @TODO @IN_PROGRESS
+     */
+    export const spawnAdminSudo: (command: string, options?: ExecProcOptions) => Promise<void>;
+    /**
+     * @TODO @IN_PROGRESS
+     */
+    export const executeUntilEndOrThrow: ({ command, cwd, shell, }: {
+        command: string;
+        cwd: string;
+        shell?: boolean;
+    }) => Promise<void>;
+    export const getStdoutWithoutShowingOrThrow: ({ command, cwd, shell, }: {
+        command: string;
+        cwd: string;
+        shell?: boolean;
+    }) => Promise<string>;
+    export {};
+}

package/full-dts/utils-files-folders.d.ts

@@ -0,0 +1,106 @@
+import 'reflect-metadata';
+import { CopyOptionsSync } from 'fs-extra';
+export declare namespace UtilsFilesFoldersSync {
+    const IGNORE_FOLDERS_FILES_PATTERNS: string[];
+    const readFile: (absoluteFilePath: string | string[], // @ts-ignore
+    options?: {
+        defaultValueWhenNotExists?: string | undefined;
+        notTrim?: boolean;
+        /**
+         * Default false
+         */
+        readImagesWithoutEncodingUtf8?: boolean;
+        /**
+         * Default false
+         */
+        forceReadWithoutEncodingUtf8?: boolean;
+    }) => string | undefined;
+    const writeFile: (absoluteFilePath: string | string[], input: string | object | Buffer, options?: {
+        /**
+         * Default false
+         * by default it will not write the file if the content is exactly the same
+         */
+        overrideSameFile?: boolean;
+        preventParentFile?: boolean;
+        /**
+         * Default false
+         */
+        writeImagesWithoutEncodingUtf8?: boolean;
+        /**
+         * Default false
+         */
+        forceReadWithoutEncodingUtf8?: boolean;
+    }) => boolean;
+    interface UtilsFilesFoldersSyncGetFilesFromOptions {
+        recursive?: boolean;
+        followSymlinks?: boolean;
+        /**
+         * glob patterns to omit from result
+         */
+        omitPatterns?: string[];
+    }
+    /**
+     * return absolute paths for files inside folder or link to folder
+     */
+    const getFilesFrom: (folderOrLinkToFolder: string | string[], options?: UtilsFilesFoldersSyncGetFilesFromOptions) => string[];
+    /**
+     * return absolute paths for folders inside folder or link to folder
+     */
+    const getFoldersFrom: (folderOrLinkToFolder: string | string[], options?: UtilsFilesFoldersSyncGetFilesFromOptions) => string[];
+    const copyFolder: (sourceDir: string | string[], destinationDir: string | string[], options?: {
+        filter?: CopyOptionsSync["filter"];
+        copySymlinksAsFiles?: boolean;
+    }) => void;
+    const copy: (sourceDir: string | string[], destinationDir: string | string[], options?: {
+        filter?: any;
+        overwrite?: boolean;
+        recursive?: boolean;
+        asSeparatedFiles?: boolean;
+        asSeparatedFilesAllowNotCopied?: boolean;
+        asSeparatedFilesSymlinkAsFile?: boolean;
+        /**
+         * folders to omit: example: ['src','node_modules']
+         *
+         * This option works only with omitFoldersBaseFolder
+         */
+        omitFolders?: string[];
+        /**
+         * absolute path for base folder for omitFolder option
+         */
+        omitFoldersBaseFolder?: string;
+        copySymlinksAsFiles?: boolean;
+        copySymlinksAsFilesDeleteUnexistedLinksFromSourceFirst?: boolean;
+        useTempFolder?: boolean;
+        dontAskOnError?: boolean;
+    } & CopyOptionsSync) => void;
+    const filterDontCopy: (basePathFoldersTosSkip: string[], projectOrBasepath: string) => (src: string, dest: string) => boolean;
+    const filterOnlyCopy: (basePathFoldersOnlyToInclude: string[], projectOrBasepath: string) => (src: string, dest: string) => boolean;
+    const copyFile: (sourcePath: string | string[], destinationPath: string | string[], options?: {
+        transformTextFn?: (input: string) => string;
+        debugMode?: boolean;
+        fast?: boolean;
+        dontCopySameContent?: boolean;
+    }) => boolean;
+    /**
+     * @deprecated use .copy and then .remove on
+     * source folder..
+     *
+     * This method is messing with parcel watcher
+     * (moved files are not detected)
+     */
+    const move: (from: string, to: string, options?: {
+        purpose?: string;
+    }) => void;
+}
+/**
+ * TODO @LAST @IN_PROGRESS
+ * - utils for files and folders operations
+ * - export when ready
+ * - should be ready for everything async refactor
+ */
+export declare namespace UtilsFilesFolders {
+    /**
+     * Patterns that should be always ignored
+     */
+    const IGNORE_FOLDERS_FILES_PATTERNS: string[];
+}

package/full-dts/utils-http.d.ts

@@ -0,0 +1,188 @@
+export declare namespace UtilsHttp {
+    type ParamType = 'Path' | 'Query' | 'Cookie' | 'Header' | 'Body';
+    /**
+     * @deprecated
+     * known http code
+     */
+    type Code = 200 | 400 | 401 | 404 | 500;
+    type Method = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'jsonp';
+    const HttpMethodArr: Method[];
+    function mimeType(type: string): string;
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
+     */
+    const mimeTypes: {
+        readonly '.aac': "audio/aac";
+        readonly '.abw': "application/x-abiword";
+        readonly '.arc': "application/x-freearc";
+        readonly '.avi': "video/x-msvideo";
+        readonly '.azw': "application/vnd.amazon.ebook";
+        readonly '.bin': "application/octet-stream";
+        readonly '.bmp': "image/bmp";
+        readonly '.bz': "application/x-bzip";
+        readonly '.bz2': "application/x-bzip2";
+        readonly '.csh': "application/x-csh";
+        readonly '.css': "text/css";
+        readonly '.csv': "text/csv";
+        readonly '.doc': "application/msword";
+        readonly '.docx': "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+        readonly '.eot': "application/vnd.ms-fontobject";
+        readonly '.epub': "application/epub+zip";
+        readonly '.gz': "application/gzip";
+        readonly '.gif': "image/gif";
+        readonly '.htm': "text/html";
+        readonly '.html': "text/html";
+        readonly '.ico': "image/vnd.microsoft.icon";
+        readonly '.ics': "text/calendar";
+        readonly '.jar': "application/java-archive";
+        readonly '.jpeg': "image/jpeg";
+        readonly '.jpg': "image/jpeg";
+        readonly '.js': "text/javascript";
+        readonly '.json': "application/json";
+        readonly '.jsonld': "application/ld+json";
+        readonly '.mid': "application/midi";
+        readonly '.midi': "application/midi";
+        readonly '.mjs': "text/javascript";
+        readonly '.mp3': "audio/mpeg";
+        readonly '.mp4': "video/mp4";
+        readonly '.mpeg': "video/mpeg";
+        readonly '.mpkg': "application/vnd.apple.installer+xml";
+        readonly '.odp': "application/vnd.oasis.opendocument.presentation";
+        readonly '.ods': "application/vnd.oasis.opendocument.spreadsheet";
+        readonly '.odt': "application/vnd.oasis.opendocument.text";
+        readonly '.oga': "audio/ogg";
+        readonly '.ogg': "audio/ogg";
+        readonly '.ogv': "video/ogg";
+        readonly '.ogx': "application/ogg";
+        readonly '.opus': "audio/opus";
+        readonly '.otf': "font/otf";
+        readonly '.png': "image/png";
+        readonly '.pdf': "application/pdf";
+        readonly '.php': "application/php";
+        readonly '.ppt': "application/vnd.ms-powerpoint";
+        readonly '.pptx': "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+        readonly '.rar': "application/vnd.rar";
+        readonly '.rtf': "application/rtf";
+        readonly '.sh': "application/x-sh";
+        readonly '.svg': "image/svg+xml";
+        readonly '.swf': "application/x-shockwave-flash";
+        readonly '.tar': "application/x-tar";
+        readonly '.tif': "image/tiff";
+        readonly '.tiff': "image/tiff";
+        readonly '.ts': "video/mp2t";
+        readonly '.ttf': "font/ttf";
+        readonly '.txt': "text/plain";
+        readonly '.vsd': "application/vnd.visio";
+        readonly '.wav': "audio/wav";
+        readonly '.weba': "audio/webm";
+        readonly '.webm': "video/webm";
+        readonly '.webp': "image/webp";
+        readonly '.woff': "font/woff";
+        readonly '.woff2': "font/woff2";
+        readonly '.xhtml': "application/xhtml+xml";
+        readonly '.xls': "application/vnd.ms-excel";
+        readonly '.xlsx': "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+        readonly '.xml': "application/xml";
+        readonly '.xul': "application/vnd.mozilla.xul+xml";
+        readonly '.zip': "application/zip";
+        readonly '.3gp': "video/3gpp";
+        readonly '.3g2': "video/3gpp2";
+        readonly '.7z': "application/x-7z-compressed";
+    };
+    type MimeTypeExt = keyof typeof mimeTypes;
+    const MimeTypesObj: {
+        readonly '.aac': "audio/aac";
+        readonly '.abw': "application/x-abiword";
+        readonly '.arc': "application/x-freearc";
+        readonly '.avi': "video/x-msvideo";
+        readonly '.azw': "application/vnd.amazon.ebook";
+        readonly '.bin': "application/octet-stream";
+        readonly '.bmp': "image/bmp";
+        readonly '.bz': "application/x-bzip";
+        readonly '.bz2': "application/x-bzip2";
+        readonly '.csh': "application/x-csh";
+        readonly '.css': "text/css";
+        readonly '.csv': "text/csv";
+        readonly '.doc': "application/msword";
+        readonly '.docx': "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+        readonly '.eot': "application/vnd.ms-fontobject";
+        readonly '.epub': "application/epub+zip";
+        readonly '.gz': "application/gzip";
+        readonly '.gif': "image/gif";
+        readonly '.htm': "text/html";
+        readonly '.html': "text/html";
+        readonly '.ico': "image/vnd.microsoft.icon";
+        readonly '.ics': "text/calendar";
+        readonly '.jar': "application/java-archive";
+        readonly '.jpeg': "image/jpeg";
+        readonly '.jpg': "image/jpeg";
+        readonly '.js': "text/javascript";
+        readonly '.json': "application/json";
+        readonly '.jsonld': "application/ld+json";
+        readonly '.mid': "application/midi";
+        readonly '.midi': "application/midi";
+        readonly '.mjs': "text/javascript";
+        readonly '.mp3': "audio/mpeg";
+        readonly '.mp4': "video/mp4";
+        readonly '.mpeg': "video/mpeg";
+        readonly '.mpkg': "application/vnd.apple.installer+xml";
+        readonly '.odp': "application/vnd.oasis.opendocument.presentation";
+        readonly '.ods': "application/vnd.oasis.opendocument.spreadsheet";
+        readonly '.odt': "application/vnd.oasis.opendocument.text";
+        readonly '.oga': "audio/ogg";
+        readonly '.ogg': "audio/ogg";
+        readonly '.ogv': "video/ogg";
+        readonly '.ogx': "application/ogg";
+        readonly '.opus': "audio/opus";
+        readonly '.otf': "font/otf";
+        readonly '.png': "image/png";
+        readonly '.pdf': "application/pdf";
+        readonly '.php': "application/php";
+        readonly '.ppt': "application/vnd.ms-powerpoint";
+        readonly '.pptx': "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+        readonly '.rar': "application/vnd.rar";
+        readonly '.rtf': "application/rtf";
+        readonly '.sh': "application/x-sh";
+        readonly '.svg': "image/svg+xml";
+        readonly '.swf': "application/x-shockwave-flash";
+        readonly '.tar': "application/x-tar";
+        readonly '.tif': "image/tiff";
+        readonly '.tiff': "image/tiff";
+        readonly '.ts': "video/mp2t";
+        readonly '.ttf': "font/ttf";
+        readonly '.txt': "text/plain";
+        readonly '.vsd': "application/vnd.visio";
+        readonly '.wav': "audio/wav";
+        readonly '.weba': "audio/webm";
+        readonly '.webm': "video/webm";
+        readonly '.webp': "image/webp";
+        readonly '.woff': "font/woff";
+        readonly '.woff2': "font/woff2";
+        readonly '.xhtml': "application/xhtml+xml";
+        readonly '.xls': "application/vnd.ms-excel";
+        readonly '.xlsx': "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+        readonly '.xml': "application/xml";
+        readonly '.xul': "application/vnd.mozilla.xul+xml";
+        readonly '.zip': "application/zip";
+        readonly '.3gp': "video/3gpp";
+        readonly '.3g2': "video/3gpp2";
+        readonly '.7z': "application/x-7z-compressed";
+    };
+    type ContentTypeKeys = keyof typeof mimeTypes;
+    type ContentType = (typeof mimeTypes)[ContentTypeKeys] | 'multipart/form-data';
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types
+     */
+    type MediaType = 'text' | 'image' | 'audio' | 'font' | 'video' | 'application' | 'multipart' | 'message' | 'model';
+    const MediaTypeAllArr: MediaType[];
+    interface UploadedBackendFile {
+        data: any | Buffer;
+        encoding: string;
+        md5: string;
+        tempFilePath: string;
+        mimetype: ContentType;
+        mv: (path: any, callback: any) => any;
+        name: string;
+        truncated: boolean;
+    }
+}