@digione/node-custom-api 0.0.1

package/utils/db.js

@@ -0,0 +1,399 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneColumn = exports.removeColumn = exports.changeColumn = exports.addConstraint = exports.addColumn = exports.getChildren = exports.getExistField = exports.getExistTable = exports.getListTable = exports.removeAttrReference = exports.renameTable = exports.dropTable = exports.createTable = exports.cloneTable = exports.truncate = exports.getFieldAll = exports.getNextId = exports.max = exports.remove = exports.insert = exports.update = exports.findAll = exports.findOne = exports.count = exports.genValue = exports.select = exports.genWhere = void 0;
+const tslib_1 = require("tslib");
+const database_1 = require("../database");
+const sequelize = require("sequelize");
+const sequelize_1 = require("sequelize");
+const _ = require("lodash");
+const errors_1 = require("../errors");
+const helper_1 = require("./helper");
+const OperatorHelper = require('sequelize/lib/dialects/abstract/query-generator/operators');
+const SqlUtil = require('sequelize/lib/utils');
+const SqlString = require('sequelize/lib/sql-string');
+const getWhereVal = (smth) => {
+    let value = smth.logic;
+    let key = smth.attribute;
+    let OperatorMap = Object.assign(Object.assign({}, OperatorHelper.OperatorMap), { [sequelize_1.Op.not]: "!=", [sequelize_1.Op.regexp]: "REGEXP", [sequelize_1.Op.notRegexp]: "NOT REGEXP" });
+    if (Object.prototype.hasOwnProperty.call(OperatorMap, smth.comparator)) {
+        smth.comparator = OperatorMap[smth.comparator];
+    }
+    if (value === null) {
+        value = "NULL";
+    }
+    if (value === "NULL") {
+        if (smth.comparator === "=") {
+            smth.comparator = "IS";
+        }
+        if (smth.comparator === "!=") {
+            smth.comparator = "IS NOT";
+        }
+    }
+    return [key, value].join(` ${smth.comparator} `);
+};
+const genWhere = (where = {}, { as = "", delimiter = ".", prefix = true, bracket = false } = {}) => {
+    as = as ? as + delimiter : as;
+    let symbolKeys = Object.getOwnPropertySymbols(where);
+    let rawWhere = (Object.keys(where).concat(symbolKeys)).reduce((result, key) => {
+        let value = where[key];
+        if (typeof value !== 'undefined') {
+            key = typeof (value) == "string" ? `${as}${key}` : key;
+            if (typeof (value) == "string") {
+                value = SqlString.escape(value);
+            }
+            else if (value instanceof Array) {
+                if (typeof key === 'symbol' && (key == sequelize_1.Op.and || key == sequelize_1.Op.or)) {
+                    let postfix = key == sequelize_1.Op.and ? 'AND' : 'OR', bracket = value.length > 1;
+                    let op = value.map(i => (0, exports.genWhere)(i, { as, delimiter, prefix: false, bracket })).join(`${postfix} `);
+                    result = `${result}( ${op}) AND `;
+                }
+                else {
+                    result = `${result + key} IN (${value.map(i => "'" + i + "'").join(',')}) AND `;
+                }
+                return result;
+            }
+            else if (_.isPlainObject(value)) {
+                let results = [];
+                SqlUtil.getComplexKeys(value).forEach((symbol) => {
+                    let val = value[symbol];
+                    results.push(getWhereVal(database_1.default.where(key, symbol, val)));
+                });
+                result = `${result}${results.join(' AND ')} AND `;
+                return result;
+            }
+            else if (typeof value == "object" && value['val']) {
+                result = `${result}${key}=${value['val']} AND `;
+                return result;
+            }
+            result = result + key + "=" + value + " AND ";
+        }
+        return result;
+    }, "");
+    let whereClause = rawWhere.substring(0, rawWhere.length - 4);
+    if (bracket && whereClause) {
+        whereClause = "(" + whereClause + ") ";
+    }
+    if (prefix && whereClause) {
+        whereClause = "WHERE " + whereClause;
+    }
+    return whereClause;
+};
+exports.genWhere = genWhere;
+const select = (table, { where = {}, attributes = [], association = [], limit = 0, offset = 0, order = [] } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let whereClause = (0, exports.genWhere)(where);
+    let orderClause = '';
+    if (order.length == 2) {
+        orderClause = `ORDER BY ${order[0]} ${order[1]}`;
+    }
+    let limitClause = '';
+    if (limit) {
+        limitClause = `LIMIT ${limit} ${offset ? 'OFFSET ' + offset : ''}`;
+    }
+    let attr = attributes.join(',');
+    if (association.length) {
+        whereClause = association.join('\n') + (whereClause ? ' ' + whereClause : '');
+    }
+    let query = `SELECT ${attr ? attr : '*'} FROM ${table} ${whereClause} ${orderClause} ${limitClause}`;
+    return query;
+});
+exports.select = select;
+const genValue = (value) => {
+    if (typeof (value) == "string") {
+        if (value === "")
+            value = null;
+        value = SqlString.escape(value);
+    }
+    else if (value instanceof Date) {
+        value = `'${(0, helper_1.getDateMysql)(value)}'`;
+    }
+    return value;
+};
+exports.genValue = genValue;
+const count = (table, { where = {}, primaryKey = 'id' } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let whereClause = (0, exports.genWhere)(where);
+    let query = `SELECT COUNT(${primaryKey}) FROM ${table} ${whereClause}`;
+    let data = yield database_1.default.query(query, { type: sequelize.QueryTypes.SELECT });
+    return data[0][`COUNT(${primaryKey})`];
+});
+exports.count = count;
+const findOne = (table, { where = {}, attributes = [], association = [], order = [] } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let query = yield (0, exports.select)(table, { where, attributes, association, limit: 1, order });
+    try {
+        let data = yield database_1.default.query(query, { type: sequelize.QueryTypes.SELECT });
+        return data[0];
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+});
+exports.findOne = findOne;
+const findAll = (table, { where = {}, attributes = [], association = [], limit = 0, offset = 0, order = [] } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let query = yield (0, exports.select)(table, { where, attributes, association, limit, offset, order });
+    try {
+        let data = yield database_1.default.query(query, { type: sequelize.QueryTypes.SELECT });
+        return data;
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+});
+exports.findAll = findAll;
+const update = (ref, table, input, { where = {}, default_lang = "", index = "id" } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    if (where['lang_code'] && (input['lang_code'] && input[index])) {
+        let exist = yield (0, exports.count)(ref + "_" + table, { primaryKey: index, where: { lang_code: input['lang_code'], [index]: input[index] } });
+        if (!exist) {
+            let where_default = {};
+            if (default_lang)
+                where_default['lang_code'] = default_lang;
+            let query = yield (0, exports.findOne)(ref + "_" + table, { where: Object.assign(Object.assign({}, where_default), { [index]: input[index] }) });
+            if (!query)
+                return null;
+            input = Object.assign(Object.assign({}, query), input);
+            if (input['created'])
+                input['created'] = (0, helper_1.getDateMysql)(input['created']);
+            return yield (0, exports.insert)(ref, table, input, { index });
+        }
+    }
+    input = _.cloneDeep(input);
+    delete input[index];
+    table = ref ? ref + "_" + table : table;
+    let rawSet = _.reduce(input, (result, value, key) => {
+        if (typeof value !== 'undefined') {
+            value = (0, exports.genValue)(value);
+            result = result + "`" + key + "`" + "=" + value + " , ";
+        }
+        return result;
+    }, "");
+    let set = rawSet.substring(0, rawSet.length - 2);
+    if (set) {
+        set = "SET " + set;
+    }
+    let whereClause = (0, exports.genWhere)(where);
+    let query = `UPDATE ${table} ${set} ${whereClause}`;
+    try {
+        let data = yield database_1.default.query(query, { type: sequelize.QueryTypes.UPDATE });
+        return data;
+    }
+    catch (err) {
+        console.log(err);
+    }
+    return Promise.reject(errors_1.generalError.BAD_REQUEST);
+});
+exports.update = update;
+const insert = (ref, table, input, { index = "id" } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    table = ref ? ref + "_" + table : table;
+    let insert, rawField = "", rawValues = "";
+    _.each(input, (value, key) => {
+        if (typeof value !== 'undefined') {
+            value = (0, exports.genValue)(value);
+            rawField = rawField + "`" + key + "` , ";
+            rawValues = rawValues + value + " , ";
+        }
+    });
+    let field = rawField.substring(0, rawField.length - 2);
+    let values = rawValues.substring(0, rawValues.length - 2);
+    if (field) {
+        insert = "(" + field + ") VALUES (" + values + ") ";
+    }
+    let query = `INSERT INTO ${table} ${insert}`;
+    try {
+        let insert = yield database_1.default.query(query, { type: sequelize.QueryTypes.INSERT });
+        return { [index]: input[index] ? input[index] : insert[0] };
+    }
+    catch (err) {
+        console.log(err);
+    }
+    return Promise.reject(errors_1.generalError.BAD_REQUEST);
+});
+exports.insert = insert;
+const remove = (ref, table, { where = {} } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    table = ref ? ref + "_" + table : table;
+    let whereClause = (0, exports.genWhere)(where);
+    let query = `DELETE FROM ${table} ${whereClause}`;
+    try {
+        yield database_1.default.query(query, { type: sequelize.QueryTypes.DELETE });
+        return 1;
+    }
+    catch (err) {
+        console.log(err);
+    }
+    return Promise.reject(errors_1.generalError.BAD_REQUEST);
+});
+exports.remove = remove;
+const max = (ref, table, field, { where = {} } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    table = ref ? ref + "_" + table : table;
+    let whereClause = (0, exports.genWhere)(where);
+    let query = `SELECT MAX(${field}) FROM ${table} ${whereClause}`;
+    try {
+        let data = yield database_1.default.query(query, { type: sequelize.QueryTypes.SELECT });
+        if (data && data.length) {
+            data = data[0][`MAX(${field})`];
+        }
+        return data;
+    }
+    catch (err) {
+        console.log(err);
+    }
+    return Promise.reject(errors_1.generalError.BAD_REQUEST);
+});
+exports.max = max;
+const getNextId = (ref, table) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    table = ref ? ref + '_' + table : table;
+    let query = `SELECT Auto_increment FROM information_schema.tables WHERE table_name='${table}'`;
+    try {
+        let data = yield database_1.default.query(query, { type: sequelize.QueryTypes.SELECT });
+        if (data[0] && data[0]['Auto_increment']) {
+            return data[0]['Auto_increment'];
+        }
+    }
+    catch (err) { }
+    return 1;
+});
+exports.getNextId = getNextId;
+const getFieldAll = (table, { type = false } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        let data = yield database_1.default.query(`DESCRIBE ${table}`, { type: sequelize.QueryTypes.SELECT });
+        if (!type) {
+            data = data.map(field => field['Field']);
+        }
+        return data;
+    }
+    catch (err) {
+    }
+    return null;
+});
+exports.getFieldAll = getFieldAll;
+const truncate = (table) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    return database_1.default.query(`TRUNCATE TABLE ${table}`, { type: sequelize.QueryTypes.RAW });
+});
+exports.truncate = truncate;
+const cloneTable = (old_table, new_table, { withRow = true } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let exist = yield (0, exports.getExistTable)(new_table);
+    if (exist)
+        return false;
+    yield database_1.default.query(`CREATE TABLE ${new_table} LIKE ${old_table}`, { type: sequelize.QueryTypes.RAW });
+    withRow && (yield database_1.default.query(`INSERT INTO ${new_table} SELECT * FROM ${old_table}`, { type: sequelize.QueryTypes.INSERT }));
+    return true;
+});
+exports.cloneTable = cloneTable;
+const createTable = (table, attributes, { removePrimary = false, field = "id" } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    return database_1.default.getQueryInterface()
+        .createTable(table, (0, exports.removeAttrReference)(attributes, { removePrimary, field }), { charset: 'utf8', collate: 'utf8_general_ci' });
+});
+exports.createTable = createTable;
+const dropTable = (table) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    return database_1.default.getQueryInterface().dropTable(table);
+});
+exports.dropTable = dropTable;
+const renameTable = (before, after) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    return database_1.default.getQueryInterface().renameTable(before, after);
+});
+exports.renameTable = renameTable;
+const removeAttrReference = (obj, { field = "id", removePrimary = false } = {}) => {
+    let attr = _.cloneDeep(obj);
+    if (removePrimary) {
+        delete attr[field]['primaryKey'];
+        delete attr[field]['autoIncrement'];
+    }
+    if (_.size(attr)) {
+        _.each(attr, (val, key) => {
+            if (val['references']) {
+                delete attr[key]['references'];
+            }
+        });
+    }
+    return attr;
+};
+exports.removeAttrReference = removeAttrReference;
+const getListTable = (search, { postfix = true } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let query = yield database_1.default.query(`SHOW TABLES LIKE '%${search}${postfix ? '%' : ''}'`, { type: sequelize.QueryTypes.SELECT });
+    if (query.length) {
+        query = query.map(i => i[Object.keys(i)[0]]);
+    }
+    return query;
+});
+exports.getListTable = getListTable;
+const getExistTable = (table) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        let data = yield database_1.default.query(`SHOW TABLES LIKE '${table}'`, { type: sequelize.QueryTypes.SELECT });
+        if (data.length) {
+            return true;
+        }
+    }
+    catch (err) { }
+    return false;
+});
+exports.getExistTable = getExistTable;
+const getExistField = (table, field) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        let data = yield database_1.default.query("SHOW COLUMNS FROM `" + table + "` LIKE '" + field + "'", { type: sequelize.QueryTypes.SELECT });
+        if (data.length) {
+            return true;
+        }
+    }
+    catch (err) { }
+    return false;
+});
+exports.getExistField = getExistField;
+const getChildren = (table, value, { level = 0, max = 1, where = {}, array = [], key_index = "id", key = "parent", init = false, lang_code = false } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    if (init) {
+        array = array.concat(value);
+    }
+    if (lang_code)
+        where['lang_code'] = "en";
+    let query = [];
+    try {
+        query = yield (0, exports.findAll)(table, { where: Object.assign({ [key]: value }, where), attributes: [key_index, key] });
+    }
+    catch (err) { }
+    level = level + 1;
+    if (query.length && level <= max) {
+        return yield (0, exports.getChildren)(table, query.map(i => i[key_index]), { level, max, where, array, key_index, key, lang_code, init: true });
+    }
+    return array;
+});
+exports.getChildren = getChildren;
+const addColumn = (table, field, schema) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        return yield database_1.default.getQueryInterface().addColumn(table, field, schema);
+    }
+    catch (err) { }
+    return null;
+});
+exports.addColumn = addColumn;
+const addConstraint = (table, options) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        return yield database_1.default.getQueryInterface().addConstraint(table, options);
+    }
+    catch (err) { }
+    return null;
+});
+exports.addConstraint = addConstraint;
+const changeColumn = (table, field, schema, { remove_primarykey = false, remove_index = false } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        if (remove_primarykey)
+            yield database_1.default.query(`ALTER TABLE ${table} DROP PRIMARY KEY`);
+        if (remove_index)
+            yield database_1.default.query(`ALTER TABLE ${table} DROP INDEX ${field}`);
+        return database_1.default.getQueryInterface().changeColumn(table, field, schema);
+    }
+    catch (err) { }
+    return null;
+});
+exports.changeColumn = changeColumn;
+const removeColumn = (table, field) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        return yield database_1.default.query(`ALTER TABLE ${table} DROP COLUMN ${field}`);
+    }
+    catch (err) { }
+    return null;
+});
+exports.removeColumn = removeColumn;
+const cloneColumn = (table, old_field, new_field) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        return yield database_1.default.query(`UPDATE ${table} SET ${new_field} = ${old_field}`, { type: sequelize.QueryTypes.UPDATE });
+    }
+    catch (err) { }
+    return null;
+});
+exports.cloneColumn = cloneColumn;

package/utils/file.d.ts

@@ -0,0 +1,232 @@
+import { Request } from 'express';
+import * as aws from "aws-sdk";
+export declare const getBuffer: (image: any, { mimetype }?: {
+    mimetype?: string;
+}) => Promise<any[]>;
+export type TagFile = Array<{
+    slug?: string;
+    type?: string;
+}>;
+interface OptionFile {
+    hostname?: any;
+    organ_id?: any;
+    parent_organ_id?: any;
+    [index: string]: any;
+}
+export declare class FileUtil {
+    protected location: any;
+    protected bucket: any;
+    protected ACL: any;
+    option: OptionFile;
+    setting: any;
+    driver: any;
+    url: string;
+    ref: string;
+    private s3;
+    private settingUtil;
+    constructor(ref?: string, option?: OptionFile);
+    getStorage(): Promise<{
+        driver: any;
+        setting: any;
+    }>;
+    getFileAttribute(): Promise<any[]>;
+    getFilePath(item: any): any[];
+    getSettingImgKit(): Promise<any>;
+    convertImgKit(path: string, setting?: any): string;
+    afterQueryFile(data?: any, { tag, file_link }?: {
+        tag?: {};
+        file_link?: boolean;
+    }): Promise<any>;
+    uploadRaw(files: Array<any>): Promise<Array<any>>;
+    upload(files: Array<any>): Promise<any[]>;
+    private uploadThumb;
+    existImageThumb(item: any, { width, height, checkExist }?: {
+        width?: number;
+        height?: number;
+        checkExist?: boolean;
+    }): Promise<any>;
+    findImageThumb(item: any, { width, height, upsert }: {
+        width?: number;
+        height?: number;
+        upsert?: boolean;
+    }): Promise<any>;
+    findImageThumbByFolderSlug(slug: any, { where, width, height, parent_folder, tags, group }?: {
+        where?: {};
+        width?: number;
+        height?: number;
+        parent_folder?: string;
+        tags?: TagFile;
+        group?: any;
+    }): Promise<any>;
+    findImageThumbByFileId(id: any, { width, height }: {
+        width?: number;
+        height?: number;
+    }): Promise<any>;
+    beforeFindFile(where?: {}, { tags, group }?: {
+        tags?: TagFile;
+        group?: any;
+    }): {};
+    findAllFile({ where, folder, full, file_link, thumb, width, height, parent_folder, attributes, limit, offset, tag, tags, group }?: {
+        where?: {};
+        folder?: boolean;
+        full?: boolean;
+        file_link?: boolean;
+        thumb?: boolean;
+        width?: number;
+        height?: number;
+        parent_folder?: string;
+        attributes?: any;
+        limit?: any;
+        offset?: any;
+        tag?: {};
+        tags?: TagFile;
+        group?: any;
+    }): Promise<any[]>;
+    findAndCountAllFileByFolder(slug: string, { where, file_link, parent_folder, limit, offset, tag, tags, group }?: {
+        where?: {};
+        file_link?: boolean;
+        parent_folder?: string;
+        limit?: any;
+        offset?: any;
+        tag?: {};
+        tags?: TagFile;
+        group?: any;
+    }): Promise<{
+        rows: any[];
+        count: number;
+    }>;
+    findAllFileByFolder(slug: string, { where, full, file_link, thumb, width, height, parent_folder, limit, offset, tags, group }?: {
+        where?: {};
+        full?: boolean;
+        file_link?: boolean;
+        thumb?: boolean;
+        width?: number;
+        height?: number;
+        parent_folder?: string;
+        limit?: any;
+        offset?: any;
+        tags?: TagFile;
+        group?: any;
+    }): Promise<any[]>;
+    findOneFileByFolder(slug: string, { where, full, file_link, parent_folder, tags, group }?: {
+        where?: {};
+        full?: boolean;
+        file_link?: boolean;
+        parent_folder?: string;
+        tags?: TagFile;
+        group?: any;
+    }): Promise<any>;
+    findOneFileById(id: string, { where, full, file_link, parent_folder, tags, group }?: {
+        where?: {};
+        full?: boolean;
+        file_link?: boolean;
+        parent_folder?: string;
+        tags?: TagFile;
+        group?: any;
+    }): Promise<any>;
+    uploadByReq(req: Request, slug: string, user_id: any, { parent_id, parent_slug, name, root, thumb, width, height, input, is_hidden, tags, group }?: {
+        parent_id?: number;
+        parent_slug?: string;
+        name?: any;
+        root?: boolean;
+        thumb?: boolean;
+        width?: number;
+        height?: number;
+        input?: {};
+        is_hidden?: any;
+        tags?: TagFile;
+        group?: any;
+    }): Promise<any>;
+    createFolder(slug: string, { parent_id, root, name, location, remote_container, hidden, input }?: {
+        parent_id?: number;
+        root?: boolean;
+        name?: any;
+        location?: any;
+        remote_container?: any;
+        hidden?: number;
+        input?: {};
+    }): Promise<any>;
+    createFileByPath(files: Array<string>, slug: string, user_id: any, { parent_slug, type, name, root, upload, tags, group }?: {
+        parent_slug?: string;
+        type?: string;
+        name?: any;
+        root?: boolean;
+        upload?: boolean;
+        tags?: TagFile;
+        group?: any;
+    }): Promise<any>;
+    allowedFileType(extension: any): Promise<any>;
+    formatFile(folder_id: any, user_id: any, reqs: Array<any>, files: Array<any>, { use_id, field, formatDateTime, input, is_hidden, tags, group }?: {
+        use_id?: boolean;
+        field?: any[];
+        formatDateTime?: string;
+        input?: {};
+        is_hidden?: any;
+        tags?: TagFile;
+        group?: any;
+    }): Promise<{
+        folder_id: any;
+        user_id: any;
+        organ_id: any;
+        organ_by: any;
+        sort: string;
+        date_added: string;
+        name: any;
+        filename: any;
+        path: any;
+        mimetype: any;
+        filesize: any;
+        extension: string;
+        type: any;
+        is_hidden: any;
+        tags: TagFile;
+        group: any;
+    }[]>;
+    insertFileUnique(results: Array<any>, { thumb, width, height }?: {
+        thumb?: boolean;
+        width?: number;
+        height?: number;
+    }): any;
+    uploadRawFormat(files: Array<any>, { field }?: {
+        field?: string[];
+    }): Promise<any>;
+    updateFile(id: string, input?: any, { paths }?: {
+        paths?: any[];
+    }): Promise<[undefined, number] | {
+        [x: string]: any;
+    }>;
+    updateFolderSlug(old_slug: string, new_slug: string): Promise<number>;
+    remove({ where, delete_object, error, tags, group }?: {
+        where?: {};
+        delete_object?: boolean;
+        error?: boolean;
+        tags?: TagFile;
+        group?: any;
+    }): Promise<any[]>;
+    removeFileById(id: any, { tags, group, delete_object, error }?: {
+        tags?: TagFile;
+        group?: any;
+        delete_object?: boolean;
+        error?: boolean;
+    }): Promise<any[]>;
+    removeFileByFolder(slug: any, { where, parent_folder, delete_object, tags, group }?: {
+        where?: {};
+        parent_folder?: string;
+        delete_object?: boolean;
+        tags?: TagFile;
+        group?: any;
+    }): Promise<any[]>;
+    removeFolder(index: any, { where, field, parent_folder, delete_object }?: {
+        where?: {};
+        field?: string;
+        parent_folder?: string;
+        delete_object?: boolean;
+    }): Promise<any[]>;
+    deleteObjects(paths: Array<string>, { origin }?: {
+        origin?: string;
+    }): Promise<import("aws-sdk/lib/request").PromiseResult<aws.S3.DeleteObjectsOutput, aws.AWSError> | {
+        error: number;
+        n: number;
+    }>;
+}
+export {};