// Originally based on contributions to DefinitelyTyped: // Definitions by: Qubo // Pablo Rodríguez // Matt R. Wilson // Satana Charuwichitratana // Shrey Jain // TypeScript Version: 3.7 import tarn = require('tarn'); import events = require('events'); import stream = require('stream'); import ResultTypes = require('./result'); import { Tables } from './tables'; import { ConnectionOptions } from "tls"; import { Stream } from "stream"; // # Generic type-level utilities // If T is object then make it a partial otherwise fallback to any // // This is primarily to prevent type incompatibilities where target can be unknown. // While unknown can be assigned to any, Partial can't be. type SafePartial = Partial>; type MaybeArray = T | T[]; type StrKey = string & keyof T; // If T is unknown then convert to any, else retain original type UnknownToAny = unknown extends T ? any : T; type AnyToUnknown = unknown extends T ? unknown : T; type AnyOrUnknownToOther = unknown extends T1 ? T2 : T1; // Intersection conditionally applied only when TParams is non-empty // This is primarily to keep the signatures more intuitive. type AugmentParams = TParams extends {} ? keyof TParams extends never ? TTarget : {} & TTarget & TParams : TTarget; // Check if provided keys (expressed as a single or union type) are members of TBase type AreKeysOf = Boxed extends Boxed ? true : false; // https://stackoverflow.com/a/50375286/476712 type UnionToIntersection = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never; type ComparisonOperator = '=' | '>' | '>=' | '<' | '<=' | '<>'; // If T is an array, get the type of member, else fall back to never type ArrayMember = T extends (infer M)[] ? M : never; // If T is an array, get the type of member, else retain original type UnwrapArrayMember = T extends (infer M)[] ? M : T; // Wrap a type in a container, making it an object type. // This is primarily useful in circumventing special handling of union/intersection in typescript interface Boxed { _value: T; } // If T can't be assigned to TBase fallback to an alternate type TAlt type IncompatibleToAlt = T extends TBase ? T : TAlt; type ArrayIfAlready = T1 extends any[] ? T2[] : T2; // Boxing is necessary to prevent distribution of conditional types: // https://lorefnon.tech/2019/05/02/using-boxing-to-prevent-distribution-of-conditional-types/ type PartialOrAny = Boxed extends Boxed ? {} : Boxed extends Boxed ? SafePick : any; // Retain the association of original keys with aliased keys at type level // to facilitates type-safe aliasing for object syntax type MappedAliasType = {} & { [K in keyof TAliasMapping]: TAliasMapping[K] extends keyof TBase ? TBase[TAliasMapping[K]] : any }; // Container type for situations when we want a partial/intersection eventually // but the keys being selected or additional properties being augmented are not // all known at once and we would want to effectively build up a partial/intersection // over multiple steps. type DeferredKeySelection< // The base of selection. In intermediate stages this may be unknown. // If it remains unknown at the point of resolution, the selection will fall back to any TBase, // Union of keys to be selected // In intermediate stages this may be never. TKeys extends string, // Changes how the resolution should behave if TKeys is never. // If true, then we assume that some keys were selected, and if TKeys is never, we will fall back to any. // If false, and TKeys is never, then we select TBase in its entirety THasSelect extends true | false = false, // Mapping of aliases -> TAliasMapping extends {} = {}, // If enabled, then instead of extracting a partial, during resolution // we will pick just a single property. TSingle extends boolean = false, // Extra props which will be intersected with the result TIntersectProps extends {} = {}, // Extra props which will be unioned with the result TUnionProps = never > = { // These properties are not actually used, but exist simply because // typescript doesn't end up happy when type parameters are unused _base: TBase; _hasSelection: THasSelect; _keys: TKeys; _aliases: TAliasMapping; _single: TSingle; _intersectProps: TIntersectProps; _unionProps: TUnionProps; }; // An companion namespace for DeferredKeySelection which provides type operators // to build up participants of intersection/partial over multiple invocations // and for final resolution. // // While the comments use wordings such as replacement and addition, it is important // to keep in mind that types are always immutable and all type operators return new altered types. declare namespace DeferredKeySelection { type Any = DeferredKeySelection; // Replace the Base if already a deferred selection. // If not, create a new deferred selection with specified base. type SetBase = TSelection extends DeferredKeySelection< any, infer TKeys, infer THasSelect, infer TAliasMapping, infer TSingle, infer TIntersectProps, infer TUnionProps > ? DeferredKeySelection : DeferredKeySelection; // If TSelection is already a deferred selection, then replace the base with TBase // If unknown, create a new deferred selection with TBase as the base // Else, retain original // // For practical reasons applicable to current context, we always return arrays of // deferred selections. So, this particular operator may not be useful in generic contexts. type ReplaceBase = UnwrapArrayMember< TSelection > extends DeferredKeySelection.Any ? ArrayIfAlready, TBase>> : unknown extends UnwrapArrayMember ? ArrayIfAlready> : TSelection; // Type operators to substitute individual type parameters: type SetSingle< TSelection, TSingle extends boolean > = TSelection extends DeferredKeySelection< infer TBase, infer TKeys, infer THasSelect, infer TAliasMapping, any, infer TIntersectProps, infer TUnionProps > ? DeferredKeySelection : never; type AddKey< TSelection, TKey extends string > = TSelection extends DeferredKeySelection< infer TBase, infer TKeys, any, infer TAliasMapping, infer TSingle, infer TIntersectProps, infer TUnionProps > ? DeferredKeySelection : DeferredKeySelection; type AddAliases = TSelection extends DeferredKeySelection< infer TBase, infer TKeys, infer THasSelect, infer TAliasMapping, infer TSingle, infer TIntersectProps, infer TUnionProps > ? DeferredKeySelection : DeferredKeySelection; type AddUnionMember = TSelection extends DeferredKeySelection< infer TBase, infer TKeys, infer THasSelect, infer TAliasMapping, infer TSingle, infer TIntersectProps, infer TUnionProps > ? DeferredKeySelection : DeferredKeySelection; // Convenience utility to set base, keys and aliases in a single type // application type Augment = AddAliases< AddKey, TKey>, TAliasMapping >; // Core resolution logic -- Refer to docs for DeferredKeySelection for specifics type ResolveOne = TSelection extends DeferredKeySelection< infer TBase, infer TKeys, infer THasSelect, infer TAliasMapping, infer TSingle, infer TIntersectProps, infer TUnionProps > ? UnknownToAny< // ^ We convert final result to any if it is unknown for backward compatibility. // Historically knex typings have been liberal with returning any and changing // default return type to unknown would be a major breaking change for users. // // So we compromise on type safety here and return any. AugmentParams< AnyToUnknown extends {} // ^ Conversion of any -> unknown is needed here to prevent distribution // of any over the conditional ? TSingle extends true ? TKeys extends keyof TBase ? TBase[TKeys] : any : AugmentParams< true extends THasSelect ? PartialOrAny : TBase, MappedAliasType > : unknown, TIntersectProps > | TUnionProps > : TSelection; type Resolve = TSelection extends DeferredKeySelection.Any ? Knex.ResolveTableType> : TSelection extends DeferredKeySelection.Any[] ? Knex.ResolveTableType>[] : TSelection extends (infer I)[] ? UnknownToAny>[] : UnknownToAny>; } type AggregationQueryResult = ArrayIfAlready< TResult, UnwrapArrayMember extends DeferredKeySelection< infer TBase, infer TKeys, infer THasSelect, infer TAliasMapping, infer TSingle, infer TIntersectProps, infer TUnionProps > ? true extends THasSelect ? DeferredKeySelection : DeferredKeySelection<{}, never, true, {}, false, TIntersectProps2> : TIntersectProps2 >; // Convenience alias and associated companion namespace for working // with DeferredSelection having TSingle=true. // // When TSingle=true in DeferredSelection, then we are effectively // deferring an index access operation (TBase[TKey]) over a potentially // unknown initial type of TBase and potentially never initial type of TKey type DeferredIndex = DeferredKeySelection; declare namespace DeferredIndex { type Augment< T, TBase, TKey extends string, TAliasMapping = {} > = DeferredKeySelection.SetSingle< DeferredKeySelection.AddKey, TKey>, true >; } // If we have more categories of deferred selection in future, // this will combine all of them type ResolveResult = DeferredKeySelection.Resolve; // # Type-aliases for common type combinations type Callback = Function; type Client = Function; type Dict = { [k: string]: T; }; type SafePick = T extends {} ? Pick : any; type TableOptions = PgTableOptions; interface PgTableOptions { only?: boolean; } interface DMLOptions { includeTriggerModifications?: boolean; } interface Knex extends Knex.QueryInterface, events.EventEmitter { ( tableName: TTable, options?: TableOptions ): Knex.QueryBuilder, DeferredKeySelection>, never>[]>; []>( tableName?: Knex.TableDescriptor | Knex.AliasDict, options?: TableOptions ): Knex.QueryBuilder; VERSION: string; __knex__: string; raw: Knex.RawBuilder; transactionProvider( config?: any ): () => Promise; transaction( transactionScope?: null, config?: any ): Promise; transaction( transactionScope: (trx: Knex.Transaction) => Promise | void, config?: any ): Promise; initialize(config?: Knex.Config): void; destroy(callback: Function): void; destroy(): Promise; batchInsert( tableName: Knex.TableDescriptor, data: TRecord2 extends Knex.CompositeTableType ? ReadonlyArray> : ReadonlyArray>, chunkSize?: number, ): Knex.BatchInsertBuilder; schema: Knex.SchemaBuilder; queryBuilder(): Knex.QueryBuilder< TRecord2, TResult2 >; client: any; migrate: Knex.Migrator; seed: Knex.Seeder; fn: Knex.FunctionHelper; ref: Knex.RefBuilder; userParams: Record; withUserParams(params: Record): Knex; } declare function Knex( config: Knex.Config | string ): Knex; declare namespace Knex { // // Utility Types // type Value = | string | number | boolean | null | Date | Array | Array | Array | Array | Buffer | Knex.Raw; interface ValueDict extends Dict {} interface AliasDict extends Dict {} type ColumnDescriptor = | string | Knex.Raw | Knex.QueryBuilder | Dict; type InferrableColumnDescriptor = | keyof TRecord | Knex.Ref | Dict; type TableDescriptor = string | Knex.Raw | Knex.QueryBuilder; type Lookup = TKey extends keyof TRegistry ? TRegistry[TKey] : TDefault; type MaybeRawColumn = TColumn | Raw; type MaybeRawRecord = { [K in keyof TRecord]: MaybeRawColumn }; type DbColumn = Readonly>; type DbRecord = Readonly>>; type DbRecordArr = Readonly>>; export type CompositeTableType> = { base: TBase, insert: TInsert, update: TUpdate, }; type TableNames = keyof Tables; type TableInterfaceScope = keyof CompositeTableType; type TableType = Tables[TTable]; type ResolveTableType = TCompositeTableType extends CompositeTableType ? TCompositeTableType[TScope] : TCompositeTableType; interface OnConflictQueryBuilder { ignore(): QueryBuilder; merge(data?: DbRecord): QueryBuilder; } // // QueryInterface // type ClearStatements = "with" | "select" | "columns" | "hintComments" | "where" | "union" | "join" | "group" | "order" | "having" | "limit" | "offset" | "counter" | "counters"; interface QueryInterface { select: Select; as: As; columns: Select; column: Select; hintComment: HintComment; from: Table; into: Table; table: Table; distinct: Distinct; distinctOn: DistinctOn; // Joins join: Join; joinRaw: JoinRaw; innerJoin: Join; leftJoin: Join; leftOuterJoin: Join; rightJoin: Join; rightOuterJoin: Join; outerJoin: Join; fullOuterJoin: Join; crossJoin: Join; // Withs with: With; withRecursive: With; withRaw: WithRaw; withSchema: WithSchema; withWrapped: WithWrapped; // Wheres where: Where; andWhere: Where; orWhere: Where; whereNot: Where; andWhereNot: Where; orWhereNot: Where; whereRaw: WhereRaw; orWhereRaw: WhereRaw; andWhereRaw: WhereRaw; whereWrapped: WhereWrapped; havingWrapped: WhereWrapped; whereExists: WhereExists; orWhereExists: WhereExists; whereNotExists: WhereExists; orWhereNotExists: WhereExists; whereIn: WhereIn; orWhereIn: WhereIn; whereNotIn: WhereIn; orWhereNotIn: WhereIn; whereNull: WhereNull; orWhereNull: WhereNull; whereNotNull: WhereNull; orWhereNotNull: WhereNull; whereBetween: WhereBetween; orWhereBetween: WhereBetween; andWhereBetween: WhereBetween; whereNotBetween: WhereBetween; orWhereNotBetween: WhereBetween; andWhereNotBetween: WhereBetween; // Group by groupBy: GroupBy; groupByRaw: RawQueryBuilder; // Order by orderBy: OrderBy; orderByRaw: RawQueryBuilder; // Intersect intersect: Intersect; // Union union: Union; unionAll: Union; // Having having: Having; andHaving: Having; havingRaw: RawQueryBuilder; orHaving: Having; orHavingRaw: RawQueryBuilder; havingIn: HavingRange; orHavingNotBetween: HavingRange; havingNotBetween: HavingRange; orHavingBetween: HavingRange; havingBetween: HavingRange; // Clear clearSelect(): QueryBuilder< TRecord, UnwrapArrayMember extends DeferredKeySelection< infer TBase, infer TKeys, true, any, any, any, any > ? DeferredKeySelection[] : TResult >; clearWhere(): QueryBuilder; clearGroup(): QueryBuilder; clearOrder(): QueryBuilder; clearHaving(): QueryBuilder; clearCounters(): QueryBuilder; clear(statement: ClearStatements): QueryBuilder; // Paging offset(offset: number): QueryBuilder; limit(limit: number): QueryBuilder; // Aggregation count: AsymmetricAggregation>; countDistinct: AsymmetricAggregation>; min: TypePreservingAggregation; max: TypePreservingAggregation; sum: TypePreservingAggregation; sumDistinct: TypePreservingAggregation; avg: TypePreservingAggregation; avgDistinct: TypePreservingAggregation; increment( columnName: keyof TRecord, amount?: number ): QueryBuilder; increment( columnName: string, amount?: number ): QueryBuilder; decrement( columnName: keyof TRecord, amount?: number ): QueryBuilder; decrement( columnName: string, amount?: number ): QueryBuilder; // Others first: Select, undefined>>; pluck( column: K ): QueryBuilder; pluck(column: string): QueryBuilder; insert( data: TRecord extends CompositeTableType ? ResolveTableType | ReadonlyArray> : DbRecordArr | ReadonlyArray>, returning: '*', options?: DMLOptions ): QueryBuilder[]>; insert< TKey extends StrKey>, TResult2 = DeferredIndex.Augment< UnwrapArrayMember, ResolveTableType, TKey >[] >( data: TRecord extends CompositeTableType ? ResolveTableType | ReadonlyArray> : DbRecordArr | ReadonlyArray>, returning: TKey, options?: DMLOptions ): QueryBuilder; insert< TKey extends StrKey>, TResult2 = DeferredKeySelection.Augment< UnwrapArrayMember, ResolveTableType, TKey >[] >( data: TRecord extends CompositeTableType ? ResolveTableType | ReadonlyArray> : DbRecordArr | ReadonlyArray>, returning: readonly TKey[], options?: DMLOptions ): QueryBuilder; insert< TKey extends string, TResult2 = DeferredIndex.Augment< UnwrapArrayMember, TRecord, TKey >[] >( data: TRecord extends CompositeTableType ? ResolveTableType | ReadonlyArray> : DbRecordArr | ReadonlyArray>, returning: TKey, options?: DMLOptions ): QueryBuilder; insert< TKey extends string, TResult2 = DeferredIndex.Augment< UnwrapArrayMember, TRecord, TKey >[] >( data: TRecord extends CompositeTableType ? ResolveTableType | ReadonlyArray> : DbRecordArr | ReadonlyArray>, returning: readonly TKey[], options?: DMLOptions ): QueryBuilder; insert( data: TRecord extends CompositeTableType ? ResolveTableType | ReadonlyArray> : DbRecordArr | ReadonlyArray> ): QueryBuilder; modify( callback: QueryCallbackWithArgs, ...args: any[] ): QueryBuilder; update< K1 extends StrKey>, K2 extends StrKey>, TResult2 = DeferredIndex.Augment< UnwrapArrayMember, ResolveTableType, K2 >[] >( columnName: K1, value: DbColumn[K1]>, returning: K2, options?: DMLOptions ): QueryBuilder; update< K1 extends StrKey>, K2 extends StrKey>, TResult2 = DeferredKeySelection.Augment< UnwrapArrayMember, ResolveTableType, K2 >[] >( columnName: K1, value: DbColumn[K1]>, returning: readonly K2[], options?: DMLOptions ): QueryBuilder; update( columnName: K, value: DbColumn ): QueryBuilder; update[]>( columnName: string, value: Value, returning: string | readonly string[], options?: DMLOptions ): QueryBuilder; update( data: DbRecordArr, returning: '*', options?: DMLOptions ): QueryBuilder[]>; update< TKey extends StrKey>, TResult2 = DeferredIndex.Augment< UnwrapArrayMember, ResolveTableType, TKey >[] >( data: TRecord extends CompositeTableType ? ResolveTableType : DbRecordArr, returning: TKey, options?: DMLOptions ): QueryBuilder; update< TKey extends StrKey>, TResult2 = DeferredKeySelection.Augment< UnwrapArrayMember, ResolveTableType, TKey >[] >( data: TRecord extends CompositeTableType ? ResolveTableType : DbRecordArr, returning: readonly TKey[], options?: DMLOptions ): QueryBuilder; update< TKey extends string = string, TResult2 extends {}[] = DeferredKeySelection.Augment< UnwrapArrayMember, TRecord, TKey >[] >( data: TRecord extends CompositeTableType ? ResolveTableType : DbRecordArr, returning: TKey | readonly TKey[], options?: DMLOptions ): QueryBuilder; update< TKey extends string, TResult2 extends {}[] = DeferredKeySelection.Augment< UnwrapArrayMember, TRecord, TKey >[] >( data: TRecord extends CompositeTableType ? ResolveTableType : DbRecordArr, returning: readonly TKey[], options?: DMLOptions ): QueryBuilder; update( data: TRecord extends CompositeTableType ? ResolveTableType : DbRecordArr ): QueryBuilder; update(columnName: string, value: Value): QueryBuilder; returning(column: '*', options?: DMLOptions): QueryBuilder[]>; returning< TKey extends StrKey>, TResult2 = DeferredIndex.Augment< UnwrapArrayMember, ResolveTableType, TKey >[] >( column: TKey, options?: DMLOptions ): QueryBuilder; returning< TKey extends StrKey>, TResult2 = DeferredKeySelection.SetSingle< DeferredKeySelection.Augment, ResolveTableType, TKey>, false >[] >( columns: readonly TKey[], options?: DMLOptions ): QueryBuilder; returning[]>( column: string | readonly string[], options?: DMLOptions ): QueryBuilder; onConflict< TKey extends StrKey, TResult2 = DeferredIndex.Augment< UnwrapArrayMember, TRecord, TKey >[] >( column: TKey ): OnConflictQueryBuilder; onConflict< TKey extends StrKey, TResult2 = DeferredKeySelection.SetSingle< DeferredKeySelection.Augment, TRecord, TKey>, false >[] >( columns: readonly TKey[] ): OnConflictQueryBuilder; del( returning: '*', options?: DMLOptions ): QueryBuilder[]>; del< TKey extends StrKey, TResult2 = DeferredIndex.Augment< UnwrapArrayMember, TRecord, TKey >[] >( returning: TKey, options?: DMLOptions ): QueryBuilder; del< TKey extends StrKey, TResult2 = DeferredKeySelection.Augment< UnwrapArrayMember, TRecord, TKey >[] >( returning: readonly TKey[], options?: DMLOptions ): QueryBuilder; del[]>( returning: string | readonly string[], options?: DMLOptions ): QueryBuilder; del(): QueryBuilder; delete( returning: '*', options?: DMLOptions ): QueryBuilder[]>; delete< TKey extends StrKey>, TResult2 = DeferredIndex.Augment< UnwrapArrayMember, ResolveTableType, TKey >[] >( returning: TKey, options?: DMLOptions ): QueryBuilder; delete< TKey extends StrKey, TResult2 = DeferredKeySelection.Augment< UnwrapArrayMember, TRecord, TKey >[] >( returning: readonly TKey[], options?: DMLOptions ): QueryBuilder; delete( returning: string | readonly string[], options?: DMLOptions ): QueryBuilder; delete(): QueryBuilder; truncate(): QueryBuilder; } interface As { (columnName: keyof TRecord): QueryBuilder; (columnName: string): QueryBuilder; } type IntersectAliases = UnionToIntersection< IncompatibleToAlt< AliasUT extends (infer I)[] ? I extends Ref ? TMapping : I : never, Dict, {} > >; interface AliasQueryBuilder { < AliasUT extends InferrableColumnDescriptor>[], TResult2 = ArrayIfAlready, ResolveTableType, IncompatibleToAlt, string, never>, IntersectAliases >> >( ...aliases: AliasUT ): QueryBuilder; < AliasUT extends InferrableColumnDescriptor>[], TResult2 = ArrayIfAlready, ResolveTableType, IncompatibleToAlt, string, never>, IntersectAliases >> >( aliases: AliasUT ): QueryBuilder; < AliasUT extends (Dict | string)[], TResult2 = ArrayIfAlready, ResolveTableType, IncompatibleToAlt, string, never>, IntersectAliases >> >( ...aliases: AliasUT ): QueryBuilder; < AliasUT extends (Dict | string)[], TResult2 = ArrayIfAlready, TRecord, IncompatibleToAlt, string, never>, IntersectAliases >> >( aliases: AliasUT ): QueryBuilder; } interface Select extends AliasQueryBuilder, ColumnNameQueryBuilder { (): QueryBuilder; , TInnerRecord = any, TInnerResult = any>( ...subQueryBuilders: readonly QueryBuilder[] ): QueryBuilder; , TInnerRecord = any, TInnerResult = any>( subQueryBuilders: readonly QueryBuilder[] ): QueryBuilder; } interface HintComment { (hint: string): QueryBuilder; (hints: readonly string[]): QueryBuilder; } interface Table { < TTable extends TableNames, TRecord2 = TableType, TResult2 = DeferredKeySelection.ReplaceBase> >( tableName: TTable, options?: TableOptions ): QueryBuilder; < TRecord2 = unknown, TResult2 = DeferredKeySelection.ReplaceBase >( tableName: TableDescriptor | AliasDict, options?: TableOptions ): QueryBuilder; < TRecord2 = unknown, TResult2 = DeferredKeySelection.ReplaceBase >( callback: Function, options?: TableOptions ): QueryBuilder; < TRecord2 = unknown, TResult2 = DeferredKeySelection.ReplaceBase >( raw: Raw, options?: TableOptions ): QueryBuilder; } interface Distinct extends ColumnNameQueryBuilder {} interface DistinctOn { ( ...columnNames: readonly ColNameUT[] ): QueryBuilder; ( columnNames: readonly ColNameUT[] ): QueryBuilder; (...columnNames: readonly string[]): QueryBuilder; (columnNames: readonly string[]): QueryBuilder; } interface JoinCallback { (this: JoinClause, join: JoinClause): void; } interface Join { < TJoinTargetRecord extends {} = any, TRecord2 extends {} = TRecord & TJoinTargetRecord, TResult2 = DeferredKeySelection.ReplaceBase >( raw: Raw ): QueryBuilder; < TTable extends TableNames, TRecord2 = ResolveTableType & ResolveTableType>, TResult2 = DeferredKeySelection.ReplaceBase >( tableName: TTable, clause: JoinCallback ): QueryBuilder; < TJoinTargetRecord extends {} = any, TRecord2 extends {} = TRecord & TJoinTargetRecord, TResult2 = DeferredKeySelection.ReplaceBase >( tableName: TableDescriptor | AliasDict | QueryCallback, clause: JoinCallback ): QueryBuilder; < TJoinTargetRecord extends {} = any, TRecord2 extends {} = TRecord & TJoinTargetRecord, TResult2 = DeferredKeySelection.ReplaceBase >( tableName: TableDescriptor | AliasDict | QueryCallback, columns: { [key: string]: string | number | boolean | Raw } ): QueryBuilder; < TJoinTargetRecord extends {} = any, TRecord2 extends {} = TRecord & TJoinTargetRecord, TResult2 = DeferredKeySelection.ReplaceBase >( tableName: TableDescriptor | AliasDict | QueryCallback, raw: Raw ): QueryBuilder; < TTable extends TableNames, TRecord2 = ResolveTableType & ResolveTableType>, TResult2 = DeferredKeySelection.ReplaceBase >( tableName: TTable, column1: string, column2: string ): QueryBuilder; < TJoinTargetRecord extends {} = any, TRecord2 extends {} = TRecord & TJoinTargetRecord, TResult2 = DeferredKeySelection.ReplaceBase >( tableName: TableDescriptor | AliasDict | QueryCallback, column1: string, column2: string ): QueryBuilder; < TJoinTargetRecord extends {} = any, TRecord2 extends {} = TRecord & TJoinTargetRecord, TResult2 = DeferredKeySelection.ReplaceBase >( tableName: TableDescriptor | AliasDict | QueryCallback, column1: string, raw: Raw ): QueryBuilder; < TTable extends TableNames, TRecord2 = ResolveTableType & ResolveTableType>, TResult2 = DeferredKeySelection.ReplaceBase >( tableName: TTable, column1: string, operator: string, column2: string ): QueryBuilder; < TJoinTargetRecord extends {} = any, TRecord2 extends {} = TRecord & TJoinTargetRecord, TResult2 = DeferredKeySelection.ReplaceBase >( tableName: TableDescriptor | AliasDict | QueryCallback, column1: string, operator: string, column2: string ): QueryBuilder; } interface JoinClause { on(raw: Raw): JoinClause; on(callback: JoinCallback): JoinClause; on(columns: { [key: string]: string | Raw }): JoinClause; on(column1: string, column2: string): JoinClause; on(column1: string, raw: Raw): JoinClause; on(column1: string, operator: string, column2: string | Raw): JoinClause; andOn(raw: Raw): JoinClause; andOn(callback: JoinCallback): JoinClause; andOn(columns: { [key: string]: string | Raw }): JoinClause; andOn(column1: string, column2: string): JoinClause; andOn(column1: string, raw: Raw): JoinClause; andOn(column1: string, operator: string, column2: string | Raw): JoinClause; orOn(raw: Raw): JoinClause; orOn(callback: JoinCallback): JoinClause; orOn(columns: { [key: string]: string | Raw }): JoinClause; orOn(column1: string, column2: string): JoinClause; orOn(column1: string, raw: Raw): JoinClause; orOn(column1: string, operator: string, column2: string | Raw): JoinClause; onIn(column1: string, values: readonly any[]): JoinClause; andOnIn(column1: string, values: readonly any[]): JoinClause; orOnIn(column1: string, values: readonly any[]): JoinClause; onNotIn(column1: string, values: readonly any[]): JoinClause; andOnNotIn(column1: string, values: readonly any[]): JoinClause; orOnNotIn(column1: string, values: readonly any[]): JoinClause; onNull(column1: string): JoinClause; andOnNull(column1: string): JoinClause; orOnNull(column1: string): JoinClause; onNotNull(column1: string): JoinClause; andOnNotNull(column1: string): JoinClause; orOnNotNull(column1: string): JoinClause; onExists(callback: QueryCallback): JoinClause; andOnExists(callback: QueryCallback): JoinClause; orOnExists(callback: QueryCallback): JoinClause; onNotExists(callback: QueryCallback): JoinClause; andOnNotExists(callback: QueryCallback): JoinClause; orOnNotExists(callback: QueryCallback): JoinClause; onBetween(column1: string, range: readonly [any, any]): JoinClause; andOnBetween(column1: string, range: readonly [any, any]): JoinClause; orOnBetween(column1: string, range: readonly [any, any]): JoinClause; onNotBetween(column1: string, range: readonly [any, any]): JoinClause; andOnNotBetween(column1: string, range: readonly [any, any]): JoinClause; orOnNotBetween(column1: string, range: readonly [any, any]): JoinClause; using( column: string | readonly string[] | Raw | { [key: string]: string | Raw } ): JoinClause; type(type: string): JoinClause; } interface JoinRaw { (tableName: string, binding?: Value | ValueDict): QueryBuilder< TRecord, TResult >; } interface With extends WithRaw, WithWrapped {} interface WithRaw { (alias: string, raw: Raw | QueryBuilder): QueryBuilder; (alias: string, sql: string, bindings?: readonly Value[] | Object): QueryBuilder< TRecord, TResult >; } interface WithSchema { (schema: string): QueryBuilder; } interface WithWrapped { (alias: string, queryBuilder: QueryBuilder): QueryBuilder; ( alias: string, callback: (queryBuilder: QueryBuilder) => any ): QueryBuilder; } interface Where extends WhereRaw, WhereWrapped, WhereNull { (raw: Raw): QueryBuilder; (callback: QueryCallback): QueryBuilder; (object: DbRecord>): QueryBuilder; (object: Readonly