sql-love 1.0.3 → 1.0.4

package/dist/index.d.ts

@@ -1,9 +1,732 @@
-export { default as Parser } from './src/Parser/Parser';
-export { default as SelectBuilder } from './src/SelectBuilder/SelectBuilder';
-export { default as extractGrouped } from './src/extractGrouped/extractGrouped';
-export { default as extractIndexed } from './src/extractIndexed/extractIndexed';
-export { default as extractLookup } from './src/extractLookup/extractLookup';
-export { default as getPagination } from './src/getPagination/getPagination';
-export { runMysql, runMysqlAsync, runMysqlAsyncWithCount, runMysqlWithCount, } from './src/runMysql/runMysql';
-export { runPrisma, runPrismaWithCount } from './src/runPrisma/runPrisma';
-export { toSafeJsonRecord, toSafeJsonRecords, toSafeJsonString, toSafeJsonValue, } from './src/toSafeJson/toSafeJson';
+// Generated by dts-bundle-generator v9.5.1
+
+export type FieldName = "option" | "options" | "select" | "column" | "columns" | "table" | "tables" | "join" | "joins" | "where" | "wheres" | "having" | "havings" | "groupBy" | "groupBys" | "orderBy" | "orderBys" | "limit" | "offset" | "page";
+export type EngineStyle = "mssql" | "mysql" | "oracle" | "pg";
+export type WhereCriteria = [
+	string,
+	string,
+	any
+] | [
+	string,
+	any
+] | [
+	string
+] | [
+	Record<string, any>
+];
+/**
+ * Build a select query
+ * Class Select
+ */
+export declare class SelectBuilder {
+	/**
+	 * The list of values to bind to the query
+	 * @private
+	 */
+	_bindings: any[];
+	/**
+	 * The list of strings to come immediately after "SELECT"
+	 * and before column names
+	 * @private
+	 */
+	_options: string[];
+	/**
+	 * The list of column names to select
+	 * @private
+	 */
+	_tables: string[];
+	/**
+	 * The list of tables in the FROM clause
+	 * @private
+	 */
+	_columns: string[];
+	/**
+	 * The list of JOIN strings to add
+	 * @private
+	 */
+	_joins: string[];
+	/**
+	 * The list of WHERE clauses to join with AND
+	 * @private
+	 */
+	_wheres: string[];
+	/**
+	 * The list of GROUP BY clauses to join with commas
+	 * @private
+	 */
+	_groupBys: string[];
+	/**
+	 * The list of HAVING clauses to join with AND
+	 * @private
+	 */
+	_havings: string[];
+	/**
+	 * The list of ORDER BY clauses to join with commas
+	 * @private
+	 */
+	_orderBys: string[];
+	/**
+	 * The LIMIT to use
+	 * @private
+	 */
+	_limit: number;
+	/**
+	 * The OFFSET to use
+	 * @private
+	 */
+	_offset: number;
+	/**
+	 * The page used to construct an OFFSET based on the LIMIT
+	 * @private
+	 */
+	_page: number;
+	/**
+	 * Select constructor
+	 * @param [sql]  A base SQL query to parse
+	 * @param [bindings]  Placeholders to bind to the query
+	 */
+	constructor(sql?: string, bindings?: Record<string, any>);
+	/**
+	 * Set the default database engine style (mssql, mysql, oracle, pg)
+	 * @param engine
+	 */
+	static setDefaultEngine(engine: EngineStyle): typeof SelectBuilder;
+	/**
+	 * Get the SQL as a pretty-printed string alongside an array of bindings
+	 * @param engine  The database engine style (mssql, mysql, oracle, pg)
+	 * @return The SQL query as a string
+	 */
+	compile({ engine, bindingIndex, }?: {
+		engine?: EngineStyle;
+		bindingIndex?: number;
+	}): {
+		sql: string;
+		bindings: any;
+	};
+	_compileLIMIT(engineStyle: EngineStyle, limit: number): string;
+	_compileOFFSET(engineStyle: EngineStyle, offset: number): string;
+	/**
+	 * Get SQL needed to return the found rows of this query
+	 * @param engineStyle  The database engine style (mssql, mysql, oracle, pg)
+	 * @param countExpr  The expression to use inside the COUNT()
+	 */
+	compileCount({ countExpr, engine, bindingIndex, }?: {
+		countExpr?: string;
+		engine?: EngineStyle;
+		bindingIndex?: number;
+	}): {
+		sql: string;
+		bindings: any;
+	};
+	/**
+	 * Get SQL needed to union this query with another
+	 * @param query  The query to union
+	 * @param engine  The database engine style (mssql, mysql, oracle, pg)
+	 */
+	compileUnion(query: SelectBuilder, { engine, bindingIndex, }?: {
+		engine?: EngineStyle;
+		bindingIndex?: number;
+	}): {
+		sql: string;
+		bindings: any[];
+	};
+	/**
+	 * @param  [fieldOrFields]  If given, reset the given component(s), otherwise reset all query components
+	 *   Valid components: option, column, table, where, orWhere, having, groupBy, orderBy, limit, offset, page
+	 * @return This object
+	 */
+	reset(fieldOrFields?: FieldName | FieldName[]): this;
+	/**
+	 * Clone this builder object
+	 */
+	getClone(): SelectBuilder;
+	/**
+	 * Build a version of this query that simply returns COUNT(*)
+	 * @param [countExpr="*"]  Use to specify `DISTINCT colname` if needed
+	 */
+	getFoundRowsQuery(countExpr?: string): SelectBuilder;
+	/**
+	 * Add an array of column names to fetch
+	 * @param columnNames  The names of columns
+	 */
+	select(columnNames: string[]): this;
+	/**
+	 * Add an array of column names to fetch
+	 * @param columnNames  The names of columns
+	 */
+	columns(columnNames: string[]): this;
+	/**
+	 * Add a column name to fetch
+	 * @param columnName  The name of the column
+	 */
+	column(columnName: string): this;
+	/**
+	 * Add an option expression such as "TOP 10" or "SQL_CALC_FOUND_ROWS"
+	 * @param optionExpression  Expression to go after "SELECT" and before column list
+	 */
+	option(optionExpression: string): this;
+	/**
+	 * Add a table to the "FROM" clause (same as .from())
+	 * @param {String} tableName  The name of the table to query
+	 * @return {Select}
+	 */
+	table(tableName: string): this;
+	/**
+	 * Add multiple table to the "FROM" clause
+	 * @param {Array} tableNames  The names of the tables to query
+	 * @return {Select}
+	 */
+	tables(tableNames: string[]): this;
+	/**
+	 * Add a table to the "FROM" clause (same as .table())
+	 * @param {String} tableName  The name of the table to query
+	 * @return {Select}
+	 */
+	from(tableName: string): this;
+	/**
+	 * Add the given join type expression
+	 * @param joinType  The type of join (e.g. "INNER JOIN", "LEFT JOIN", etc.)
+	 * @param expression  The expression following the INNER JOIN keyword
+	 * @param bindings  A list of values to bind to ? placeholders in the expression
+	 * @example
+	 *   query.join('posts p ON p.id = c.post_id');
+	 *   query.join('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
+	 */
+	_addJoin(joinType: string, expression: string, bindings?: any[]): void;
+	/**
+	 * Add a JOIN expression
+	 * @param expression  The expression following the INNER JOIN keyword
+	 * @param bindings  A list of values to bind to ? placeholders in the expression
+	 * @example
+	 *   query.join('posts p ON p.id = c.post_id');
+	 *   query.join('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
+	 */
+	join(expression: string, bindings?: any[]): this;
+	/**
+	 * Add a LEFT JOIN expression
+	 * @param expression  The expression following the LEFT JOIN keyword
+	 * @param bindings  A list of values to bind to ? placeholders in the expression
+	 * @example
+	 *   query.leftJoin('posts p ON p.id = c.post_id');
+	 *   query.leftJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
+	 */
+	leftJoin(expression: string, bindings?: any[]): this;
+	/**
+	 * Add a FULL JOIN expression
+	 * @param expression  The expression following the FULL JOIN keyword
+	 * @param bindings  A list of values to bind to ? placeholders in the expression
+	 * @example
+	 *   query.fullJoin('posts p ON p.id = c.post_id');
+	 *   query.fullJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
+	 */
+	fullJoin(expression: string, bindings?: any[]): this;
+	/**
+	 * Add a RIGHT JOIN expression
+	 * @param expression  The expression following the RIGHT JOIN keyword
+	 * @param bindings  A list of values to bind to ? placeholders in the expression
+	 * @example
+	 *   query.rightJoin('posts p ON p.id = c.post_id');
+	 *   query.rightJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
+	 */
+	rightJoin(expression: string, bindings?: any[]): this;
+	/**
+	 * Add a CROSS JOIN expression
+	 * @param expression  The expression following the CROSS JOIN keyword
+	 * @param bindings  A list of values to bind to ? placeholders in the expression
+	 * @example
+	 *   query.crossJoin('posts p ON p.id = c.post_id');
+	 *   query.crossJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
+	 */
+	crossJoin(expression: string, bindings?: any[]): this;
+	/**
+	 * Add an INNER JOIN expression (same as ->join())
+	 * @param expression  The expression following the INNER JOIN keyword
+	 * @param bindings  A list of values to bind to ? placeholders in the expression
+	 * @example
+	 *   query.innerJoin('posts p ON p.id = c.post_id');
+	 *   query.innerJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
+	 */
+	innerJoin(expression: string, bindings?: any[]): this;
+	/**
+	 * Add a LEFT OUTER JOIN expression
+	 * @param expression  The expression following the LEFT OUTER JOIN keyword
+	 * @param bindings  A list of values to bind to ? placeholders in the expression
+	 * @example
+	 *   query.leftOuterJoin('posts p ON p.id = c.post_id');
+	 *   query.leftOuterJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
+	 */
+	leftOuterJoin(expression: string, bindings?: any[]): this;
+	/**
+	 * Add a FULL OUTER JOIN expression
+	 * @param expression  The expression following the FULL OUTER JOIN keyword
+	 * @param bindings  A list of values to bind to ? placeholders in the expression
+	 * @example
+	 *   query.fullOuterJoin('posts p ON p.id = c.post_id');
+	 *   query.fullOuterJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
+	 */
+	fullOuterJoin(expression: string, bindings?: any[]): this;
+	/**
+	 * Add a RIGHT OUTER JOIN expression
+	 * @param expression  The expression following the RIGHT OUTER JOIN keyword
+	 * @param bindings  A list of values to bind to ? placeholders in the expression
+	 * @example
+	 *   query.rightOuterJoin('posts p ON p.id = c.post_id');
+	 *   query.rightOuterJoin('posts p ON p.id = c.post_id AND p.deleted_at < ?', [myDate]);
+	 */
+	rightOuterJoin(expression: string, bindings?: any[]): this;
+	/**
+	 * Remove a join condition with the specified table
+	 * @param table  The name of the table or tables in the first part of the join statement
+	 */
+	unjoin(table: string | string[]): this;
+	/**
+	 * Utility function to add conditions for a clause (WHERE, HAVING)
+	 * @param  collection  The collection to add the clauses to (e.g. this._wheres or this._havings)
+	 * @param  criteria  Criteria adhering to WhereCriteria type
+	 * @example  The following are equivalent
+	 *   this._conditions(this._wheres, ['deleted_at IS NULL']);
+	 *   this._conditions(this._wheres, ['deleted_at', null]);
+	 *   this._conditions(this._wheres, ['deleted_at', '=', null]);
+	 * @example  More examples
+	 *   this._conditions(this._wheres, ['fname', 'LIKE', 'joe']); // `fname` LIKE 'joe'
+	 *   this._conditions(this._wheres, ['fname', 'LIKE ?', 'joe']); // `fname` LIKE 'joe'
+	 *   this._conditions(this._wheres, ['fname LIKE %?%', 'joe']); // `fname` LIKE '%joe%'
+	 *   this._conditions(this._wheres, ['fname LIKE ?%', 'joe']); // `fname` LIKE 'joe%'
+	 *   this._conditions(this._wheres, ['fname', 'LIKE ?%', 'joe']); // `fname` LIKE 'joe%'
+	 *   this._conditions(this._wheres, ['price >', 10]); // `price` > 10
+	 *   this._conditions(this._wheres, ['price', '>', 10]); // `price` > 10
+	 *   this._conditions(this._wheres, ['price =', 10]); // `price` = 10
+	 *   this._conditions(this._wheres, ['price !=', 10]); // `price` != 10
+	 *   this._conditions(this._wheres, ['price', 10]); // `price` = 10
+	 *   this._conditions(this._wheres, ['price', '=', 10]); // `price` = 10
+	 *   this._conditions(this._wheres, ['price', '!=', 10]); // `price` != 10
+	 *   this._conditions(this._wheres, ['price', 'BETWEEN', [10,20]]); // `price` BETWEEN 10 AND 20
+	 *   this._conditions(this._wheres, ['price', 'NOT BETWEEN', [10,20]]); // `price` NOT BETWEEN 10 AND 20
+	 *   this._conditions(this._wheres, ['price', [10,20]]); // `price` IN(10,20)
+	 *   this._conditions(this._wheres, ['price', '=', [10,20]]); // `price` IN(10,20)
+	 *   this._conditions(this._wheres, ['price', 'IN', [10,20]]); // `price` IN(10,20)
+	 *   this._conditions(this._wheres, ['price', 'NOT IN', [10,20]]); // `price` NOT IN(10,20)
+	 */
+	_conditions(collection: string[], criteria: WhereCriteria): this;
+	/**
+	 * Add a group by column or expression
+	 * @param column  The name of a column (or expression) to group by
+	 */
+	groupBy(column: string): this;
+	/**
+	 * Add WHERE clauses to conditions (See _conditions for usage)
+	 */
+	where(...args: WhereCriteria): this;
+	/**
+	 * Add a WHERE clause with a BETWEEN condition
+	 * @param column  The column name
+	 * @param twoValueArray  The two values to be between
+	 */
+	whereBetween(column: string, twoValueArray: [
+		any,
+		any
+	]): this;
+	/**
+	 * Add a series of WHERE clauses joined by OR (See _conditions for usage)
+	 * @param conditions
+	 */
+	_orConditions(conditions: WhereCriteria[] | Record<string, any>[] | Record<string, any>): string;
+	/**
+	 * Add WHERE conditions to place inside an OR block (See _conditions for usage)
+	 * @param conditions  A list or object where each item is an array with parameters that would be taken by where()
+	 */
+	orWhere(conditions: WhereCriteria[] | Record<string, any>[] | Record<string, any>): this;
+	/**
+	 * Add an OR with conditions under the HAVING clause
+	 * @param conditions  A list or object where each item is an array with parameters that would be taken by having()
+	 */
+	orHaving(conditions: WhereCriteria[] | Record<string, any>[] | Record<string, any>): this;
+	/**
+	 * Add a HAVING condition (See _conditions for usage)
+	 */
+	having(...args: WhereCriteria): this;
+	/**
+	 * Add a column or expression to order by
+	 * @param column  The column name or expression to sort by. Include DESC or prefix with - to sort descending
+	 * @param [direction]  The direction to sort by (ASC or DESC)
+	 * @example
+	 *   query.sortField('modified_at'); // ORDER BY modified_at
+	 *   query.sortField('-modified_at'); // ORDER BY modified_at DESC
+	 *   query.sortField('COUNT(*)'); // ORDER BY COUNT(*)
+	 *   query.sortField('COUNT(*) DESC'); // ORDER BY COUNT(*) DESC
+	 */
+	orderBy(column: string, direction?: "ASC" | "DESC"): this;
+	/**
+	 * Sort by the given column, with a map of columns to translate
+	 * @param fieldName  The file name such as "created_at" or "-created_at" for descending
+	 * @param [mapNames]  Column names to translate from field to column expression
+	 * @example
+	 *   query.sortField('-modified_at'); // ORDER BY modified_at DESC
+	 *   query.sortField('-created', {'created': 'created_at'}); // ORDER BY created_at DESC
+	 */
+	sortField(fieldName: string, mapNames?: Record<string, string>): this;
+	/**
+	 * Check to see if the given string is 0 or all digits not starting with 0
+	 * @param string  The input string
+	 * @private
+	 */
+	_isEntirelyDigits(string: string): boolean;
+	/**
+	 * Check to see if the given string is all digits
+	 * @param string  The input string
+	 * @private
+	 */
+	_isEntirelyDigitsNoZeros(string: string): boolean;
+	/**
+	 * Limit results to the given number
+	 * @param max  The number to limit by (placeholder string or integer greater than 0)
+	 */
+	limit(max: number | string): this;
+	/**
+	 * Fetch results from the given offset
+	 * @param number  The offset (placeholder string or integer greater than or equal to 0)
+	 */
+	offset(number: number | string): this;
+	/**
+	 * Set the offset based on the limit with the given page number
+	 * @param number  The page number (integer greater than 0)
+	 */
+	page(number: number | string): this;
+}
+/**
+ * Parse SQL and populate onto a Select query object
+ */
+export declare class Parser {
+	query: SelectBuilder;
+	/**
+	 * Create a new instance
+	 * @param query  A Select object on which to build parsed conditions
+	 */
+	constructor(query: SelectBuilder);
+	/**
+	 * Strip single-line and multi-line comment blocks
+	 * @param sql  The SQL string
+	 * @return  The SQL string without comments
+	 * @private
+	 */
+	_stripComments(sql: string): string;
+	/**
+	 * Before splitting into SQL clauses, extract some regex-able subQueries
+	 * @param sql  The unparsed sql string
+	 * @return  An array with new sql and subQueries
+	 * @private
+	 */
+	_extractSubQueries(sql: string): {
+		sql: string;
+		subQueries: {};
+	};
+	/**
+	 * Inject column subQueries back into this object
+	 * @param subQueries  The lookup of extracted subQueries
+	 * @private
+	 */
+	_injectSubQueries(subQueries: Record<string, string>): void;
+	/**
+	 * Split SQL into clauses (used by parse())
+	 * @param sql  The SQL to split
+	 * @return
+	 * @private
+	 */
+	_split(sql: string): string[];
+	/**
+	 * Get a QuickSelect object representing the given SQL SELECT statement
+	 * @param  rawSql  The raw SQL for the SELECT statement
+	 * @return True if the SQL was parsed successfully
+	 */
+	parse(rawSql: string): boolean;
+	/**
+	 * Handle SQL_CALC_FOUND_ROWS and column names
+	 * @param clause  The clause after the SELECT
+	 * @private
+	 */
+	_handleSELECT(clause: string): void;
+	/**
+	 * Handle table names
+	 * @param clause  The clause after the FROM
+	 * @private
+	 */
+	_handleFROM(clause: string): void;
+	/**
+	 * Handle INNER JOIN statements
+	 * @param clause  The clause after the INNER JOIN
+	 * @private
+	 */
+	_handleINNER_JOIN(clause: string): void;
+	/**
+	 * Handle LEFT JOIN statements
+	 * @param clause  The clause after the LEFT JOIN
+	 * @private
+	 */
+	_handleLEFT_JOIN(clause: string): void;
+	/**
+	 * Handle LEFT OUTER JOIN statements
+	 * @param clause  The clause after the LEFT OUTER JOIN
+	 * @private
+	 */
+	_handleLEFT_OUTER_JOIN(clause: string): void;
+	/**
+	 * Handle RIGHT JOIN statements
+	 * @param clause  The clause after the RIGHT JOIN
+	 * @private
+	 */
+	_handleRIGHT_JOIN(clause: string): void;
+	/**
+	 * Handle RIGHT OUTER JOIN statements
+	 * @param clause  The clause after the RIGHT OUTER JOIN
+	 * @private
+	 */
+	_handleRIGHT_OUTER_JOIN(clause: string): void;
+	/**
+	 * Handle CROSS JOIN statements
+	 * @param clause  The clause after the CROSS JOIN
+	 * @private
+	 */
+	_handleCROSS_JOIN(clause: string): void;
+	/**
+	 * Handle FULL JOIN statements
+	 * @param clause  The clause after the FULL JOIN
+	 * @private
+	 */
+	_handleFULL_JOIN(clause: string): void;
+	/**
+	 * Handle FULL OUTER JOIN statements
+	 * @param clause  The clause after the FULL OUTER JOIN
+	 * @private
+	 */
+	_handleFULL_OUTER_JOIN(clause: string): void;
+	/**
+	 * Handle WHERE conditions
+	 * @param clause  All the conditions after WHERE
+	 * @private
+	 */
+	_handleWHERE(clause: string): void;
+	/**
+	 * Handle HAVING statements
+	 * @param clause  All the conditions after HAVING
+	 * @private
+	 */
+	_handleHAVING(clause: string): void;
+	/**
+	 * Build a conditions list
+	 * @param type  Either where or having
+	 * @param clause  The expressions following the type keyword
+	 * @private
+	 */
+	_handleConditions(type: "where" | "having", clause: string): void;
+	/**
+	 * Handle GROUP BY statements
+	 * @param clause  The clauses after the GROUP BY
+	 * @private
+	 */
+	_handleGROUP_BY(clause: string): void;
+	/**
+	 * Handle ORDER BY statements
+	 * @param clause  The clause after the ORDER BY
+	 * @private
+	 */
+	_handleORDER_BY(clause: string): void;
+	/**
+	 * Handle LIMIT statements including "LIMIT #" and "LIMIT #, #"
+	 * @param clause  The clause after the LIMIT
+	 * @private
+	 */
+	_handleLIMIT(clause: string): void;
+	/**
+	 * Handle OFFSET statements
+	 * @param clause  The number after the OFFSET
+	 * @private
+	 */
+	_handleOFFSET(clause: string): void;
+	/**
+	 * Handle OFFSET statements
+	 * @param clause  The number after the OFFSET
+	 * @private
+	 */
+	_handleFETCH_NEXT(clause: string): void;
+}
+/**
+ * Group database rows by a column value
+ * @param field  The database column to group by
+ * @param records  Records from the database
+ * @example
+ * extractGrouped('org', users); // result:
+ * {
+ *     "Marketing": [
+ *         { id: 1, name: "John", org: "Marketing" },
+ *         { id: 2, name: "Jane", org: "Marketing" },
+ *     ],
+ *     "Finance": [
+ *         { id: 3, name: "Jose", org: "Finance" },
+ *     ],
+ * }
+ */
+export function extractGrouped<DbRecord extends Record<string, any>>(field: keyof DbRecord, records: DbRecord[]): Record<string, DbRecord[]>;
+/**
+ * Index each database row by a column value
+ * @param field  The database column to index by
+ * @param records  Records from the database
+ * @example
+ * extractIndexed('id', users); // result:
+ * {
+ *   "1": { id: 1, name: "John" },
+ *   "2": { id: 2, name: "Jane" },
+ * }
+ */
+export function extractIndexed<DbRecord extends Record<string, any>>(field: keyof DbRecord, records: DbRecord[]): Record<string, DbRecord>;
+/**
+ * Given an array of records, extract an object with keyField-valueField pairs
+ * @param records  An array of records
+ * @param keyField  The field to use as the key
+ * @param valueField  The field to use as the value
+ */
+export function extractLookup<T extends Array<Record<K | V, any>>, K extends keyof T[number], V extends keyof T[number]>(keyField: K, valueField: V, records: T): {
+	[key in T[number][K]]: T[number][V];
+};
+/**
+ * Given a foundRows number of records and a limit, return the foundRows number of pages
+ * @param query  The query that was just run
+ * @param total  The number of records if there were no limit
+ */
+export function getPagination(query: SelectBuilder, total: BigInt | number): {
+	page: number;
+	prevPage: number;
+	nextPage: number;
+	perPage: number;
+	numPages: number;
+	total: number;
+	isFirst: boolean;
+	isLast: boolean;
+};
+export interface MysqlClient {
+	query: (sql: string, bindings: any[], callback: (err: Error | null, results: Array<Record<string, any>>, fields: any[]) => void) => void;
+}
+export interface MysqlAsyncClient {
+	query: (sql: string, bindings: any[]) => Promise<[
+		Array<Record<string, any>>,
+		any[]
+	]>;
+}
+/**
+ * Run the given query with mysql and return the results
+ * @param mysqlClient  A client created with mysql.createConnection()  or mysql.createPool()
+ * @param query  The SelectBuilder query to run
+ */
+export declare function runMysql(mysqlClient: MysqlClient, query: SelectBuilder): Promise<[
+	Array<Record<string, any>>,
+	any[]
+]>;
+/**
+ * Run the given query with mysql and return the results, count, and pagination
+ * @param mysqlClient  A client created with mysql.createConnection()  or mysql.createPool()
+ * @param query  The SelectBuilder query to run
+ * @param options
+ * @param options.countExpr  The SQL expression to use for the count (default "*")
+ */
+export declare function runMysqlWithCount(mysqlClient: MysqlClient, query: SelectBuilder, { countExpr }?: {
+	countExpr?: string;
+}): Promise<{
+	records: Record<string, any>[];
+	total: any;
+	pagination: {
+		page: number;
+		prevPage: number;
+		nextPage: number;
+		perPage: number;
+		numPages: number;
+		total: number;
+		isFirst: boolean;
+		isLast: boolean;
+	};
+	fields: any[];
+}>;
+export declare function runMysqlAsync(mysqlClient: MysqlAsyncClient, query: SelectBuilder): Promise<[
+	Array<Record<string, any>>,
+	any[]
+]>;
+export declare function runMysqlAsyncWithCount(mysqlClient: MysqlAsyncClient, query: SelectBuilder, { engine, countExpr, }?: {
+	engine?: EngineStyle;
+	countExpr?: string;
+}): Promise<{
+	records: Record<string, any>[];
+	total: any;
+	pagination: {
+		page: number;
+		prevPage: number;
+		nextPage: number;
+		perPage: number;
+		numPages: number;
+		total: number;
+		isFirst: boolean;
+		isLast: boolean;
+	};
+	fields: any[];
+}>;
+export interface PrismaClient {
+	$queryRawUnsafe: (sql: string, ...bindings: any[]) => Promise<Array<Record<string, any>>>;
+}
+/**
+ * Run the given query with prisma and return the results
+ * @param prisma  The prisma client instance
+ * @param query  The SelectBuilder query to run
+ * @param options
+ * @param options.engine  The engine style to use ("mssql" | "mysql" | "oracle" | "pg")
+ */
+export declare function runPrisma<T extends Array<Record<string, any>> = Array<Record<string, any>>>(prisma: PrismaClient, query: SelectBuilder, { engine }?: {
+	engine?: EngineStyle;
+}): Promise<T>;
+/**
+ * Run the given query with prisma and return the results, count, and pagination
+ * @param prisma  The prisma client instance
+ * @param query  The SelectBuilder query to run
+ * @param options
+ * @param options.engine  The engine style to use ("mssql" | "mysql" | "oracle" | "pg")
+ * @param options.countExpr  The SQL expression to use for the count (default "*")
+ */
+export declare function runPrismaWithCount<T extends Array<Record<string, any>> = Array<Record<string, any>>>(prisma: PrismaClient, query: SelectBuilder, { engine, countExpr, }?: {
+	engine?: EngineStyle;
+	countExpr?: string;
+}): Promise<{
+	records: T;
+	total: number;
+	pagination: {
+		page: number;
+		prevPage: number;
+		nextPage: number;
+		perPage: number;
+		numPages: number;
+		total: number;
+		isFirst: boolean;
+		isLast: boolean;
+	};
+}>;
+export type SafeValue<T> = T extends BigInt ? number | string : T;
+export type SafeRecord<T> = Record<string, SafeValue<T>>;
+export type SafeRecords<T> = Array<SafeRecord<T>>;
+/**
+ * Convert a value to a value that can be safely serialized to JSON
+ * @param value
+ */
+export declare function toSafeJsonValue<T>(value: T): SafeValue<T>;
+/**
+ * Convert a record to one that can be safely serialized to JSON
+ * @param record
+ */
+export declare function toSafeJsonRecord<T extends Record<string, any>>(record: T): SafeRecord<T>;
+/**
+ * Convert a recordset to one that can be safely serialized to JSON
+ * @param records
+ */
+export declare function toSafeJsonRecords<T extends Record<string, any>>(records: T[]): SafeRecords<T>;
+/**
+ * JSON stringify a value or data structure, ensuring first that all values are
+ *   safe to serialize
+ * @param records
+ */
+export declare function toSafeJsonString(records: Array<Record<string, any>>): string;
+
+export {};