@datatruck/cli 0.30.1 → 0.32.0

package/utils/datatruck/{server.d.ts → repository-server.d.ts}

@@ -1,17 +1,16 @@
 /// <reference types="node" />
 import { IncomingMessage } from "http";
 type User = {
+    enabled?: boolean;
     name: string;
     password: string;
 };
-export type DatatruckServerOptions = {
-    path?: string;
-    log?: boolean;
+export type DatatruckRepositoryServerOptions = {
+    enabled?: boolean;
     listen?: {
         port?: number;
         address?: string;
     };
-    users?: User[];
     trustProxy?: true | {
         remoteAddressHeader: string;
     };
@@ -22,10 +21,18 @@ export type DatatruckServerOptions = {
         enabled?: boolean;
         remoteAddresses?: string[];
     };
+    backends?: {
+        name: string;
+        path: string;
+        users?: User[];
+    }[];
 };
 export declare const headerKey: {
     user: string;
     password: string;
 };
-export declare function createDatatruckServer(options: DatatruckServerOptions): import("node:http").Server<typeof IncomingMessage, typeof import("node:http").ServerResponse>;
+export declare function createDatatruckRepositoryServer(inOptions: Omit<DatatruckRepositoryServerOptions, "listen">, config?: {
+    log?: boolean;
+    configPath?: string;
+}): import("node:http").Server<typeof IncomingMessage, typeof import("node:http").ServerResponse>;
 export {};

package/utils/datatruck/{server.js → repository-server.js}

@@ -1,30 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDatatruckServer = exports.headerKey = void 0;
+exports.createDatatruckRepositoryServer = exports.headerKey = void 0;
+const ConfigAction_1 = require("../../Action/ConfigAction");
 const http_1 = require("../http");
 const virtual_fs_1 = require("../virtual-fs");
 const fs_1 = require("fs");
 const promises_1 = require("fs/promises");
 const http_2 = require("http");
-function parseUrl(inUrl) {
+exports.headerKey = {
+    user: "x-dtt-user",
+    password: "x-dtt-password",
+};
+function parseUrl(inUrl, repositoryPrefix = "repo") {
     const url = new URL(`http://127.0.0.1${inUrl}`);
     const inParams = url.searchParams.get("params");
-    const action = url.pathname.slice(1);
-    if (typeof inParams === "string") {
+    const [prefix, repository, action] = url.pathname.slice(1).split("/");
+    if (prefix !== repositoryPrefix) {
+        return { repository: undefined, action: undefined, params: [] };
+    }
+    else if (typeof inParams === "string") {
         const params = JSON.parse(inParams);
         if (!Array.isArray(params))
             throw new Error(`Invalid params`);
-        return { action, params };
+        return { repository, action, params };
     }
     else {
-        return { action, params: [] };
+        return { repository, action, params: [] };
     }
 }
-exports.headerKey = {
-    user: "x-dtt-user",
-    password: "x-dtt-password",
-};
-function validateRequest(req, options) {
+function findRepositoryBackend(req, repository, options) {
     const list = options.allowlist;
     if (list && (list.enabled ?? true) && list.remoteAddresses) {
         const remoteAddress = getRemoteAddress(req, options);
@@ -35,7 +39,15 @@ function validateRequest(req, options) {
     const password = req.headers[exports.headerKey.password]?.toString().trim();
     if (!name?.length || !password?.length)
         return;
-    return (options.users?.some((user) => user.name === name && user.password === password) || false);
+    const backend = options.backends?.find((e) => e.name === repository);
+    if (!backend)
+        return;
+    const user = backend.users?.find((user) => user.name === name && user.password === password);
+    if (!user)
+        return;
+    if (!(user.enabled ?? true))
+        return;
+    return backend;
 }
 const getRemoteAddress = (req, options) => {
     return ((options.trustProxy
@@ -44,24 +56,34 @@ const getRemoteAddress = (req, options) => {
             : req.headers[options.trustProxy.remoteAddressHeader]?.toString()
         : undefined) ?? req.socket.remoteAddress);
 };
-function createDatatruckServer(options) {
-    const log = options.log ?? true;
+function createDatatruckRepositoryServer(inOptions, config = {}) {
     return (0, http_2.createServer)(async (req, res) => {
         try {
-            if (req.url === "/" || req.url === "/favicon.ico") {
+            if (req.url === "/" || req.url === "/favicon.ico")
+                return res.end();
+            const { repository, action, params } = parseUrl(req.url);
+            if (!repository || !action) {
+                res.statusCode = 404;
                 return res.end();
             }
-            else if (!validateRequest(req, options)) {
+            const fileOptions = config.configPath
+                ? (await ConfigAction_1.ConfigAction.parseFile(config.configPath)).server?.repository
+                : undefined;
+            const options = fileOptions ?? inOptions;
+            const backend = findRepositoryBackend(req, repository, options);
+            if (!backend) {
                 res.statusCode = 401;
                 return res.end();
             }
-            if (log)
-                console.info(`> ${req.url}`);
+            if (config.log)
+                console.info(`> [repository] ${repository} - ${req.url}`);
             const fs = new virtual_fs_1.LocalFs({
-                backend: options.path ?? ".",
+                backend: backend.path,
             });
-            const { action, params } = parseUrl(req.url);
-            if (action === "upload") {
+            if (action === "comcheck") {
+                res.write(JSON.stringify({ success: true }));
+            }
+            else if (action === "upload") {
                 const [target] = params;
                 const path = fs.resolvePath(target);
                 const file = (0, fs_1.createWriteStream)(path);
@@ -99,17 +121,17 @@ function createDatatruckServer(options) {
                 if (json !== undefined)
                     res.write(JSON.stringify(json));
             }
-            if (log)
-                console.info(`<${action}`);
+            if (config.log)
+                console.info(`< [repository] ${repository} - ${action}`);
             res.end();
         }
         catch (error) {
-            if (log)
-                console.error(`<${req.url}`, error);
+            if (config.log)
+                console.error(`< [repository] ${req.url}`, error);
             res.statusCode = 500;
             res.statusMessage = error.message;
             res.end();
         }
     });
 }
-exports.createDatatruckServer = createDatatruckServer;
+exports.createDatatruckRepositoryServer = createDatatruckRepositoryServer;

package/utils/fs.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.asFile = exports.groupFiles = exports.ensureFreeDiskSpace = exports.checkFreeDiskSpace = exports.fetchDiskStats = exports.initEmptyDir = exports.tryRm = exports.safeRename = exports.fetchData = exports.countFileLines = exports.createWriteStreamPool = exports.createFileScanner = exports.createProgress = exports.cpy = exports.isNotFoundError = exports.updateFileStats = exports.copyFileWithStreams = exports.waitForClose = exports.writeGitIgnoreList = exports.fastglobToGitIgnore = exports.forEachFile = exports.readDir = exports.readPartialFile = exports.fastFolderSizeAsync = exports.findFile = exports.parsePackageFile = exports.parseFile = exports.parseFileExtensions = exports.writeJSONFile = exports.existsFile = exports.existsDir = exports.safeStat = exports.ensureExistsDir = exports.ensureSingleFile = exports.ensureEmptyDir = exports.mkdirIfNotExists = exports.isLocalDir = exports.isEmptyDir = exports.isWSLSystem = void 0;
+const pkg_1 = require("../pkg");
 const bytes_1 = require("./bytes");
 const math_1 = require("./math");
-const path_1 = require("./path");
 const string_1 = require("./string");
 const temp_1 = require("./temp");
 const async_1 = require("async");
@@ -16,8 +16,8 @@ const fs_1 = require("fs");
 const fs_2 = require("fs");
 const promises_1 = require("fs/promises");
 const os_1 = require("os");
+const path_1 = require("path");
 const path_2 = require("path");
-const path_3 = require("path");
 const readline_1 = require("readline");
 const util_1 = require("util");
 exports.isWSLSystem = (0, os_1.release)().includes("microsoft-standard-WSL");
@@ -59,12 +59,12 @@ async function ensureSingleFile(path) {
     if (files.length !== 1)
         throw new Error(`Dir has not one file: ${files.length}`);
     const [file] = files;
-    return (0, path_2.join)(path, file);
+    return (0, path_1.join)(path, file);
 }
 exports.ensureSingleFile = ensureSingleFile;
 async function ensureExistsDir(path) {
     if (!(await existsDir(path)))
-        throw new Error(`Dir is not crated: ${path}`);
+        throw new Error(`Dir is not created: ${path}`);
 }
 exports.ensureExistsDir = ensureExistsDir;
 async function safeStat(path) {
@@ -88,10 +88,11 @@ async function writeJSONFile(path, json) {
 exports.writeJSONFile = writeJSONFile;
 exports.parseFileExtensions = ["json", "js", "ts", "yaml", "yml"];
 async function parseFile(path, jsKey) {
-    if (!(0, path_3.isAbsolute)(path))
-        path = (0, path_2.join)(process.cwd(), path);
+    if (!(0, path_2.isAbsolute)(path))
+        path = (0, path_1.join)(process.cwd(), path);
+    const $require = require;
     if (path.endsWith(".ts"))
-        require("ts-node").register();
+        $require("ts-node").register();
     if (path.endsWith(".yaml") || path.endsWith("yml")) {
         const contents = await (0, promises_1.readFile)(path);
         return require("yaml").parse(contents.toString());
@@ -107,7 +108,7 @@ async function parseFile(path, jsKey) {
 }
 exports.parseFile = parseFile;
 function parsePackageFile() {
-    return require(`${path_1.rootPath}/package.json`);
+    return pkg_1.pkg;
 }
 exports.parsePackageFile = parsePackageFile;
 async function findFile(sourcePath, baseName, extensions, errorMessage = "Path not found") {
@@ -115,7 +116,7 @@ async function findFile(sourcePath, baseName, extensions, errorMessage = "Path n
     let path;
     if (info.isDirectory()) {
         for (const ext of extensions) {
-            const extPath = (0, path_2.join)(sourcePath, baseName) + "." + ext;
+            const extPath = (0, path_1.join)(sourcePath, baseName) + "." + ext;
             if (await existsFile(extPath)) {
                 path = extPath;
                 break;
@@ -183,7 +184,7 @@ exports.readDir = readDir;
 async function forEachFile(dirPath, cb, includeDir) {
     const files = await readDir(dirPath);
     for (const file of files) {
-        const filePath = (0, path_2.join)(dirPath, file);
+        const filePath = (0, path_1.join)(dirPath, file);
         if ((await (0, promises_1.stat)(filePath)).isDirectory()) {
             if (includeDir)
                 cb(filePath, true);
@@ -206,12 +207,12 @@ function fastglobToGitIgnore(patterns, baseDir) {
 exports.fastglobToGitIgnore = fastglobToGitIgnore;
 async function writeGitIgnoreList(options) {
     const { outDir } = options;
-    const path = (0, path_2.join)(outDir, `.gitignore`);
+    const path = (0, path_1.join)(outDir, `.gitignore`);
     const stream = (0, fs_2.createWriteStream)(path);
     const dirs = new Set();
     stream.write("*\n");
     for await (const value of options.paths) {
-        const dir = (0, path_2.dirname)(value.toString());
+        const dir = (0, path_1.dirname)(value.toString());
         if (dir !== ".") {
             let parentPath;
             for (const value of dir.split("/")) {
@@ -290,9 +291,9 @@ async function cpy(options) {
     const task = async (rawEntryPath, basePath) => {
         [rawEntryPath] = rawEntryPath.split(":");
         const isDir = rawEntryPath.endsWith("/");
-        const entryPath = (0, path_2.normalize)(rawEntryPath);
-        const entrySourcePath = (0, path_2.resolve)((0, path_2.join)(basePath, rawEntryPath));
-        const entryTargetPath = (0, path_2.resolve)((0, path_2.join)(options.outPath, rawEntryPath));
+        const entryPath = (0, path_1.normalize)(rawEntryPath);
+        const entrySourcePath = (0, path_1.resolve)((0, path_1.join)(basePath, rawEntryPath));
+        const entryTargetPath = (0, path_1.resolve)((0, path_1.join)(options.outPath, rawEntryPath));
         const onPathResult = await options?.onPath?.({
             isDir,
             entryPath,
@@ -307,7 +308,7 @@ async function cpy(options) {
             await makeRecursiveDir(entryTargetPath);
         }
         else {
-            const dir = (0, path_2.dirname)(entryTargetPath);
+            const dir = (0, path_1.dirname)(entryTargetPath);
             await makeRecursiveDir(dir);
             await options.onProgress?.({
                 current: stats.files,
@@ -447,7 +448,7 @@ function createWriteStreamPool(options) {
         const item = {
             key,
             lines: 0,
-            stream: (0, fs_2.createWriteStream)((0, path_2.join)(options.path, options.onStreamPath ? options.onStreamPath(key) : key)),
+            stream: (0, fs_2.createWriteStream)((0, path_1.join)(options.path, options.onStreamPath ? options.onStreamPath(key) : key)),
             finished: false,
         };
         item.stream
@@ -612,7 +613,7 @@ exports.groupFiles = groupFiles;
 async function asFile(input) {
     if (typeof input === "string") {
         const dir = await (0, temp_1.mkTmpDir)("text-as-file");
-        const path = (0, path_2.join)(dir, "contents.txt");
+        const path = (0, path_1.join)(dir, "contents.txt");
         await (0, promises_1.writeFile)(path, input);
         return [
             path,

package/utils/http.d.ts

@@ -3,10 +3,16 @@ import { BasicProgress } from "./progress";
 import { IncomingMessage, Server } from "http";
 export declare function closeServer(server: Server): Promise<void>;
 export declare function readRequestData(req: IncomingMessage): Promise<string | undefined>;
-export declare function fetchJson<T = any>(url: string, options?: {
+export type FetchOptions = {
     headers?: Record<string, string>;
     query?: Record<string, string>;
-}): Promise<T>;
+    statusError?: boolean;
+};
+export declare function fetch(url: string, options?: FetchOptions): Promise<{
+    data: string | undefined;
+    status: number | undefined;
+}>;
+export declare function fetchJson<T = any>(url: string, options?: FetchOptions): Promise<T | undefined>;
 export declare function post(url: string, data: string, options?: {
     headers?: Record<string, string>;
     query?: Record<string, string>;

package/utils/http.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadFile = exports.downloadFile = exports.post = exports.fetchJson = exports.readRequestData = exports.closeServer = void 0;
+exports.uploadFile = exports.downloadFile = exports.post = exports.fetchJson = exports.fetch = exports.readRequestData = exports.closeServer = void 0;
 const math_1 = require("./math");
 const fs_1 = require("fs");
 const promises_1 = require("fs/promises");
@@ -37,14 +37,15 @@ function readRequestData(req) {
     });
 }
 exports.readRequestData = readRequestData;
-async function fetchJson(url, options = {}) {
+async function fetch(url, options = {}) {
+    const throwStatusCodeError = options.statusError ?? true;
     return new Promise((resolve, reject) => {
         let data;
         request(href(url, options.query), {
             method: "GET",
             headers: options.headers,
         }, (res) => {
-            if (res.statusCode !== 200)
+            if (throwStatusCodeError && res.statusCode !== 200)
                 return reject(new Error(`GET failed: ${res.statusCode} ${res.statusMessage}`));
             res
                 .on("data", (chunk) => {
@@ -54,23 +55,20 @@ async function fetchJson(url, options = {}) {
             })
                 .on("error", reject)
                 .on("close", () => {
-                if (data === undefined) {
-                    resolve(undefined);
-                }
-                else {
-                    try {
-                        resolve(JSON.parse(data));
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                }
+                resolve({ data, status: res.statusCode });
             });
         })
             .on("error", reject)
             .end();
     });
 }
+exports.fetch = fetch;
+async function fetchJson(url, options = {}) {
+    const res = await fetch(url, options);
+    if (res.data === undefined)
+        return;
+    return JSON.parse(res.data);
+}
 exports.fetchJson = fetchJson;
 async function post(url, data, options = {}) {
     await new Promise((resolve, reject) => {

package/utils/object.d.ts

@@ -1,5 +1,5 @@
 export declare function merge<T extends Record<string, unknown>>(target: T, ...sources: Record<string, unknown>[]): T;
-export declare function push<T>(map: Record<string, T[]>, key: string, object: T): void;
+export declare function omitProp<T extends Record<string, any>, N extends keyof T>(object: T, name: N): Omit<T, N>;
 export declare function getErrorProperties(error: Error): Record<string, string>;
 type GroupByKeyParamType<TItem> = ((item: TItem) => string[] | string) | (keyof TItem)[] | keyof TItem;
 export declare function groupBy<TItem>(items: TItem[], keyOrCb: GroupByKeyParamType<TItem>): Record<string, TItem[]>;

package/utils/object.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupBy = exports.getErrorProperties = exports.push = exports.merge = void 0;
+exports.groupBy = exports.getErrorProperties = exports.omitProp = exports.merge = void 0;
 function merge(target, ...sources) {
     const isObject = (o) => typeof o === "object" && o !== null;
     for (const source of sources)
@@ -13,12 +13,12 @@ function merge(target, ...sources) {
     return target;
 }
 exports.merge = merge;
-function push(map, key, object) {
-    if (!map[key])
-        map[key] = [];
-    map[key].push(object);
+function omitProp(object, name) {
+    const result = { ...object };
+    delete result[name];
+    return result;
 }
-exports.push = push;
+exports.omitProp = omitProp;
 function getErrorProperties(error) {
     const alt = {};
     for (const key of Object.getOwnPropertyNames(error)) {

package/utils/schema.d.ts

@@ -0,0 +1,34 @@
+import { JSONSchema7 } from "json-schema";
+export declare function omitPropertySchema<T extends {
+    properties: Record<string, any>;
+}, N extends keyof T["properties"]>(object: T, name: N): Omit<T, "properties"> & {
+    properties: Omit<T["properties"], N>;
+};
+type IfSchema<KType extends string, KValue extends string, T extends string, V extends JSONSchema7> = {
+    if: {
+        type: "object";
+        properties: {
+            [k in KType]: {
+                const: T;
+            };
+        };
+    };
+    then: {
+        type: "object";
+        properties: {
+            [k in KValue]: V;
+        };
+    };
+    else: false;
+};
+export declare function createCaseSchema<KType extends string, KValue extends string, V extends {
+    [K in KType]: JSONSchema7;
+}>(keys: {
+    type: KType;
+    value: KValue;
+}, value: V): IfSchema<KType, KValue, string, JSONSchema7>[];
+export declare function createIfSchema<KType extends string, KValue extends string, T extends string, V extends JSONSchema7>(keys: {
+    type: KType;
+    value: KValue;
+}, type: T, value: V): IfSchema<KType, KValue, T, V>;
+export {};

package/utils/schema.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIfSchema = exports.createCaseSchema = exports.omitPropertySchema = void 0;
+const object_1 = require("./object");
+function omitPropertySchema(object, name) {
+    return {
+        ...object,
+        properties: (0, object_1.omitProp)(object.properties, name),
+    };
+}
+exports.omitPropertySchema = omitPropertySchema;
+function createCaseSchema(keys, value) {
+    return Object.entries(value).reduce((schemas, [type, value]) => {
+        schemas.push(createIfSchema(keys, type, value));
+        return schemas;
+    }, []);
+}
+exports.createCaseSchema = createCaseSchema;
+function createIfSchema(keys, type, value) {
+    return {
+        if: {
+            type: "object",
+            properties: {
+                [keys.type]: { const: type },
+            },
+        },
+        then: {
+            type: "object",
+            properties: {
+                [keys.value]: value,
+            },
+        },
+        else: false,
+    };
+}
+exports.createIfSchema = createIfSchema;

package/utils/steps.d.ts

@@ -14,6 +14,11 @@ export type TelegramMessageStepConfig = {
     chatId: number;
     text?: string;
 };
+export type NtfyStepConfig = {
+    token: string;
+    topic?: string;
+    text?: string;
+};
 export type Step = {
     type: "process";
     config: ProcessStepConfig;
@@ -23,20 +28,15 @@ export type Step = {
 } | {
     type: "telegram-message";
     config: TelegramMessageStepConfig;
+} | {
+    type: "ntfy";
+    config: NtfyStepConfig;
 };
 export type StepOptions = {
     env?: Record<string, string | undefined>;
-    process?: {
-        vars?: Record<string, string | undefined>;
-    };
-    node?: {
-        vars?: Record<string, any>;
-        tempDir?: () => Promise<string>;
-    };
-    telegram?: {
-        vars?: Record<string, string>;
-    };
+    vars?: Record<string, any>;
     cwd?: string;
+    tempDir?: () => Promise<string>;
     onLine?: (p: string) => any;
     verbose?: boolean;
 };

package/utils/steps.js

@@ -9,9 +9,10 @@ const promises_1 = require("fs/promises");
 const path_1 = require("path");
 async function runSteps(input, options) {
     const steps = Array.isArray(input) ? input : [input];
+    const vars = options?.vars || {};
     for (const step of steps) {
         if (step.type === "process") {
-            await (0, process_1.exec)(step.config.command, (step.config.args || []).map((v) => (0, string_1.render)(v, options.process?.vars || {})), {
+            await (0, process_1.exec)(step.config.command, (step.config.args || []).map((v) => (0, string_1.render)(v, vars)), {
                 cwd: options.cwd,
                 env: {
                     ...process.env,
@@ -30,19 +31,19 @@ async function runSteps(input, options) {
         }
         else if (step.type === "node") {
             let tempDir;
-            if (options.node?.tempDir) {
-                tempDir = await options.node.tempDir();
+            if (options?.tempDir) {
+                tempDir = await options.tempDir();
             }
             else {
                 tempDir = await (0, temp_1.mkTmpDir)("node-step");
             }
             const scriptPath = (0, path_1.join)(tempDir, "script.js");
-            const vars = {
+            const nodeVars = {
                 ...step.config.vars,
-                ...options.node?.vars,
+                ...vars,
             };
-            const varKeys = Object.keys(vars);
-            const varJson = JSON.stringify(vars);
+            const varKeys = Object.keys(nodeVars);
+            const varJson = JSON.stringify(nodeVars);
             const code = Array.isArray(step.config.code)
                 ? [...step.config.code].join(";\n")
                 : step.config.code;
@@ -67,7 +68,7 @@ async function runSteps(input, options) {
         else if (step.type === "telegram-message") {
             await (0, http_1.post)(`https://api.telegram.org/bot${step.config.bot}/sendMessage`, JSON.stringify({
                 chat_id: step.config.chatId.toString(),
-                text: (0, string_1.render)(step.config.text ?? `{TEXT}`, options.telegram?.vars || {}),
+                text: (0, string_1.render)(step.config.text ?? `{dtt.text}`, vars),
                 disable_notification: true,
             }), {
                 headers: {
@@ -75,6 +76,19 @@ async function runSteps(input, options) {
                 },
             });
         }
+        else if (step.type === "ntfy") {
+            const topic = [step.config.token, step.config.topic]
+                .filter(Boolean)
+                .join("-");
+            if (topic.length < 32)
+                throw new Error(`Topic is less than 32 characters: ${topic}`);
+            await (0, http_1.post)(`https://ntfy.sh/${topic}`, (0, string_1.render)(step.config.text ?? `{dtt.text}`, vars), {
+                headers: {
+                    Title: (0, string_1.render)("{dtt.title}", vars),
+                    Priority: vars.success ? "default" : "high",
+                },
+            });
+        }
         else {
             throw new Error(`Invalid step type: ${step.type}`);
         }

package/utils/string.d.ts

@@ -1,4 +1,3 @@
-export declare function serialize(message: string, data?: Object): string;
 export declare function snakeCase(value: string, char?: string): string;
 export declare function render(subject: string, vars: Record<string, string | undefined>): string;
 type NoInfer<T> = [T][T extends any ? 0 : never];
@@ -12,12 +11,10 @@ export type UriType = {
     path?: string;
 };
 export declare function formatUri(input: UriType, hidePassword?: boolean): string;
-export declare function formatSeconds(seconds: number): string;
 export declare function makePathPatterns(values: string[] | undefined): string[] | undefined;
 export declare function match(path: string, include?: string[], exclude?: string[]): boolean;
 export declare function endsWith(input: string, patterns: string[]): boolean;
 export declare function createMatchFilter(include?: string[], exclude?: string[]): (input: string) => boolean;
 export declare function checkMatch(subject: string | undefined, patterns: string[]): boolean;
-export declare function formatDateTime(datetime: string): string;
 export declare function undefIfEmpty(input: string): string | undefined;
 export {};