sql-love 1.0.2 → 1.0.4

package/dist/src/Parser/Parser.js

@@ -1,304 +0,0 @@
-/**
- * Parse SQL and populate onto a Select query object
- */
-export default class Parser {
-    query;
-    /**
-     * Create a new instance
-     * @param query  A Select object on which to build parsed conditions
-     */
-    constructor(query) {
-        this.query = query;
-    }
-    /**
-     * Strip single-line and multi-line comment blocks
-     * @param sql  The SQL string
-     * @return  The SQL string without comments
-     * @private
-     */
-    _stripComments(sql) {
-        // multiline comments
-        sql = sql.replace(/\/\*[\s\S]*?\*\//g, '');
-        // single line comments -- dashes
-        sql = sql.replace(/--([\r\n]|\s+[^\r\n]+[\r\n])/g, '');
-        // single line comments #hashes
-        sql = sql.replace(/#[^\r\n]+[\r\n]/g, '');
-        return sql;
-    }
-    /**
-     * 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) {
-        const subQueries = {};
-        let i = 0;
-        const extractor = $0 => {
-            const placeholder = `~~SUBQUERY_${i++}~~`;
-            subQueries[placeholder] = $0;
-            return placeholder;
-        };
-        // subselect in FROM clause
-        sql = sql.replace(/\(\s*SELECT\s+.+\)\s+AS\s+[^\s,]+/, extractor);
-        // IF() in FROM clause
-        sql = sql.replace(/\bIF\s*\(.+\)\s+AS\s+[^\s,]+/, extractor);
-        // IN (SELECT *) in JOINs, WHERE or HAVING
-        sql = sql.replace(/\bIN\s*\(\s*SELECT\s.+?\)/, extractor);
-        return { sql, subQueries };
-    }
-    /**
-     * Inject column subQueries back into this object
-     * @param subQueries  The lookup of extracted subQueries
-     * @private
-     */
-    _injectSubQueries(subQueries) {
-        const replacer = $0 => {
-            return subQueries[$0] || $0;
-        };
-        const mapper = clause => {
-            return clause.replace(/~~SUBQUERY_\d+~~/g, replacer);
-        };
-        this.query._columns = this.query._columns.map(replacer);
-        this.query._joins = this.query._joins.map(mapper);
-        this.query._wheres = this.query._wheres.map(mapper);
-        this.query._havings = this.query._havings.map(mapper);
-    }
-    /**
-     * Split SQL into clauses (used by parse())
-     * @param sql  The SQL to split
-     * @return
-     * @private
-     */
-    _split(sql) {
-        const splitter = /(?:^|\s)(SELECT|FROM|(?:INNER|LEFT\s+OUTER|RIGHT\s+OUTER|LEFT|RIGHT|CROSS|FULL|FULL\s+OUTER)\s+JOIN|WHERE|GROUP\s+BY|HAVING|ORDER\s+BY|LIMIT|OFFSET|FETCH\s+NEXT)\b/i;
-        return sql.split(splitter);
-    }
-    /**
-     * 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) {
-        const stripped = this._stripComments(rawSql);
-        const { sql, subQueries } = this._extractSubQueries(stripped);
-        const expressions = this._split(sql);
-        let i = 1;
-        while (i < expressions.length) {
-            const rawKeyword = expressions[i++].trim();
-            const keyword = rawKeyword.toUpperCase().replace(/\s+/g, '_');
-            const clause = expressions[i++].trim();
-            const handler = `_handle${keyword}`;
-            this[handler](clause);
-        }
-        this._injectSubQueries(subQueries);
-        return true;
-    }
-    /**
-     * Handle SQL_CALC_FOUND_ROWS and column names
-     * @param clause  The clause after the SELECT
-     * @private
-     */
-    _handleSELECT(clause) {
-        let columns = clause.split(/s*,s*/);
-        // now handle parenthesis expressions that contain commas
-        let buffer = '';
-        columns.forEach((column, i) => {
-            if (i === 0) {
-                const optionRegex = /^(SQL_CALC_FOUND_ROWS)\s+/i;
-                const match = column.match(optionRegex);
-                if (match) {
-                    this.query.option(match[1]);
-                    column = column.replace(optionRegex, '');
-                }
-            }
-            if (buffer.length) {
-                // we are in the middle of an expression containing parenthesis
-                if (column.indexOf(')') > 0) {
-                    // we have an end parenthesis
-                    buffer += column;
-                    this.query.column(buffer.trim());
-                    buffer = '';
-                }
-                else {
-                    buffer += column + ',';
-                }
-            }
-            else if (column.match(/\([^)]+$/)) {
-                buffer = column + ',';
-            }
-            else {
-                this.query.column(column.trim());
-            }
-        });
-    }
-    /**
-     * Handle table names
-     * @param clause  The clause after the FROM
-     * @private
-     */
-    _handleFROM(clause) {
-        const tables = clause.split(/\s*,\s*/);
-        tables.forEach(table => this.query.table(table));
-    }
-    /**
-     * Handle INNER JOIN statements
-     * @param clause  The clause after the INNER JOIN
-     * @private
-     */
-    _handleINNER_JOIN(clause) {
-        this.query.innerJoin(clause);
-    }
-    /**
-     * Handle LEFT JOIN statements
-     * @param clause  The clause after the LEFT JOIN
-     * @private
-     */
-    _handleLEFT_JOIN(clause) {
-        this.query.leftJoin(clause);
-    }
-    /**
-     * Handle LEFT OUTER JOIN statements
-     * @param clause  The clause after the LEFT OUTER JOIN
-     * @private
-     */
-    _handleLEFT_OUTER_JOIN(clause) {
-        this.query.leftOuterJoin(clause);
-    }
-    /**
-     * Handle RIGHT JOIN statements
-     * @param clause  The clause after the RIGHT JOIN
-     * @private
-     */
-    _handleRIGHT_JOIN(clause) {
-        this.query.rightJoin(clause);
-    }
-    /**
-     * Handle RIGHT OUTER JOIN statements
-     * @param clause  The clause after the RIGHT OUTER JOIN
-     * @private
-     */
-    _handleRIGHT_OUTER_JOIN(clause) {
-        this.query.rightOuterJoin(clause);
-    }
-    /**
-     * Handle CROSS JOIN statements
-     * @param clause  The clause after the CROSS JOIN
-     * @private
-     */
-    _handleCROSS_JOIN(clause) {
-        this.query.crossJoin(clause);
-    }
-    /**
-     * Handle FULL JOIN statements
-     * @param clause  The clause after the FULL JOIN
-     * @private
-     */
-    _handleFULL_JOIN(clause) {
-        this.query.fullJoin(clause);
-    }
-    /**
-     * Handle FULL OUTER JOIN statements
-     * @param clause  The clause after the FULL OUTER JOIN
-     * @private
-     */
-    _handleFULL_OUTER_JOIN(clause) {
-        this.query.fullOuterJoin(clause);
-    }
-    /**
-     * Handle WHERE conditions
-     * @param clause  All the conditions after WHERE
-     * @private
-     */
-    _handleWHERE(clause) {
-        if (/^(1|'1'|true)$/i.test(clause)) {
-            this.query._wheres.push(clause);
-        }
-        else {
-            this._handleConditions('where', clause);
-        }
-    }
-    /**
-     * Handle HAVING statements
-     * @param clause  All the conditions after HAVING
-     * @private
-     */
-    _handleHAVING(clause) {
-        this._handleConditions('having', clause);
-    }
-    /**
-     * Build a conditions list
-     * @param type  Either where or having
-     * @param clause  The expressions following the type keyword
-     * @private
-     */
-    _handleConditions(type, clause) {
-        const andGroups = clause.split(/\bAND\b/i);
-        andGroups.forEach(andGroup => {
-            const orPieces = andGroup.split(/\bOR\b/i).map(str => str.trim());
-            if (orPieces.length === 1) {
-                // no OR operators
-                const fn = type; // either where or having
-                this.query[fn](orPieces[0]);
-            }
-            else {
-                // some OR operators
-                // either orWhere or orHaving
-                const orFn = type === 'where' ? 'orWhere' : 'orHaving';
-                this.query[orFn](orPieces.map(p => [p]));
-            }
-        });
-    }
-    /**
-     * Handle GROUP BY statements
-     * @param clause  The clauses after the GROUP BY
-     * @private
-     */
-    _handleGROUP_BY(clause) {
-        const columns = clause.split(/\s*,\s*/);
-        columns.forEach(column => this.query.groupBy(column));
-    }
-    /**
-     * Handle ORDER BY statements
-     * @param clause  The clause after the ORDER BY
-     * @private
-     */
-    _handleORDER_BY(clause) {
-        const columns = clause.split(/\s*,\s*/);
-        columns.forEach(column => this.query.orderBy(column));
-    }
-    /**
-     * Handle LIMIT statements including "LIMIT #" and "LIMIT #, #"
-     * @param clause  The clause after the LIMIT
-     * @private
-     */
-    _handleLIMIT(clause) {
-        const offsetLimit = clause.match(/^(\d+|\?|:\w+)\s*,\s*(\d+|\?|:\w+)$/);
-        if (offsetLimit) {
-            this.query.offset(offsetLimit[1]);
-            this.query.limit(offsetLimit[2]);
-        }
-        else {
-            clause = clause.replace(/ ROWS$/i, '');
-            this.query.limit(clause);
-        }
-    }
-    /**
-     * Handle OFFSET statements
-     * @param clause  The number after the OFFSET
-     * @private
-     */
-    _handleOFFSET(clause) {
-        clause = clause.replace(/^(\d+) ROWS$/i, '$1');
-        this.query.offset(clause);
-    }
-    /**
-     * Handle OFFSET statements
-     * @param clause  The number after the OFFSET
-     * @private
-     */
-    _handleFETCH_NEXT(clause) {
-        clause = clause.replace(/^(\d+) ROWS ONLY$/i, '$1');
-        this.query.limit(clause);
-    }
-}

package/dist/src/SelectBuilder/SelectBuilder.d.ts

@@ -1,379 +0,0 @@
-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 default 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;
-}