tiny-essentials 1.0.0

package/dist/legacy/firebase/mysqlConnector/create.cjs

@@ -0,0 +1,119 @@
+'use strict';
+
+/**
+ * Initializes and caches one or more MySQL database connections using provided configuration.
+ * Supports Firebase and Google Cloud SQL socket-based connections, as well as local/standard MySQL setups.
+ *
+ * @async
+ * @param {Object} mysql - The `mysql2` module or similar instance, with a `.createPool()` method.
+ * @param {string} proxyType - The type of proxy connection. Can be `"default"`, `"firebase"`, or `"google_cloud"`.
+ * @param {Object|Object[]} databases - A single database config object or an array of config objects.
+ * @param {Object} cfg - Global fallback configuration, e.g., `{ charset: 'utf8mb4' }`.
+ *
+ * @returns {Promise<Object>} Resolves with a single connection object if one database is provided,
+ *                            or a map of database names to connections if multiple databases are configured.
+ *
+ * @throws {Error} Will reject if any database config is invalid or if the proxyType is unsupported.
+ *
+ * @example
+ * const connection = await create(mysql, 'default', {
+ *   data: { database: 'my_db', user: 'root', password: 'pass', host: 'localhost', port: 3306 },
+ *   default: { host: 'localhost', port: 3306 },
+ * });
+ *
+ * @example
+ * const connections = await create(mysql, 'google_cloud', [
+ *   {
+ *     data: { database: 'db1', user: 'user', password: 'pass' },
+ *     google_cloud: { socketPath: '/cloudsql/project:region:instance' },
+ *     default: { host: 'localhost', port: 3306 },
+ *   },
+ *   {
+ *     data: { database: 'db2', user: 'user', password: 'pass' },
+ *     google_cloud: { socketPath: '/cloudsql/project:region:instance2' },
+ *     default: { host: 'localhost', port: 3306 },
+ *   }
+ * ]);
+ */
+function create(mysql, proxyType, databases, cfg) {
+  return new Promise(function (resolve, reject) {
+    let databaseList = [];
+
+    // Create Settings
+    const tinyCfg = _.defaultsDeep({}, cfg, {
+      charset: 'utf8mb4',
+    });
+
+    // Convert
+    if (!Array.isArray(databases)) databaseList = [clone(databases)];
+    else databaseList = clone(databases);
+
+    // Run Array
+    for (const item in databaseList) {
+      // Exist
+      if (objType(databaseList[item], 'object') && objType(databaseList[item].data, 'object')) {
+        if (!db[databaseList[item].data.database]) {
+          // Charset
+          if (typeof databaseList[item].data.charset !== 'string')
+            databaseList[item].data.charset = tinyCfg.charset;
+
+          // Firebase Is Emulator
+          let firebaseIsEmulator = false;
+          if (proxyType === 'firebase') {
+            try {
+              firebaseIsEmulator = isEmulator();
+            } catch (err) {
+              firebaseIsEmulator = false;
+            }
+          }
+
+          // Exist Proxy
+          if (!firebaseIsEmulator && typeof proxyType === 'string' && proxyType !== 'default') {
+            // Google Cloud
+            if (
+              (proxyType === 'firebase' || proxyType === 'google_cloud') &&
+              objType(databaseList[item].google_cloud, 'object') &&
+              typeof databaseList[item].google_cloud.socketPath === 'string'
+            ) {
+              // Insert the config
+              databaseList[item].data.socketPath = databaseList[item].google_cloud.socketPath;
+            } else reject(new Error('Invalid Proxy Type! Index:' + item));
+          }
+
+          // Normal Connection
+          else {
+            // SSL Files
+            if (objType(databaseList[item].default.ssl, 'object'))
+              databaseList[item].data.ssl = databaseList[item].default.ssl;
+
+            // Host and Port
+            databaseList[item].data.host = databaseList[item].default.host;
+            databaseList[item].data.port = databaseList[item].default.port;
+          }
+
+          // Create DB Connection
+          try {
+            db[databaseList[item].data.database] = mysql.createPool(databaseList[item].data);
+            db[databaseList[item].data.database].query = util.promisify(
+              db[databaseList[item].data.database].query,
+            );
+          } catch (err) {
+            reject(err);
+          }
+        }
+      }
+
+      // Nope
+      else reject(new Error('Invalid MySQL Setting! Index:' + item));
+    }
+
+    // Fix
+    const dbKets = Object.keys(databaseList);
+
+    // Complete
+    if (dbKets.length < 2) resolve(db[databaseList[0].data.database]);
+    else resolve(db);
+  });
+}
+
+module.exports = create;

package/dist/legacy/firebase/mysqlConnector/create.d.mts

@@ -0,0 +1,36 @@
+/**
+ * Initializes and caches one or more MySQL database connections using provided configuration.
+ * Supports Firebase and Google Cloud SQL socket-based connections, as well as local/standard MySQL setups.
+ *
+ * @async
+ * @param {Object} mysql - The `mysql2` module or similar instance, with a `.createPool()` method.
+ * @param {string} proxyType - The type of proxy connection. Can be `"default"`, `"firebase"`, or `"google_cloud"`.
+ * @param {Object|Object[]} databases - A single database config object or an array of config objects.
+ * @param {Object} cfg - Global fallback configuration, e.g., `{ charset: 'utf8mb4' }`.
+ *
+ * @returns {Promise<Object>} Resolves with a single connection object if one database is provided,
+ *                            or a map of database names to connections if multiple databases are configured.
+ *
+ * @throws {Error} Will reject if any database config is invalid or if the proxyType is unsupported.
+ *
+ * @example
+ * const connection = await create(mysql, 'default', {
+ *   data: { database: 'my_db', user: 'root', password: 'pass', host: 'localhost', port: 3306 },
+ *   default: { host: 'localhost', port: 3306 },
+ * });
+ *
+ * @example
+ * const connections = await create(mysql, 'google_cloud', [
+ *   {
+ *     data: { database: 'db1', user: 'user', password: 'pass' },
+ *     google_cloud: { socketPath: '/cloudsql/project:region:instance' },
+ *     default: { host: 'localhost', port: 3306 },
+ *   },
+ *   {
+ *     data: { database: 'db2', user: 'user', password: 'pass' },
+ *     google_cloud: { socketPath: '/cloudsql/project:region:instance2' },
+ *     default: { host: 'localhost', port: 3306 },
+ *   }
+ * ]);
+ */
+export default function create(mysql: Object, proxyType: string, databases: Object | Object[], cfg: Object): Promise<Object>;

package/dist/legacy/firebase/mysqlConnector/create.mjs

@@ -0,0 +1,109 @@
+/**
+ * Initializes and caches one or more MySQL database connections using provided configuration.
+ * Supports Firebase and Google Cloud SQL socket-based connections, as well as local/standard MySQL setups.
+ *
+ * @async
+ * @param {Object} mysql - The `mysql2` module or similar instance, with a `.createPool()` method.
+ * @param {string} proxyType - The type of proxy connection. Can be `"default"`, `"firebase"`, or `"google_cloud"`.
+ * @param {Object|Object[]} databases - A single database config object or an array of config objects.
+ * @param {Object} cfg - Global fallback configuration, e.g., `{ charset: 'utf8mb4' }`.
+ *
+ * @returns {Promise<Object>} Resolves with a single connection object if one database is provided,
+ *                            or a map of database names to connections if multiple databases are configured.
+ *
+ * @throws {Error} Will reject if any database config is invalid or if the proxyType is unsupported.
+ *
+ * @example
+ * const connection = await create(mysql, 'default', {
+ *   data: { database: 'my_db', user: 'root', password: 'pass', host: 'localhost', port: 3306 },
+ *   default: { host: 'localhost', port: 3306 },
+ * });
+ *
+ * @example
+ * const connections = await create(mysql, 'google_cloud', [
+ *   {
+ *     data: { database: 'db1', user: 'user', password: 'pass' },
+ *     google_cloud: { socketPath: '/cloudsql/project:region:instance' },
+ *     default: { host: 'localhost', port: 3306 },
+ *   },
+ *   {
+ *     data: { database: 'db2', user: 'user', password: 'pass' },
+ *     google_cloud: { socketPath: '/cloudsql/project:region:instance2' },
+ *     default: { host: 'localhost', port: 3306 },
+ *   }
+ * ]);
+ */
+export default function create(mysql, proxyType, databases, cfg) {
+    return new Promise(function (resolve, reject) {
+        let databaseList = [];
+        // Create Settings
+        const tinyCfg = _.defaultsDeep({}, cfg, {
+            charset: 'utf8mb4',
+        });
+        // Convert
+        if (!Array.isArray(databases))
+            databaseList = [clone(databases)];
+        else
+            databaseList = clone(databases);
+        // Run Array
+        for (const item in databaseList) {
+            // Exist
+            if (objType(databaseList[item], 'object') && objType(databaseList[item].data, 'object')) {
+                if (!db[databaseList[item].data.database]) {
+                    // Charset
+                    if (typeof databaseList[item].data.charset !== 'string')
+                        databaseList[item].data.charset = tinyCfg.charset;
+                    // Firebase Is Emulator
+                    let firebaseIsEmulator = false;
+                    if (proxyType === 'firebase') {
+                        try {
+                            firebaseIsEmulator = isEmulator();
+                        }
+                        catch (err) {
+                            firebaseIsEmulator = false;
+                        }
+                    }
+                    // Exist Proxy
+                    if (!firebaseIsEmulator && typeof proxyType === 'string' && proxyType !== 'default') {
+                        // Google Cloud
+                        if ((proxyType === 'firebase' || proxyType === 'google_cloud') &&
+                            objType(databaseList[item].google_cloud, 'object') &&
+                            typeof databaseList[item].google_cloud.socketPath === 'string') {
+                            // Insert the config
+                            databaseList[item].data.socketPath = databaseList[item].google_cloud.socketPath;
+                        }
+                        else
+                            reject(new Error('Invalid Proxy Type! Index:' + item));
+                    }
+                    // Normal Connection
+                    else {
+                        // SSL Files
+                        if (objType(databaseList[item].default.ssl, 'object'))
+                            databaseList[item].data.ssl = databaseList[item].default.ssl;
+                        // Host and Port
+                        databaseList[item].data.host = databaseList[item].default.host;
+                        databaseList[item].data.port = databaseList[item].default.port;
+                    }
+                    // Create DB Connection
+                    try {
+                        db[databaseList[item].data.database] = mysql.createPool(databaseList[item].data);
+                        db[databaseList[item].data.database].query = util.promisify(db[databaseList[item].data.database].query);
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                }
+            }
+            // Nope
+            else
+                reject(new Error('Invalid MySQL Setting! Index:' + item));
+        }
+        // Fix
+        const dbKets = Object.keys(databaseList);
+        // Complete
+        if (dbKets.length < 2)
+            resolve(db[databaseList[0].data.database]);
+        else
+            resolve(db);
+    });
+}

package/dist/legacy/firebase/mysqlConnector/index.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var create = require('./create.cjs');
+var nextPrev = require('./nextPrev.cjs');
+var pagination = require('./pagination.cjs');
+var sameUser = require('./sameUser.cjs');
+
+// Modules
+const mysqlConnector = {
+  // Next and Prev
+  nextPrev,
+
+  // Pagination
+  pagination,
+
+  // Same User Generator
+  sameUser,
+
+  // Create DB Value
+  create,
+};
+
+module.exports = mysqlConnector;

package/dist/legacy/firebase/mysqlConnector/index.d.mts

@@ -0,0 +1,11 @@
+export default mysqlConnector;
+declare namespace mysqlConnector {
+    export { nextPrev };
+    export { pagination };
+    export { sameUser };
+    export { create };
+}
+import nextPrev from './nextPrev.mjs';
+import pagination from './pagination.mjs';
+import sameUser from './sameUser.mjs';
+import create from './create.mjs';

package/dist/legacy/firebase/mysqlConnector/index.mjs

@@ -0,0 +1,16 @@
+import create from './create.mjs';
+import nextPrev from './nextPrev.mjs';
+import pagination from './pagination.mjs';
+import sameUser from './sameUser.mjs';
+// Modules
+const mysqlConnector = {
+    // Next and Prev
+    nextPrev,
+    // Pagination
+    pagination,
+    // Same User Generator
+    sameUser,
+    // Create DB Value
+    create,
+};
+export default mysqlConnector;

package/dist/legacy/firebase/mysqlConnector/nextPrev.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+/**
+ * Executes a directional query (next or previous) based on a position value and timestamp, returning a single row.
+ *
+ * @async
+ * @param {Object} db - The database instance with a `.query(sql, params)` method.
+ * @param {Object} tiny_search - Configuration object for the query.
+ * @param {string} tiny_search.select - SQL SELECT fields.
+ * @param {string} tiny_search.from - SQL FROM clause.
+ * @param {string} [tiny_search.where] - Optional WHERE clause (without 'WHERE') to filter results.
+ * @param {Array} tiny_search.params - Parameters for the query placeholders.
+ * @param {*} tiny_search.position - Value to compare in the directional filter (typically an ID or timestamp).
+ * @param {boolean} [tiny_search.direction_r=false] - If `true`, selects previous record (uses `<`), otherwise selects next (`>`).
+ * @param {Object} tiny_search.database - Object with database structure details.
+ * @param {string} tiny_search.database.name - The table name or alias used in the query.
+ * @param {string} tiny_search.database.timeVar - Column name used for ordering chronologically (e.g., `"created_at"`).
+ * @param {string} tiny_search.database.positionVar - Column name used for the directional condition (e.g., `"id"`).
+ * @returns {Promise<Object|null>} Resolves with the selected row or `null` if none is found.
+ */
+async function nextPrev(db, tiny_search) {
+  // Validate Database
+  if (
+    tiny_search.database &&
+    typeof tiny_search.database.name === 'string' &&
+    typeof tiny_search.database.timeVar === 'string' &&
+    typeof tiny_search.database.positionVar === 'string'
+  ) {
+    // Prepare Tiny Search
+    if (tiny_search.where) tiny_search.where += ' AND ';
+    tiny_search.params.push(tiny_search.position);
+
+    // Select Direction
+    let tiny_direction = '';
+    let tiny_order = '';
+    if (tiny_search.direction_r) {
+      tiny_direction = '<';
+      tiny_order = `${tiny_search.database.name}.${tiny_search.database.timeVar} DESC`;
+    } else {
+      tiny_direction = '>';
+      tiny_order = `${tiny_search.database.name}.${tiny_search.database.timeVar}`;
+    }
+
+    // Select Config
+    const existData = await db.query(
+      `SELECT ${tiny_search.select} FROM ${tiny_search.from}
+                WHERE ${tiny_search.where}${tiny_search.database.name}.${tiny_search.database.positionVar} ${tiny_direction} ? ORDER BY ${tiny_order} LIMIT 1`,
+      tiny_search.params,
+    );
+
+    // Exist Data
+    if (existData.length > 0) return existData[0];
+    else {
+      // Fix Where
+      if (tiny_search.where)
+        tiny_search.where = 'WHERE ' + tiny_search.where.substring(0, tiny_search.where.length - 5);
+
+      // Select Config
+      const existData2 = await db.query(
+        `SELECT ${tiny_search.select} FROM ${tiny_search.from}
+                    ${tiny_search.where} ORDER BY ${tiny_order} LIMIT 1`,
+        tiny_search.params,
+      );
+
+      // Exist Data
+      if (existData2.length > 0) return existData2[0];
+      else return null;
+    }
+  }
+
+  // Nope
+  else return null;
+}
+
+module.exports = nextPrev;

package/dist/legacy/firebase/mysqlConnector/nextPrev.d.mts

@@ -0,0 +1,31 @@
+/**
+ * Executes a directional query (next or previous) based on a position value and timestamp, returning a single row.
+ *
+ * @async
+ * @param {Object} db - The database instance with a `.query(sql, params)` method.
+ * @param {Object} tiny_search - Configuration object for the query.
+ * @param {string} tiny_search.select - SQL SELECT fields.
+ * @param {string} tiny_search.from - SQL FROM clause.
+ * @param {string} [tiny_search.where] - Optional WHERE clause (without 'WHERE') to filter results.
+ * @param {Array} tiny_search.params - Parameters for the query placeholders.
+ * @param {*} tiny_search.position - Value to compare in the directional filter (typically an ID or timestamp).
+ * @param {boolean} [tiny_search.direction_r=false] - If `true`, selects previous record (uses `<`), otherwise selects next (`>`).
+ * @param {Object} tiny_search.database - Object with database structure details.
+ * @param {string} tiny_search.database.name - The table name or alias used in the query.
+ * @param {string} tiny_search.database.timeVar - Column name used for ordering chronologically (e.g., `"created_at"`).
+ * @param {string} tiny_search.database.positionVar - Column name used for the directional condition (e.g., `"id"`).
+ * @returns {Promise<Object|null>} Resolves with the selected row or `null` if none is found.
+ */
+export default function nextPrev(db: Object, tiny_search: {
+    select: string;
+    from: string;
+    where?: string | undefined;
+    params: any[];
+    position: any;
+    direction_r?: boolean | undefined;
+    database: {
+        name: string;
+        timeVar: string;
+        positionVar: string;
+    };
+}): Promise<Object | null>;

package/dist/legacy/firebase/mysqlConnector/nextPrev.mjs

@@ -0,0 +1,63 @@
+/**
+ * Executes a directional query (next or previous) based on a position value and timestamp, returning a single row.
+ *
+ * @async
+ * @param {Object} db - The database instance with a `.query(sql, params)` method.
+ * @param {Object} tiny_search - Configuration object for the query.
+ * @param {string} tiny_search.select - SQL SELECT fields.
+ * @param {string} tiny_search.from - SQL FROM clause.
+ * @param {string} [tiny_search.where] - Optional WHERE clause (without 'WHERE') to filter results.
+ * @param {Array} tiny_search.params - Parameters for the query placeholders.
+ * @param {*} tiny_search.position - Value to compare in the directional filter (typically an ID or timestamp).
+ * @param {boolean} [tiny_search.direction_r=false] - If `true`, selects previous record (uses `<`), otherwise selects next (`>`).
+ * @param {Object} tiny_search.database - Object with database structure details.
+ * @param {string} tiny_search.database.name - The table name or alias used in the query.
+ * @param {string} tiny_search.database.timeVar - Column name used for ordering chronologically (e.g., `"created_at"`).
+ * @param {string} tiny_search.database.positionVar - Column name used for the directional condition (e.g., `"id"`).
+ * @returns {Promise<Object|null>} Resolves with the selected row or `null` if none is found.
+ */
+export default async function nextPrev(db, tiny_search) {
+    // Validate Database
+    if (tiny_search.database &&
+        typeof tiny_search.database.name === 'string' &&
+        typeof tiny_search.database.timeVar === 'string' &&
+        typeof tiny_search.database.positionVar === 'string') {
+        // Prepare Tiny Search
+        if (tiny_search.where)
+            tiny_search.where += ' AND ';
+        tiny_search.params.push(tiny_search.position);
+        // Select Direction
+        let tiny_direction = '';
+        let tiny_order = '';
+        if (tiny_search.direction_r) {
+            tiny_direction = '<';
+            tiny_order = `${tiny_search.database.name}.${tiny_search.database.timeVar} DESC`;
+        }
+        else {
+            tiny_direction = '>';
+            tiny_order = `${tiny_search.database.name}.${tiny_search.database.timeVar}`;
+        }
+        // Select Config
+        const existData = await db.query(`SELECT ${tiny_search.select} FROM ${tiny_search.from}
+                WHERE ${tiny_search.where}${tiny_search.database.name}.${tiny_search.database.positionVar} ${tiny_direction} ? ORDER BY ${tiny_order} LIMIT 1`, tiny_search.params);
+        // Exist Data
+        if (existData.length > 0)
+            return existData[0];
+        else {
+            // Fix Where
+            if (tiny_search.where)
+                tiny_search.where = 'WHERE ' + tiny_search.where.substring(0, tiny_search.where.length - 5);
+            // Select Config
+            const existData2 = await db.query(`SELECT ${tiny_search.select} FROM ${tiny_search.from}
+                    ${tiny_search.where} ORDER BY ${tiny_order} LIMIT 1`, tiny_search.params);
+            // Exist Data
+            if (existData2.length > 0)
+                return existData2[0];
+            else
+                return null;
+        }
+    }
+    // Nope
+    else
+        return null;
+}

package/dist/legacy/firebase/mysqlConnector/pagination.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * Executes a paginated query on the database, returning the result set along with pagination metadata.
+ *
+ * @async
+ * @param {Object} db - Database instance with a `.query(sql, params)` method.
+ * @param {Object} data - Query configuration options.
+ * @param {string} data.from - The table or view name to query from.
+ * @param {string} [data.where] - Optional WHERE clause without the keyword (e.g., `"status = 'active'"`).
+ * @param {Array} [data.params] - Optional parameters for the SQL query placeholders.
+ * @param {string} [data.select="*"] - Fields to select in the query.
+ * @param {string} data.order - SQL ORDER BY clause (e.g., `"created_at DESC"`).
+ * @param {number} [data.limit] - Number of rows per page.
+ * @param {number|string} [data.page] - Current page number or `'last'` to get the last page.
+ * @param {number} [data.count] - Optional total count override (skip count query if provided).
+ * @param {boolean} [data.count_rows=false] - Whether to include a row number for each result.
+ * @returns {Promise<Object>} Resolves with pagination metadata and result set.
+ * @returns {number} return.count - Total number of matched rows.
+ * @returns {Array} return.data - The paginated data from the query.
+ * @returns {number} return.pages - Total number of pages.
+ * @returns {number} return.page - Current page number after validation.
+ * @returns {number} return.start - Row offset used in the query.
+ */
+async function pagination(db, data) {
+  // Create Where
+  if (data.where) data.where = ' WHERE ' + data.where;
+  else data.where = '';
+
+  // Values
+  let start = 0;
+  let page;
+  let pages;
+  let edit_count;
+
+  if (typeof data.page === 'number') {
+    // Get Count
+    if (!data.count) {
+      edit_count = await db.query(`SELECT COUNT(*) FROM ${data.from}${data.where}`, data.params);
+      edit_count = edit_count[0]['COUNT(*)'];
+    } else edit_count = data.count;
+
+    // Prepare Numbers
+    pages = Math.ceil(edit_count / data.limit);
+
+    // Default
+    page = data.page;
+
+    // Is Last
+    if (page === 'last') page = pages;
+    // is NaN
+    else if (isNaN(page)) page = 1;
+    // Bigger
+    else if (page > pages) page = pages;
+    // Smaller
+    else if (page < 1) page = 1;
+
+    // Offset
+    if (page) start = Number(page - 1) * data.limit;
+    else {
+      start = 0;
+      page = 1;
+    }
+  }
+
+  if (!data.select) data.select = '*';
+
+  // Count Rows
+  let count_rows = {
+    select: '',
+    from: '',
+  };
+
+  if (data.count_rows)
+    count_rows = {
+      select: `(@row_number:=@row_number + 1) AS row_num, `,
+      from: `(SELECT @row_number:=${start}) AS row_number, `,
+    };
+
+  // Edits
+  let tiny_query = `SELECT ${count_rows.select}${data.select} FROM ${count_rows.from}${data.from}${data.where} ORDER BY ${data.order}`;
+  if (typeof data.limit === 'number') tiny_query += ` LIMIT ${data.limit}`;
+  if (typeof data.page === 'number') tiny_query += ` OFFSET ${start}`;
+
+  let edits = await db.query(tiny_query, data.params);
+
+  // Complete
+  return { count: edit_count, data: edits, pages: pages, page: page, start: start };
+}
+
+module.exports = pagination;

package/dist/legacy/firebase/mysqlConnector/pagination.d.mts

@@ -0,0 +1,33 @@
+/**
+ * Executes a paginated query on the database, returning the result set along with pagination metadata.
+ *
+ * @async
+ * @param {Object} db - Database instance with a `.query(sql, params)` method.
+ * @param {Object} data - Query configuration options.
+ * @param {string} data.from - The table or view name to query from.
+ * @param {string} [data.where] - Optional WHERE clause without the keyword (e.g., `"status = 'active'"`).
+ * @param {Array} [data.params] - Optional parameters for the SQL query placeholders.
+ * @param {string} [data.select="*"] - Fields to select in the query.
+ * @param {string} data.order - SQL ORDER BY clause (e.g., `"created_at DESC"`).
+ * @param {number} [data.limit] - Number of rows per page.
+ * @param {number|string} [data.page] - Current page number or `'last'` to get the last page.
+ * @param {number} [data.count] - Optional total count override (skip count query if provided).
+ * @param {boolean} [data.count_rows=false] - Whether to include a row number for each result.
+ * @returns {Promise<Object>} Resolves with pagination metadata and result set.
+ * @returns {number} return.count - Total number of matched rows.
+ * @returns {Array} return.data - The paginated data from the query.
+ * @returns {number} return.pages - Total number of pages.
+ * @returns {number} return.page - Current page number after validation.
+ * @returns {number} return.start - Row offset used in the query.
+ */
+export default function pagination(db: Object, data: {
+    from: string;
+    where?: string | undefined;
+    params?: any[] | undefined;
+    select?: string | undefined;
+    order: string;
+    limit?: number | undefined;
+    page?: string | number | undefined;
+    count?: number | undefined;
+    count_rows?: boolean | undefined;
+}): Promise<Object>;