inibase 1.0.0-rc.12 → 1.0.0-rc.15

package/dist/file.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { ComparisonOperator, FieldType } from ".";
+export declare const isExists: (path: string) => Promise<boolean>;
+export declare const encode: (input: string | number | boolean | null | (string | number | boolean | null)[], secretKey?: string | Buffer) => string | number | boolean;
+export declare const decode: (input: string | null | number, fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], secretKey?: string | Buffer) => string | number | boolean | null | (string | number | null | boolean)[];
+export declare const get: (filePath: string, lineNumbers?: number | number[], fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], secretKey?: string | Buffer) => Promise<[
+    Record<number, string | number | boolean | (string | number | boolean | (string | number | boolean)[])[]> | null,
+    number
+]>;
+export declare const replace: (filePath: string, replacements: string | number | boolean | null | (string | number | boolean | null)[] | Record<number, string | boolean | number | null | (string | boolean | number | null)[]>, secretKey?: string | Buffer) => Promise<void>;
+export declare const remove: (filePath: string, linesToDelete: number | number[]) => Promise<void>;
+export declare const count: (filePath: string) => Promise<number>;
+export declare const search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | null | (string | number | boolean | null)[], logicalOperator?: "and" | "or", fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], limit?: number, offset?: number, readWholeFile?: boolean, secretKey?: string | Buffer) => Promise<[
+    Record<number, Record<string, string | number | boolean | (string | number | boolean | null)[] | null>> | null,
+    number
+]>;
+export declare const sum: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
+export declare const max: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
+export declare const min: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
+export declare const sort: (filePath: string, sortDirection: 1 | -1 | "asc" | "desc", lineNumbers?: number | number[], _lineNumbersPerChunk?: number) => Promise<void>;
+export default class File {
+    static get: (filePath: string, lineNumbers?: number | number[], fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], secretKey?: string | Buffer) => Promise<[Record<number, string | number | boolean | (string | number | boolean | (string | number | boolean)[])[]>, number]>;
+    static remove: (filePath: string, linesToDelete: number | number[]) => Promise<void>;
+    static search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | (string | number | boolean)[], logicalOperator?: "and" | "or", fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], limit?: number, offset?: number, readWholeFile?: boolean, secretKey?: string | Buffer) => Promise<[Record<number, Record<string, string | number | boolean | (string | number | boolean)[]>>, number]>;
+    static replace: (filePath: string, replacements: string | number | boolean | (string | number | boolean)[] | Record<number, string | number | boolean | (string | number | boolean)[]>, secretKey?: string | Buffer) => Promise<void>;
+    static count: (filePath: string) => Promise<number>;
+    static encode: (input: string | number | boolean | (string | number | boolean)[], secretKey?: string | Buffer) => string | number | boolean;
+    static decode: (input: string | number, fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], secretKey?: string | Buffer) => string | number | boolean | (string | number | boolean)[];
+    static isExists: (path: string) => Promise<boolean>;
+    static sum: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
+    static min: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
+    static max: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
+}

package/dist/file.js

@@ -0,0 +1,501 @@
+import { open, rename, stat, writeFile, } from "node:fs/promises";
+import { createInterface } from "node:readline";
+import { parse } from "node:path";
+import { detectFieldType, isArrayOfArrays, isNumber, encodeID, comparePassword, } from "./utils";
+const doesSupportReadLines = () => {
+    const [major, minor, patch] = process.versions.node.split(".").map(Number);
+    return major > 18 || (major === 18 && minor >= 11);
+};
+export const isExists = async (path) => {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const delimiters = [",", "|", "&", "$", "#", "@", "^", "%", ":", "!", ";"];
+export const encode = (input, secretKey) => {
+    const secureString = (input) => {
+        if (["true", "false"].includes(String(input)))
+            return input ? 1 : 0;
+        return typeof input === "string"
+            ? decodeURIComponent(input)
+                .replaceAll("<", "&lt;")
+                .replaceAll(">", "&gt;")
+                .replaceAll(",", "%2C")
+                .replaceAll("|", "%7C")
+                .replaceAll("&", "%26")
+                .replaceAll("$", "%24")
+                .replaceAll("#", "%23")
+                .replaceAll("@", "%40")
+                .replaceAll("^", "%5E")
+                .replaceAll("%", "%25")
+                .replaceAll(":", "%3A")
+                .replaceAll("!", "%21")
+                .replaceAll(";", "%3B")
+                .replaceAll("\n", "\\n")
+                .replaceAll("\r", "\\r")
+            : input;
+    }, secureArray = (arr_str) => Array.isArray(arr_str) ? arr_str.map(secureArray) : secureString(arr_str), joinMultidimensionalArray = (arr, delimiter_index = 0) => {
+        delimiter_index++;
+        if (isArrayOfArrays(arr))
+            arr = arr.map((ar) => joinMultidimensionalArray(ar, delimiter_index));
+        delimiter_index--;
+        return arr.join(delimiters[delimiter_index]);
+    };
+    return Array.isArray(input)
+        ? joinMultidimensionalArray(secureArray(input))
+        : secureString(input);
+};
+export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
+    if (!fieldType)
+        return null;
+    const unSecureString = (input) => decodeURIComponent(input)
+        .replaceAll("&lt;", "<")
+        .replaceAll("&gt;", ">")
+        .replaceAll("%2C", ",")
+        .replaceAll("%7C", "|")
+        .replaceAll("%26", "&")
+        .replaceAll("%24", "$")
+        .replaceAll("%23", "#")
+        .replaceAll("%40", "@")
+        .replaceAll("%5E", "^")
+        .replaceAll("%25", "%")
+        .replaceAll("%3A", ":")
+        .replaceAll("%21", "!")
+        .replaceAll("%3B", ";")
+        .replaceAll("\\n", "\n")
+        .replaceAll("\\r", "\r") || null, unSecureArray = (arr_str) => Array.isArray(arr_str)
+        ? arr_str.map(unSecureArray)
+        : unSecureString(arr_str), reverseJoinMultidimensionalArray = (joinedString) => {
+        const reverseJoinMultidimensionalArrayHelper = (arr, delimiter) => Array.isArray(arr)
+            ? arr.map((ar) => reverseJoinMultidimensionalArrayHelper(ar, delimiter))
+            : arr.split(delimiter);
+        const availableDelimiters = delimiters.filter((delimiter) => joinedString.includes(delimiter));
+        for (const delimiter of availableDelimiters) {
+            joinedString = Array.isArray(joinedString)
+                ? reverseJoinMultidimensionalArrayHelper(joinedString, delimiter)
+                : joinedString.split(delimiter);
+        }
+        return joinedString;
+    }, decodeHelper = (value) => {
+        if (Array.isArray(value) && fieldType !== "array")
+            return value.map(decodeHelper);
+        switch (fieldType) {
+            case "table":
+            case "number":
+                return isNumber(value) ? Number(value) : null;
+            case "boolean":
+                return typeof value === "string" ? value === "true" : Boolean(value);
+            case "array":
+                if (!Array.isArray(value))
+                    return [value];
+                if (fieldChildrenType)
+                    return value.map((v) => decode(v, Array.isArray(fieldChildrenType)
+                        ? detectFieldType(v, fieldChildrenType)
+                        : fieldChildrenType, undefined, secretKey));
+                else
+                    return value;
+            case "id":
+                return isNumber(value) ? encodeID(value, secretKey) : value;
+            default:
+                return value;
+        }
+    };
+    if (input === null || input === "")
+        return null;
+    if (Array.isArray(fieldType))
+        fieldType = detectFieldType(String(input), fieldType);
+    return decodeHelper(typeof input === "string"
+        ? input.includes(",")
+            ? unSecureArray(reverseJoinMultidimensionalArray(input))
+            : unSecureString(input)
+        : input);
+};
+export const get = async (filePath, lineNumbers, fieldType, fieldChildrenType, secretKey) => {
+    let fileHandle;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            });
+        let lines = {}, lineCount = 0;
+        if (!lineNumbers) {
+            for await (const line of rl)
+                lineCount++,
+                    (lines[lineCount] = decode(line, fieldType, fieldChildrenType, secretKey));
+        }
+        else if (lineNumbers === -1) {
+            let lastLine;
+            for await (const line of rl)
+                lineCount++, (lastLine = line);
+            if (lastLine)
+                lines = {
+                    [lineCount]: decode(lastLine, fieldType, fieldChildrenType, secretKey),
+                };
+        }
+        else {
+            let lineNumbersArray = [
+                ...(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]),
+            ];
+            for await (const line of rl) {
+                lineCount++;
+                if (!lineNumbersArray.includes(lineCount))
+                    continue;
+                lines[lineCount] = decode(line, fieldType, fieldChildrenType, secretKey);
+                lineNumbersArray[lineNumbersArray.indexOf(lineCount)] = 0;
+                if (!lineNumbersArray.filter((lineN) => lineN !== 0).length)
+                    break;
+            }
+        }
+        return [lines ?? null, lineCount];
+    }
+    finally {
+        await fileHandle?.close();
+    }
+};
+export const replace = async (filePath, replacements, secretKey) => {
+    if (await isExists(filePath)) {
+        const tempFilePath = `${filePath.replace(".inib", "")}-${Date.now()}.tmp`;
+        let fileHandle, tempFileHandle;
+        try {
+            fileHandle = await open(filePath, "r");
+            tempFileHandle = await open(tempFilePath, "w");
+            const rl = doesSupportReadLines()
+                ? fileHandle.readLines()
+                : createInterface({
+                    input: fileHandle.createReadStream(),
+                    crlfDelay: Infinity,
+                }), writeStream = tempFileHandle.createWriteStream();
+            if (typeof replacements === "object" && !Array.isArray(replacements)) {
+                let lineCount = 0;
+                for await (const line of rl) {
+                    lineCount++;
+                    writeStream.write((lineCount in replacements
+                        ? encode(replacements[lineCount], secretKey)
+                        : line) + "\n");
+                }
+                const newLinesNumber = Object.keys(replacements)
+                    .map(Number)
+                    .filter((num) => num > lineCount);
+                if (newLinesNumber.length) {
+                    if (Math.min(...newLinesNumber) - lineCount - 1 > 1)
+                        writeStream.write("\n".repeat(Math.min(...newLinesNumber) - lineCount - 1));
+                    for (var i = 0, n = newLinesNumber.length; i < n; ++i)
+                        writeStream.write(encode(replacements[i], secretKey) + "\n");
+                }
+            }
+            else
+                for await (const _line of rl)
+                    writeStream.write(encode(replacements, secretKey) + "\n");
+            writeStream.end(async () => await rename(tempFilePath, filePath)); // Rename the temp file to the original file name
+        }
+        finally {
+            await fileHandle?.close();
+            await tempFileHandle?.close();
+        }
+    }
+    else if (typeof replacements === "object" && !Array.isArray(replacements)) {
+        await writeFile(filePath, Object.keys(replacements)
+            .map(Number)
+            .sort((a, b) => a - b)
+            .map((num) => replacements[num])
+            .join("\n") + "\n");
+    }
+};
+export const remove = async (filePath, linesToDelete) => {
+    let lineCount = 0;
+    const tempFilePath = `${filePath.replace(".inib", "")}-${Date.now()}.tmp`, linesToDeleteArray = [
+        ...(Array.isArray(linesToDelete) ? linesToDelete : [linesToDelete]),
+    ];
+    let fileHandle, tempFileHandle;
+    try {
+        fileHandle = await open(filePath, "r");
+        tempFileHandle = await open(tempFilePath, "w");
+        const rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            }), writeStream = tempFileHandle.createWriteStream();
+        for await (const line of rl) {
+            lineCount++;
+            if (!linesToDeleteArray.includes(lineCount)) {
+                writeStream.write(`${line}\n`);
+            }
+        }
+        writeStream.end(async () => await rename(tempFilePath, filePath)); // Rename the temp file to the original file name
+    }
+    finally {
+        await fileHandle?.close();
+        await tempFileHandle?.close();
+    }
+};
+export const count = async (filePath) => {
+    let lineCount = 0;
+    let fileHandle;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            });
+        for await (const line of rl)
+            lineCount++;
+        return lineCount;
+    }
+    finally {
+        await fileHandle?.close();
+    }
+};
+export const search = async (filePath, operator, comparedAtValue, logicalOperator, fieldType, fieldChildrenType, limit, offset, readWholeFile, secretKey) => {
+    const handleComparisonOperator = (operator, originalValue, comparedAtValue, fieldType, fieldChildrenType) => {
+        if (Array.isArray(fieldType))
+            fieldType = detectFieldType(String(originalValue), fieldType);
+        if (Array.isArray(comparedAtValue) && !["[]", "![]"].includes(operator))
+            return comparedAtValue.some((comparedAtValueSingle) => handleComparisonOperator(operator, originalValue, comparedAtValueSingle, fieldType));
+        // check if not array or object // it can't be array or object!
+        switch (operator) {
+            case "=":
+                switch (fieldType) {
+                    case "password":
+                        return typeof originalValue === "string" &&
+                            typeof comparedAtValue === "string"
+                            ? comparePassword(originalValue, comparedAtValue)
+                            : false;
+                    case "boolean":
+                        return Number(originalValue) - Number(comparedAtValue) === 0;
+                    default:
+                        return originalValue === comparedAtValue;
+                }
+            case "!=":
+                return !handleComparisonOperator("=", originalValue, comparedAtValue, fieldType);
+            case ">":
+                return originalValue > comparedAtValue;
+            case "<":
+                return originalValue < comparedAtValue;
+            case ">=":
+                return originalValue >= comparedAtValue;
+            case "<=":
+                return originalValue <= comparedAtValue;
+            case "[]":
+                return ((Array.isArray(originalValue) &&
+                    Array.isArray(comparedAtValue) &&
+                    originalValue.some(comparedAtValue.includes)) ||
+                    (Array.isArray(originalValue) &&
+                        !Array.isArray(comparedAtValue) &&
+                        originalValue.includes(comparedAtValue)) ||
+                    (!Array.isArray(originalValue) &&
+                        Array.isArray(comparedAtValue) &&
+                        comparedAtValue.includes(originalValue)));
+            case "![]":
+                return !handleComparisonOperator("[]", originalValue, comparedAtValue, fieldType);
+            case "*":
+                return new RegExp(`^${(String(comparedAtValue).includes("%")
+                    ? String(comparedAtValue)
+                    : "%" + String(comparedAtValue) + "%").replace(/%/g, ".*")}$`, "i").test(String(originalValue));
+            case "!*":
+                return !handleComparisonOperator("*", originalValue, comparedAtValue, fieldType);
+            default:
+                throw new Error(operator);
+        }
+    };
+    let RETURN = {}, lineCount = 0, foundItems = 0;
+    let fileHandle;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            });
+        const columnName = parse(filePath).name;
+        for await (const line of rl) {
+            lineCount++;
+            const decodedLine = decode(line, fieldType, fieldChildrenType, secretKey);
+            if ((Array.isArray(operator) &&
+                Array.isArray(comparedAtValue) &&
+                ((logicalOperator &&
+                    logicalOperator === "or" &&
+                    operator.some((single_operator, index) => handleComparisonOperator(single_operator, decodedLine, comparedAtValue[index], fieldType))) ||
+                    operator.every((single_operator, index) => handleComparisonOperator(single_operator, decodedLine, comparedAtValue[index], fieldType)))) ||
+                (!Array.isArray(operator) &&
+                    handleComparisonOperator(operator, decodedLine, comparedAtValue, fieldType))) {
+                foundItems++;
+                if (offset && foundItems < offset)
+                    continue;
+                if (limit && foundItems > limit)
+                    if (readWholeFile)
+                        continue;
+                    else
+                        break;
+                if (!RETURN[lineCount])
+                    RETURN[lineCount] = {};
+                RETURN[lineCount][columnName] = decodedLine;
+            }
+        }
+        if (foundItems) {
+            return [RETURN, readWholeFile ? foundItems : foundItems - 1];
+        }
+        else
+            return [null, 0];
+    }
+    finally {
+        await fileHandle?.close();
+    }
+};
+export const sum = async (filePath, lineNumbers) => {
+    let fileHandle;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            });
+        let sum = 0;
+        if (lineNumbers) {
+            let lineCount = 0;
+            let lineNumbersArray = [
+                ...(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]),
+            ];
+            for await (const line of rl) {
+                lineCount++;
+                if (!lineNumbersArray.includes(lineCount))
+                    continue;
+                sum += +decode(line, "number");
+                lineNumbersArray[lineNumbersArray.indexOf(lineCount)] = 0;
+                if (!lineNumbersArray.filter((lineN) => lineN !== 0).length)
+                    break;
+            }
+        }
+        else
+            for await (const line of rl)
+                sum += +decode(line, "number");
+        return sum;
+    }
+    finally {
+        await fileHandle?.close();
+    }
+};
+export const max = async (filePath, lineNumbers) => {
+    let fileHandle;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            });
+        let max = 0;
+        if (lineNumbers) {
+            let lineCount = 0;
+            let lineNumbersArray = [
+                ...(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]),
+            ];
+            for await (const line of rl) {
+                lineCount++;
+                if (!lineNumbersArray.includes(lineCount))
+                    continue;
+                const lineContentNum = +decode(line, "number");
+                if (lineContentNum > max)
+                    max = lineContentNum;
+                lineNumbersArray[lineNumbersArray.indexOf(lineCount)] = 0;
+                if (!lineNumbersArray.filter((lineN) => lineN !== 0).length)
+                    break;
+            }
+        }
+        else
+            for await (const line of rl) {
+                const lineContentNum = +decode(line, "number");
+                if (lineContentNum > max)
+                    max = lineContentNum;
+            }
+        return max;
+    }
+    finally {
+        await fileHandle?.close();
+    }
+};
+export const min = async (filePath, lineNumbers) => {
+    let fileHandle;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            });
+        let min = 0;
+        if (lineNumbers) {
+            let lineCount = 0;
+            let lineNumbersArray = [
+                ...(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]),
+            ];
+            for await (const line of rl) {
+                lineCount++;
+                if (!lineNumbersArray.includes(lineCount))
+                    continue;
+                const lineContentNum = +decode(line, "number");
+                if (lineContentNum < min)
+                    min = lineContentNum;
+                lineNumbersArray[lineNumbersArray.indexOf(lineCount)] = 0;
+                if (!lineNumbersArray.filter((lineN) => lineN !== 0).length)
+                    break;
+            }
+        }
+        else
+            for await (const line of rl) {
+                const lineContentNum = +decode(line, "number");
+                if (lineContentNum < min)
+                    min = lineContentNum;
+            }
+        return min;
+    }
+    finally {
+        await fileHandle?.close();
+    }
+};
+export const sort = async (filePath, sortDirection, lineNumbers, _lineNumbersPerChunk = 100000) => {
+    let fileHandle;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            });
+        let lineCount = 0;
+        for await (const line of rl) {
+            lineCount++;
+        }
+    }
+    finally {
+        await fileHandle?.close();
+    }
+};
+export default class File {
+    static get = get;
+    static remove = remove;
+    static search = search;
+    static replace = replace;
+    static count = count;
+    static encode = encode;
+    static decode = decode;
+    static isExists = isExists;
+    static sum = sum;
+    static min = min;
+    static max = max;
+}

package/dist/index.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" />
+export interface Data {
+    id?: number | string;
+    [key: string]: any;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+export type FieldType = "string" | "number" | "boolean" | "date" | "email" | "url" | "table" | "object" | "array" | "password" | "html" | "ip" | "id";
+type FieldDefault = {
+    id?: string | number | null | undefined;
+    key: string;
+    required?: boolean;
+    children?: any;
+};
+type FieldStringType = {
+    type: Exclude<FieldType, "array" | "object">;
+};
+type FieldStringArrayType = {
+    type: Exclude<FieldType, "array" | "object">[];
+};
+type FieldArrayType = {
+    type: "array";
+    children: FieldType | FieldType[] | Schema;
+};
+type FieldArrayArrayType = {
+    type: ["array", ...FieldType[]];
+    children: FieldType | FieldType[];
+};
+type FieldObjectType = {
+    type: "object";
+    children: Schema;
+};
+export type Field = FieldDefault & (FieldStringType | FieldStringArrayType | FieldObjectType | FieldArrayType | FieldArrayArrayType);
+export type Schema = Field[];
+export interface Options {
+    page?: number;
+    per_page?: number;
+    columns?: string[] | string;
+    order?: Record<string, "asc" | "desc">;
+}
+export type ComparisonOperator = "=" | "!=" | ">" | "<" | ">=" | "<=" | "*" | "!*" | "[]" | "![]";
+type pageInfo = {
+    total?: number;
+    total_pages?: number;
+} & Options;
+export type Criteria = ({
+    [logic in "and" | "or"]?: Criteria | (string | number | boolean | null)[];
+} & {
+    [key: string]: string | number | boolean | Criteria;
+}) | null;
+declare global {
+    type Entries<T> = {
+        [K in keyof T]: [K, T[K]];
+    }[keyof T][];
+    interface ObjectConstructor {
+        entries<T extends object>(o: T): Entries<T>;
+    }
+}
+export default class Inibase {
+    folder: string;
+    database: string;
+    table: string;
+    pageInfo: pageInfo;
+    private cache;
+    private totalItems;
+    salt: Buffer;
+    constructor(database: string, mainFolder?: string);
+    private throwError;
+    setTableSchema(tableName: string, schema: Schema): Promise<void>;
+    getTableSchema(tableName: string): Promise<Schema | undefined>;
+    getField<Property extends keyof Field | "children">(keyPath: string, schema: Schema | Field, property?: Property): any;
+    validateData(data: Data | Data[], schema: Schema, skipRequiredField?: boolean): void;
+    formatData<dataType extends Data | Data[]>(data: dataType, schema: Schema, formatOnlyAvailiableKeys?: boolean): dataType extends Data ? Data : Data[];
+    private getDefaultValue;
+    private joinPathesContentsReplacement;
+    joinPathesContents(mainPath: string, data: Data | Data[], startWith?: number): {
+        [key: string]: string[];
+    };
+    get<O extends boolean = false, N extends boolean = false>(tableName: string, where?: string | number | (string | number)[] | Criteria, options?: Options, onlyOne?: O, onlyLinesNumbers?: N): Promise<(N extends true ? number[] : O extends true ? Data : Data[]) | null>;
+    post<DataType extends Data | Data[]>(tableName: string, data: DataType, options?: Options, returnPostedData?: boolean): Promise<DataType extends Data ? Data | null | void : Data[] | null | void>;
+    put<returnPostedDataType extends boolean = true>(tableName: string, data: Data | Data[], where?: number | string | (number | string)[] | Criteria, options?: Options, returnPostedData?: returnPostedDataType): Promise<(returnPostedDataType extends true ? Data | Data[] : void) | null>;
+    delete(tableName: string, where?: number | string | (number | string)[] | Criteria, _id?: string | string[]): Promise<string | string[] | null>;
+    sum(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
+    sum(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
+    max(tableName: string, columns: string | string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
+    min(tableName: string, columns: string | string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
+}
+export {};