@rvoh/dream 0.29.1

package/dist/types/src/dream/Query.d.ts

@@ -0,0 +1,1132 @@
+import { DeleteQueryBuilder, SelectQueryBuilder, UpdateQueryBuilder } from 'kysely';
+import ConnectedToDB from '../db/ConnectedToDB.js';
+import { DbConnectionType } from '../db/types.js';
+import { ColumnNamesAccountingForJoinedAssociations, LimitStatement, OffsetStatement, OrderQueryStatement, PassthroughOnClause, WhereStatement, WhereStatementForJoinedAssociation } from '../decorators/associations/shared.js';
+import Dream from '../Dream.js';
+import { FindInterfaceWithValue } from '../helpers/typeutils.js';
+import DreamTransaction from './DreamTransaction.js';
+import { AllDefaultScopeNames, DefaultScopeName, DreamColumnNames, DreamTableSchema, IdType, JoinedAssociation, JoinedAssociationsTypeFromAssociations, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, QueryTypeOptions, RelaxedJoinOnStatement, RelaxedJoinStatement, RelaxedPreloadOnStatement, RelaxedPreloadStatement, TableColumnNames, TableColumnType, TableOrAssociationName, VariadicJoinsArgs, VariadicLeftJoinLoadArgs, VariadicLoadArgs } from './types.js';
+export type QueryWithJoinedAssociationsType<Q extends Query<any, any>, JoinedAssociations extends Readonly<JoinedAssociation[]>> = Query<Q['dreamInstance'], ExtendQueryType<Q['queryTypeOpts'], Readonly<{
+    joinedAssociations: JoinedAssociations;
+}>>>;
+export type QueryWithJoinedAssociationsTypeAndNoPreload<Q extends Query<any, any>, JoinedAssociations extends Readonly<JoinedAssociation[]> = Readonly<JoinedAssociation[]>> = Query<Q['dreamInstance'], ExtendQueryType<Q['queryTypeOpts'], Readonly<{
+    joinedAssociations: JoinedAssociations;
+    allowPreload: false;
+}>>>;
+export type QueryWithJoinedAssociationsTypeAndNoLeftJoinPreload<Q extends Query<any, any>, JoinedAssociations extends Readonly<JoinedAssociation[]> = Readonly<JoinedAssociation[]>> = Query<Q['dreamInstance'], ExtendQueryType<Q['queryTypeOpts'], Readonly<{
+    joinedAssociations: JoinedAssociations;
+    allowLeftJoinPreload: false;
+}>>>;
+export type DefaultQueryTypeOptions<TableNameSource extends Dream, TableAliasSource extends Dream | string = TableNameSource> = Readonly<{
+    joinedAssociations: Readonly<[]>;
+    rootTableName: TableNameSource['table'];
+    rootTableAlias: TableAliasSource extends Dream ? TableAliasSource['table'] : TableAliasSource;
+    allowPreload: true;
+    allowLeftJoinPreload: true;
+}>;
+export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Readonly<QueryTypeOptions> = DefaultQueryTypeOptions<DreamInstance>> extends ConnectedToDB<DreamInstance> {
+    /**
+     * @internal
+     *
+     * stores the default batch sizes for various
+     * provided batching methods
+     */
+    static readonly BATCH_SIZES: {
+        FIND_EACH: number;
+        PLUCK_EACH: number;
+        PLUCK_EACH_THROUGH: number;
+    };
+    /**
+     * @internal
+     * purely for typing
+     */
+    queryTypeOpts: QueryTypeOpts;
+    /**
+     * @internal
+     *
+     * stores the dream transaction applied to the
+     * current Query instance
+     */
+    dreamTransaction: DreamTransaction<Dream> | null;
+    /**
+     * @internal
+     *
+     * stores the passthrough on statements applied to the
+     * current Query instance
+     */
+    private readonly passthroughOnStatement;
+    /**
+     * @internal
+     *
+     * stores the where statements applied to the
+     * current Query instance
+     */
+    private readonly whereStatements;
+    /**
+     * @internal
+     *
+     * stores the where not statements applied to the
+     * current Query instance
+     */
+    private readonly whereNotStatements;
+    /**
+     * @internal
+     *
+     * stores the limit statements applied to the
+     * current Query instance
+     */
+    private readonly limitStatement;
+    /**
+     * @internal
+     *
+     * stores the offset statements applied to the
+     * current Query instance
+     */
+    private readonly offsetStatement;
+    /**
+     * @internal
+     *
+     * stores the or statements applied to the
+     * current Query instance
+     */
+    private readonly whereAnyStatements;
+    /**
+     * @internal
+     *
+     * stores the order statements applied to the
+     * current Query instance
+     */
+    private readonly orderStatements;
+    /**
+     * @internal
+     *
+     * whether or not to turn joins into load statements
+     */
+    private readonly joinLoadActivated;
+    /**
+     * @internal
+     *
+     * stores the preload statements applied to the
+     * current Query instance
+     */
+    private readonly preloadStatements;
+    /**
+     * @internal
+     *
+     * stores the preload on statements applied to the
+     * current Query instance
+     */
+    private readonly preloadOnStatements;
+    /**
+     * @internal
+     *
+     * stores the joins statements applied to the
+     * current Query instance
+     */
+    private readonly innerJoinStatements;
+    /**
+     * @internal
+     *
+     * stores the joins on statements applied to the
+     * current Query instance
+     */
+    private readonly innerJoinOnStatements;
+    /**
+     * @internal
+     *
+     * stores the joins statements applied to the
+     * current Query instance
+     */
+    private readonly leftJoinStatements;
+    /**
+     * @internal
+     *
+     * stores the joins on statements applied to the
+     * current Query instance
+     */
+    private readonly leftJoinOnStatements;
+    /**
+     * @internal
+     *
+     * Whether or not to bypass all default scopes for this Query
+     */
+    private readonly bypassAllDefaultScopes;
+    /**
+     * @internal
+     *
+     * Whether or not to bypass all default scopes for this Query, but not associations
+     */
+    private readonly bypassAllDefaultScopesExceptOnAssociations;
+    /**
+     * @internal
+     *
+     * Specific default scopes to bypass
+     */
+    private readonly defaultScopesToBypass;
+    /**
+     * @internal
+     *
+     * Specific default scopes to bypass, but not associations
+     */
+    private readonly defaultScopesToBypassExceptOnAssociations;
+    /**
+     * @internal
+     *
+     * Whether or not to bypass SoftDelete and really destroy a record
+     * when calling destroy.
+     */
+    private readonly shouldReallyDestroy;
+    /**
+     * @internal
+     *
+     * The distinct column to apply to the Query
+     */
+    private readonly distinctColumn;
+    /**
+     * @internal
+     *
+     * The base sql alias to use for the base model
+     * of this Query
+     */
+    private baseSqlAlias;
+    private get tableName();
+    private get namespacedPrimaryKey();
+    /**
+     * @internal
+     *
+     * Used for unscoping Query instances. In most cases, this will be null,
+     * but when calling `removeAllDefaultScopes`, a removeAllDefaultScopes Query is stored as
+     * baseSelectQuery.
+     */
+    private baseSelectQuery;
+    constructor(dreamInstance: DreamInstance, opts?: QueryOpts<DreamInstance, DreamColumnNames<DreamInstance>>);
+    /**
+     * Returns true. Useful for distinguishing Query instances
+     * from other objects.
+     *
+     * @returns true
+     */
+    get isDreamQuery(): boolean;
+    /**
+     * @internal
+     *
+     * Used for applying preload and load statements
+     *
+     * @returns An associated Query
+     */
+    private dreamClassQueryWithScopeBypasses;
+    /**
+     * @internal
+     *
+     * Returns a cloned version of the Query
+     *
+     * ```ts
+     * const clonedQuery = User.query().clone()
+     * ```
+     *
+     * @param opts - Statements to override when cloning the Query
+     * @returns A cloned Query with the provided overrides clause applied
+     */
+    clone<Q extends Query<DreamInstance, QueryTypeOpts>>(this: Q, opts?: QueryOpts<DreamInstance, any>): Q;
+    /**
+     * Finds a record matching the Query with the
+     * specified primary key. If not found, null
+     * is returned.
+     *
+     * ```ts
+     * await User.query().find(123)
+     * // User{id: 123}
+     * ```
+     *
+     * @param primaryKey - The primary key of the record to look up
+     * @returns Either the found record, or else null
+     */
+    find(primaryKey: PrimaryKeyForFind<DreamInstance>): Promise<DreamInstance | null>;
+    /**
+     * Finds a record matching the Query with the
+     * specified primary key. If not found, an exception
+     * is raised.
+     *
+     * ```ts
+     * await User.query().findOrFail(123)
+     * // User{id: 123}
+     * ```
+     *
+     * @param primaryKey - The primary key of the record to look up
+     * @returns The found record
+     */
+    findOrFail(primaryKey: PrimaryKeyForFind<DreamInstance>): Promise<DreamInstance>;
+    /**
+     * Finds a record matching the Query and the
+     * specified where statement. If not found, null
+     * is returned.
+     *
+     * ```ts
+     * await User.query().findBy({ email: 'how@yadoin' })
+     * // User{email: 'how@yadoin'}
+     * ```
+     *
+     * @param whereStatement - The where statement used to locate the record
+     * @returns Either the first record found matching the attributes, or else null
+     */
+    findBy<DB extends DreamInstance['DB'], Schema extends DreamInstance['schema']>(whereStatement: WhereStatement<DB, Schema, DreamInstance['table']>): Promise<DreamInstance | null>;
+    /**
+     * Finds a record matching the Query and the
+     * specified where statement. If not found, an exception
+     * is raised.
+     *
+     * ```ts
+     * await User.query().findOrFailBy({ email: 'how@yadoin' })
+     * // User{email: 'how@yadoin'}
+     * ```
+     *
+     * @param whereStatement - The where statement used to locate the record
+     * @returns The first record found matching the attributes
+     */
+    findOrFailBy<DB extends DreamInstance['DB'], Schema extends DreamInstance['schema']>(whereStatement: WhereStatement<DB, Schema, DreamInstance['table']>): Promise<DreamInstance>;
+    /**
+     * Finds all records matching the Query in batches,
+     * and then calls the provided callback for each found record.
+     * Once all records have been passed for a given batch, the next set of
+     * records will be fetched and passed to your callback, until all
+     * records matching the Query have been fetched.
+     *
+     * ```ts
+     * await User.order('id').findEach(user => {
+     *   DreamApplication.log(user)
+     * })
+     * // User{id: 1}
+     * // User{id: 2}
+     * ```
+     *
+     * @param cb - The callback to call for each found record
+     * @param options - Options for destroying the instance
+     * @param options.batchSize - The batch size you wish to collect records in. If not provided, it will default to 1000
+     * @returns void
+     */
+    findEach(this: Query<DreamInstance, QueryTypeOpts>, cb: (instance: DreamInstance) => void | Promise<void>, { batchSize }?: {
+        batchSize?: number;
+    }): Promise<void>;
+    /**
+     * Load each specified association using a single SQL query.
+     * See {@link #preload} for preloading in separate queries.
+     *
+     * Note: since leftJoinPreload loads via single query, it has
+     * some downsides and that may be avoided using {@link #preload}:
+     * 1. `limit` and `offset` will be automatically removed
+     * 2. `through` associations will bring additional namespaces into the query that can conflict with through associations from other associations, creating an invalid query
+     * 3. each nested association will result in an additional record which duplicates data from the outer record. E.g., given `.leftJoinPreload('a', 'b', 'c')`, if each `a` has 10 `b` and each `b` has 10 `c`, then for one `a`, 100 records will be returned, each of which has all of the columns of `a`. `.preload('a', 'b', 'c')` would perform three separate SQL queries, but the data for a single `a` would only be returned once.
+     * 4. the individual query becomes more complex the more associations are included
+     * 5. associations loading associations loading associations could result in exponential amounts of data; in those cases, `.preload(...).findEach(...)` avoids instantiating massive amounts of data at once
+     *
+     *
+     * ```ts
+     * const posts = await user.associationQuery('posts').leftJoinPreload('comments', { visibilty: 'public' }, 'replies').all()
+     * console.log(posts[0].comments[0].replies[0])
+     * // [Reply{id: 1}, Reply{id: 2}]
+     * ```
+     *
+     * @param args - A chain of association names and on/notOn/onAny clauses
+     * @returns A cloned Query with the joinLoad statement applied
+     */
+    leftJoinPreload<Q extends Query<DreamInstance, any>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], TableName extends DreamInstance['table'], const Arr extends readonly unknown[], const LastArg extends VariadicLeftJoinLoadArgs<DB, Schema, TableName, Arr>, Incompatible extends Q['queryTypeOpts'] extends Readonly<{
+        allowLeftJoinPreload: false;
+    }> ? true : false, const JoinedAssociationsCandidate = JoinedAssociationsTypeFromAssociations<DB, Schema, TableName, Incompatible extends true ? [] : [...Arr, LastArg]>, const JoinedAssociations extends readonly JoinedAssociation[] = JoinedAssociationsCandidate extends readonly JoinedAssociation[] ? JoinedAssociationsCandidate : never, RetQuery = Query<DreamInstance, ExtendQueryType<QueryTypeOpts, Readonly<{
+        joinedAssociations: JoinedAssociations;
+        allowPreload: false;
+    }>>>>(this: Q, ...args: Incompatible extends true ? 'leftJoinPreload is incompatible with preload'[] : [...Arr, LastArg]): RetQuery;
+    /**
+     * Load each specified association using a separate SQL query.
+     * See {@link #leftJoinPreload} for preloading in a single query.
+     *
+     * ```ts
+     * const user = await User.query().preload('posts', 'comments', { visibilty: 'public' }, 'replies').first()
+     * console.log(user.posts[0].comments[0].replies[0])
+     * // [Reply{id: 1}, Reply{id: 2}]
+     * ```
+     *
+     * @param args - A chain of association names and on/notOn/onAny clauses
+     * @returns A cloned Query with the preload statement applied
+     */
+    preload<Q extends Query<DreamInstance, any>, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], TableName extends DreamInstance['table'], const Arr extends readonly unknown[], Incompatible extends Q['queryTypeOpts'] extends Readonly<{
+        allowPreload: false;
+    }> ? true : false, RetQuery = Query<DreamInstance, ExtendQueryType<QueryTypeOpts, Readonly<{
+        allowLeftJoinPreload: false;
+    }>>>>(this: Q, ...args: Incompatible extends true ? 'preload is incompatible with leftJoinPreload'[] : [...Arr, VariadicLoadArgs<DB, Schema, TableName, Arr>]): RetQuery;
+    /**
+     * Returns a new Query instance, with the provided
+     * joins statement attached
+     *
+     * ```ts
+     * await User.query().innerJoin('posts').first()
+     * ```
+     *
+     * @param args - A chain of association names and on/notOn/onAny clauses
+     * @returns A cloned Query with the joins clause applied
+     */
+    innerJoin<DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], TableName extends DreamInstance['table'], const Arr extends readonly unknown[], const LastArg extends VariadicJoinsArgs<DB, Schema, TableName, Arr>, const JoinedAssociationsCandidate = JoinedAssociationsTypeFromAssociations<DB, Schema, TableName, [
+        ...Arr,
+        LastArg
+    ]>, const JoinedAssociations extends readonly JoinedAssociation[] = JoinedAssociationsCandidate extends readonly JoinedAssociation[] ? JoinedAssociationsCandidate : never, RetQuery = Query<DreamInstance, ExtendQueryType<QueryTypeOpts, Readonly<{
+        joinedAssociations: JoinedAssociations;
+    }>>>>(...args: [...Arr, LastArg]): RetQuery;
+    /**
+     * @internal
+     *
+     * @param args - A chain of association names and on/notOn/onAny clauses
+     * @returns A cloned Query with the joins clause applied
+     */
+    leftJoin<DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], TableName extends DreamInstance['table'], const Arr extends readonly unknown[], const LastArg extends VariadicJoinsArgs<DB, Schema, TableName, Arr>, const JoinedAssociationsCandidate = JoinedAssociationsTypeFromAssociations<DB, Schema, TableName, [
+        ...Arr,
+        LastArg
+    ]>, const JoinedAssociations extends readonly JoinedAssociation[] = JoinedAssociationsCandidate extends readonly JoinedAssociation[] ? JoinedAssociationsCandidate : never, RetQuery = Query<DreamInstance, ExtendQueryType<QueryTypeOpts, Readonly<{
+        joinedAssociations: JoinedAssociations;
+    }>>>>(...args: [...Arr, LastArg]): RetQuery;
+    /**
+     * @internal
+     *
+     */
+    private fleshOutJoinStatements;
+    /**
+     * @internal
+     *
+     *
+     */
+    private associationNamesToDreamClassesMap;
+    /**
+     * @internal
+     *
+     *
+     */
+    private associationNamesToAssociationsMap;
+    /**
+     * @internal
+     */
+    private associationNamesToAssociationDataAndDreamClassesMap;
+    /**
+     * @internal
+     */
+    private throughAssociationDetails;
+    /**
+     * @internal
+     *
+     *
+     */
+    private joinStatementsToDreamClassesMap;
+    /**
+     * @internal
+     *
+     *
+     */
+    private joinStatementsToAssociationsMap;
+    /**
+     * @internal
+     *
+     * Adds Dream class to temporary innerJoinDreamClasses array based on association name
+     *
+     */
+    private addAssociatedDreamClassToInnerJoinDreamClasses;
+    private addThroughAssociatedDreamClassToInnerJoinDreamClasses;
+    /**
+     * @internal
+     *
+     * Changes the base sql alias
+     *
+     */
+    private setBaseSQLAlias;
+    /**
+     * @internal
+     *
+     * Association queries start from the table corresponding to an instance
+     * of a Dream and join the association. However, the Dream may have
+     * default scopes that would preclude finding that instance, so the
+     * Query that forms the base of an association query must be unscoped,
+     * but that unscoping should not carry through to other associations
+     * (thus the use of `removeAllDefaultScopesExceptOnAssociations` instead of
+     * `removeAllDefaultScopes`).
+     *
+     * The association that this query is loading leverages `joins`, and the
+     * joining code explicitly handles applying / omitting default scopes.
+     * We set `bypassAllDefaultScopesExceptOnAssociations: true` on this Query
+     * to let that code do its work. This keeps the implementation DRY and simpler
+     * (without `bypassAllDefaultScopesExceptOnAssociations`, the default scopes would
+     * be applied twice, and when the association attempts to remove a default
+     * association would be foiled because it would be applied outside of the context
+     * where the association is modifying the query).
+     *
+     */
+    private setAssociationQueryBase;
+    /**
+     * Prevents default scopes from applying when
+     * the Query is executed
+     *
+     * @returns A new Query which will prevent default scopes from applying
+     */
+    removeAllDefaultScopes(): Query<DreamInstance, QueryTypeOpts>;
+    /**
+     * Prevents default scopes from applying when
+     * the Query is executed, but not when applying to associations
+     *
+     * @returns A new Query which will prevent default scopes from applying, but not when applying to asociations
+     */
+    protected removeAllDefaultScopesExceptOnAssociations(): Query<DreamInstance, QueryTypeOpts>;
+    /**
+     * Prevents a specific default scope from applying when
+     * the Query is executed
+     *
+     * @returns A new Query which will prevent a specific default scope from applying
+     */
+    removeDefaultScope(scopeName: AllDefaultScopeNames<DreamInstance>): Query<DreamInstance, QueryTypeOpts>;
+    /**
+     * Prevents a specific default scope from applying when
+     * the Query is executed, but not when applying to asociations
+     *
+     * @returns A new Query which will prevent a specific default scope from applying, but not when applying to asociations
+     */
+    protected removeDefaultScopeExceptOnAssociations(scopeName: DefaultScopeName<DreamInstance>): Query<DreamInstance, QueryTypeOpts>;
+    /**
+     * Sends data through for use as passthrough data
+     * for the associations that require it.
+     *
+     * ```ts
+     * class Post {
+     *   @Deco.HasMany('LocalizedText')
+     *   public localizedTexts: LocalizedText[]
+     *
+     *   @Deco.HasOne('LocalizedText', {
+     *     on: { locale: DreamConst.passthrough },
+     *   })
+     *   public currentLocalizedText: LocalizedText
+     * }
+     *
+     * await User.query().passthrough({ locale: 'es-ES' })
+     *   .preload('posts', 'currentLocalizedText')
+     *   .first()
+     * ```
+     *
+     * @param passthroughOnStatement - where statement used for associations that require passthrough data
+     * @returns A cloned Query with the passthrough data
+     */
+    passthrough(passthroughOnStatement: PassthroughOnClause<PassthroughColumnNames<DreamInstance>>): this;
+    /**
+     * Applies a where statement to the Query instance
+     *
+     * ```ts
+     * await User.where({ email: 'how@yadoin' }).first()
+     * // User{email: 'how@yadoin'}
+     * ```
+     *
+     * @param whereStatement - Where statement to apply to the Query
+     * @returns A cloned Query with the where clause applied
+     */
+    where<DB extends DreamInstance['DB'], Schema extends DreamInstance['schema']>(whereStatement: WhereStatementForJoinedAssociation<QueryTypeOpts['joinedAssociations'], DB, Schema, QueryTypeOpts['rootTableName']> | null): Query<DreamInstance, QueryTypeOpts>;
+    /**
+     * Accepts a list of where statements, each of
+     * which is combined via `OR`
+     *
+     * ```ts
+     * await User.query().whereAny([{ email: 'how@yadoin' }, { name: 'fred' }]).first()
+     * // [User{email: 'how@yadoin'}, User{name: 'fred'}, User{name: 'fred'}]
+     * ```
+     *
+     * @param whereStatements - a list of where statements to `OR` together
+     * @returns A cloned Query with the whereAny clause applied
+     */
+    whereAny<DB extends DreamInstance['DB'], Schema extends DreamInstance['schema']>(whereStatements: WhereStatementForJoinedAssociation<QueryTypeOpts['joinedAssociations'], DB, Schema, QueryTypeOpts['rootTableName']>[] | null): Query<DreamInstance, QueryTypeOpts>;
+    /**
+     * Applies a whereNot statement to the Query instance
+     *
+     * ```ts
+     * await User.query().whereNot({ email: 'how@yadoin' }).first()
+     * // User{email: 'hello@world'}
+     * ```
+     *
+     * @param whereStatement - A where statement to negate and apply to the Query
+     * @returns A cloned Query with the whereNot clause applied
+     */
+    whereNot<DB extends DreamInstance['DB'], Schema extends DreamInstance['schema']>(whereStatement: WhereStatementForJoinedAssociation<QueryTypeOpts['joinedAssociations'], DB, Schema, QueryTypeOpts['rootTableName']> | null): Query<DreamInstance, QueryTypeOpts>;
+    /**
+     * @internal
+     *
+     * Applies a where clause
+     */
+    private _where;
+    /**
+     * Returns a new Kysely SelectQueryBuilder instance to be used
+     * in a sub Query
+     *
+     * ```ts
+     * const records = await User.where({
+     *   id: Post.query().nestedSelect('userId'),
+     * }).all()
+     * // [User{id: 1}, ...]
+     * ```
+     *
+     * @param selection - the column to use for your nested Query
+     * @returns A Kysely SelectQueryBuilder instance
+     */
+    nestedSelect<SimpleFieldType extends keyof DreamColumnNames<DreamInstance>, PluckThroughFieldType>(this: Query<DreamInstance, QueryTypeOpts>, selection: SimpleFieldType | PluckThroughFieldType): SelectQueryBuilder<any, any, any>;
+    /**
+     * Returns a new Query instance, attaching the provided
+     * order statement
+     *
+     * ```ts
+     * await User.query().order('id').all()
+     * // [User{id: 1}, User{id: 2}, ...]
+     * ```
+     *
+     * ```ts
+     * await User.query().order({ name: 'asc', id: 'desc' }).all()
+     * // [User{name: 'a', id: 99}, User{name: 'a', id: 97}, User{ name: 'b', id: 98 } ...]
+     * ```
+     *
+     * @param orderStatement - Either a string or an object specifying order. If a string, the order is implicitly ascending. If the orderStatement is an object, statements will be provided in the order of the keys set in the object
+     * @returns A cloned Query with the order clause applied
+     */
+    order<Q extends Query<DreamInstance, QueryTypeOpts>, DB extends DreamInstance['DB'], ColumnName extends ColumnNamesAccountingForJoinedAssociations<Q['queryTypeOpts']['joinedAssociations'], DB, QueryTypeOpts['rootTableName'], QueryTypeOpts['rootTableAlias']>>(arg: ColumnName | Partial<Record<ColumnName, OrderDir>> | null): this;
+    /**
+     * Returns a new Query instance, specifying a limit
+     *
+     * ```ts
+     * await User.order('id').limit(2).all()
+     * // [User{id: 1}, User{id: 2}]
+     * ```
+     *
+     * @returns A cloned Query with the limit clause applied
+     */
+    limit(limit: number | null): Query<DreamInstance, QueryTypeOpts>;
+    /**
+     * Returns a new Query instance, specifying an offset
+     *
+     * ```ts
+     * await User.order('id').offset(2).limit(2).all()
+     * // [User{id: 3}, User{id: 4}]
+     * ```
+     *
+     * @returns A cloned Query with the offset clause applied
+     */
+    offset(offset: number | null): Query<DreamInstance, QueryTypeOpts>;
+    /**
+     * Returns the sql that would be executed by this Query
+     *
+     * ```ts
+     * User.where({ email: 'how@yadoin' }).sql()
+     * // {
+     * //  query: {
+     * //    kind: 'SelectQueryNode',
+     * //    from: { kind: 'FromNode', froms: [Array] },
+     * //    selections: [ [Object] ],
+     * //    distinctOn: undefined,
+     * //    joins: undefined,
+     * //    groupBy: undefined,
+     * //    orderBy: undefined,
+     * //    where: { kind: 'WhereNode', where: [Object] },
+     * //    frontModifiers: undefined,
+     * //    endModifiers: undefined,
+     * //    limit: undefined,
+     * //    offset: undefined,
+     * //    with: undefined,
+     * //    having: undefined,
+     * //    explain: undefined,
+     * //    setOperations: undefined
+     * //  },
+     * //  sql: 'select "users".* from "users" where ("users"."email" = $1 and "users"."deleted_at" is null)',
+     * //  parameters: [ 'how@yadoin' ]
+     * //}
+     * ```
+     *
+     * @returns An object representing the underlying sql statement
+     *
+     */
+    sql(): import("kysely").CompiledQuery<{
+        [x: string]: any;
+    }>;
+    /**
+     * Converts the given dream class into a Kysely query, enabling
+     * you to build custom queries using the Kysely API
+     *
+     * ```ts
+     * await User.query().toKysely('select').where('email', '=', 'how@yadoin').execute()
+     * ```
+     *
+     * @param type - the type of Kysely query builder instance you would like to obtain
+     * @returns A Kysely query. Depending on the type passed, it will return either a SelectQueryBuilder, DeleteQueryBuilder, or an UpdateQueryBuilder
+     */
+    toKysely<QueryType extends 'select' | 'delete' | 'update', ToKyselyReturnType = QueryType extends 'select' ? SelectQueryBuilder<DreamInstance['DB'], DreamInstance['table'], unknown> : QueryType extends 'delete' ? DeleteQueryBuilder<DreamInstance['DB'], DreamInstance['table'], unknown> : QueryType extends 'update' ? UpdateQueryBuilder<DreamInstance['DB'], DreamInstance['table'], DreamInstance['table'], unknown> : never>(type: QueryType): ToKyselyReturnType;
+    /**
+     * Applies transaction to the Query instance
+     *
+     * ```ts
+     * await ApplicationModel.transaction(async txn => {
+     *   await User.query().txn(txn).create({ email: 'how@yadoin' })
+     * })
+     * ```
+     *
+     * @param txn - A DreamTransaction instance (usually collected by calling `ApplicationModel.transaction`)
+     * @returns A cloned Query with the transaction applied
+     *
+     */
+    txn(dreamTransaction: DreamTransaction<Dream>): this;
+    /**
+     * Retrieves the number of records in the database
+     *
+     * ```ts
+     * await User.query().count()
+     * ```
+     *
+     * @returns The number of records in the database
+     */
+    count(): Promise<number>;
+    /**
+     * Returns new Query with distinct clause applied
+     *
+     * ```ts
+     * await User.query().distinct('name').pluck('name')
+     * ```
+     *
+     * @returns A cloned Query with the distinct clause applied
+     */
+    distinct(column?: TableColumnNames<DreamInstance['DB'], DreamInstance['table']> | boolean): this;
+    /**
+     * @internal
+     *
+     * Returns a namespaced column name
+     *
+     * @returns A string
+     */
+    private namespaceColumn;
+    /**
+     * Retrieves the max value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await User.query().max('id')
+     * // 99
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the max value of the specified column for this Query
+     *
+     */
+    max<Q extends Query<DreamInstance, QueryTypeOpts>, DB extends DreamInstance['DB'], ColumnName extends ColumnNamesAccountingForJoinedAssociations<Q['queryTypeOpts']['joinedAssociations'], DB, QueryTypeOpts['rootTableName'], QueryTypeOpts['rootTableAlias']>, ReturnType extends NamespacedOrBaseModelColumnTypes<[ColumnName], Q, DreamInstance>[0]>(columnName: ColumnName): Promise<ReturnType>;
+    /**
+     * Retrieves the min value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await User.query().min('id')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the min value of the specified column for this Query
+     */
+    min<Q extends Query<DreamInstance, QueryTypeOpts>, DB extends DreamInstance['DB'], ColumnName extends ColumnNamesAccountingForJoinedAssociations<Q['queryTypeOpts']['joinedAssociations'], DB, QueryTypeOpts['rootTableName'], QueryTypeOpts['rootTableAlias']>, ReturnType extends NamespacedOrBaseModelColumnTypes<[ColumnName], Q, DreamInstance>[0]>(columnName: ColumnName): Promise<ReturnType>;
+    /**
+     * @internal
+     *
+     * Runs the query and extracts plucked values
+     *
+     * @returns An array of plucked values
+     */
+    private executePluck;
+    /**
+     * @internal
+     *
+     */
+    private executeJoinLoad;
+    private fleshOutJoinLoadExecutionResults;
+    private hydratePreloadedThroughColumns;
+    /**
+     * Plucks the provided fields from the given dream class table
+     *
+     * ```ts
+     * await User.order('id').pluck('id')
+     * // [1, 2, 3]
+     * ```
+     *
+     * If more than one column is requested, a multi-dimensional
+     * array is returned:
+     *
+     * ```ts
+     * await User.order('id').pluck('id', 'email')
+     * // [[1, 'a@a.com'], [2, 'b@b.com']]
+     * ```
+     *
+     * @param columnNames - The column or array of columns to pluck
+     * @returns An array of pluck results
+     */
+    pluck<Q extends Query<DreamInstance, QueryTypeOpts>, DB extends DreamInstance['DB'], const ColumnNames extends ColumnNamesAccountingForJoinedAssociations<Q['queryTypeOpts']['joinedAssociations'], DB, QueryTypeOpts['rootTableName'], QueryTypeOpts['rootTableAlias']>[], ReturnValue extends ColumnNames['length'] extends 1 ? NamespacedOrBaseModelColumnTypes<ColumnNames, Q, DreamInstance>[0][] : NamespacedOrBaseModelColumnTypes<ColumnNames, Q, DreamInstance>[]>(this: Q, ...columnNames: ColumnNames): Promise<ReturnValue>;
+    /**
+     * Plucks the specified column names from the given dream class table
+     * in batches, passing each found columns into the
+     * provided callback function
+     *
+     * ```ts
+     * await User.order('id').pluckEach('id', (id) => {
+     *   console.log(id)
+     * })
+     * // 1
+     * // 2
+     * // 3
+     * ```
+     *
+     * @param args - a list of column names to pluck, followed by a callback function to call for each set of found fields
+     * @returns void
+     */
+    pluckEach<Q extends Query<DreamInstance, QueryTypeOpts>, DB extends DreamInstance['DB'], const ColumnNames extends ColumnNamesAccountingForJoinedAssociations<Q['queryTypeOpts']['joinedAssociations'], DB, QueryTypeOpts['rootTableName'], QueryTypeOpts['rootTableAlias']>[], CbArgTypes extends NamespacedOrBaseModelColumnTypes<ColumnNames, Q, DreamInstance>>(this: Q, ...args: PluckEachArgs<ColumnNames, CbArgTypes>): Promise<void>;
+    /**
+     * Retrieves an array containing all records matching the Query.
+     * Be careful using this, since it will attempt to pull every
+     * record into memory at once. When querying might return a large
+     * number of records, consider using `.findEach`, which will pull
+     * the records in batches.
+     *
+     * ```ts
+     * await User.query().all()
+     * ```
+     *
+     * @returns an array of dreams
+     */
+    all(options?: {
+        columns?: DreamColumnNames<DreamInstance>[];
+    }): Promise<DreamInstance[]>;
+    /**
+     * Forces use of a database connection (e.g. 'primary') during the query.
+     *
+     * NOTE: all queries within a transaction always use the 'primary' replica, so
+     * explicitly setting connection within a transaction has no effect.
+     *
+     * @param connection - The connection you wish to access ('primary' or 'replica')
+     * @returns A Query with the requested connection
+     */
+    connection(connection: DbConnectionType): this;
+    private _connection;
+    /**
+     * Returns true if a record exists for the given
+     * Query
+     *
+     * ```ts
+     * await User.query().exists()
+     * // false
+     *
+     * await User.create({ email: 'how@yadoin' })
+     *
+     * await User.query().exists()
+     * // true
+     * ```
+     *
+     * @returns boolean
+     */
+    exists(): Promise<boolean>;
+    /**
+     * Returns the first record in the database
+     * matching the Query. If the Query is not
+     * ordered, it will automatically order
+     * by primary key.
+     *
+     * ```ts
+     * await User.query().first()
+     * // User{id: 1}
+     * ```
+     *
+     * @returns First record in the database, or null if no record exists
+     */
+    first(): Promise<DreamInstance | null>;
+    /**
+     * Returns the first record in the database
+     * matching the Query. If the Query is not
+     * ordered, it will automatically order
+     * by primary key. If no record is found,
+     * an exception is raised.
+     *
+     * ```ts
+     * await User.query().first()
+     * // User{id: 1}
+     * ```
+     *
+     * @returns First record in the database, or null if no record exists
+     */
+    firstOrFail(): Promise<DreamInstance>;
+    /**
+     * Returns the last record in the database
+     * matching the Query. If the Query is not
+     * ordered, it will automatically order
+     * by primary key.
+     *
+     * ```ts
+     * await User.query().last()
+     * // User{id: 99}
+     * ```
+     *
+     * @returns Last record in the database, or null if no record exists
+     */
+    last(): Promise<DreamInstance | null>;
+    /**
+     * Returns the last record in the database
+     * matching the Query. If the Query is not
+     * ordered, it will automatically order
+     * by primary key. If no record is found,
+     * it will raise an exception.
+     *
+     * ```ts
+     * await User.where(...).lastOrFail()
+     * // User{id: 99}
+     * ```
+     *
+     * @returns Last record in the database, or null if no record exists
+     */
+    lastOrFail(): Promise<DreamInstance>;
+    /**
+     * Destroys all records matching the Query,
+     * calling model hooks and cascading destroy
+     * to associations with `dependent: 'destroy'`,
+     * and returns the number of records that
+     * were destroyed.
+     *
+     * To delete in a single database query,
+     * ignoring model hooks and association
+     * dependent-destroy declarations, use
+     * {@link Query.delete | delete} instead.
+     *
+     * ```ts
+     * await User.where({ email: ops.ilike('%burpcollaborator%') }).destroy()
+     * // 12
+     * ```
+     *
+     * @param options - Options for destroying the instance
+     * @param options.skipHooks - If true, skips applying model hooks during the destroy operation. Defaults to false
+     * @param options.cascade - If false, skips destroying associations marked `dependent: 'destroy'`. Defaults to true
+     * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when cascade destroying. Defaults to false
+     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade destroying. Defaults to an empty array
+     * @returns The number of records that were removed
+     */
+    destroy({ skipHooks, cascade, }?: {
+        skipHooks?: boolean;
+        cascade?: boolean;
+    }): Promise<number>;
+    /**
+     * Destroys all records matching the Query,
+     * ignoring the SoftDelete decorator and
+     * permanently removing records from the database.
+     *
+     * Calls model hooks and applies cascade destroy
+     * to associations with `dependent: 'destroy'`,
+     * returning the number of records that
+     * were destroyed.
+     *
+     * To destroy without bypassing the SoftDelete
+     * decorator, use {@link Query.(destroy:instance) | destroy} instead.
+     *
+     * ```ts
+     * await User.where({ email: ops.ilike('%burpcollaborator%') }).reallyDestroy()
+     * // 12
+     * ```
+     *
+     * @param options - Options for destroying the instance
+     * @param options.skipHooks - If true, skips applying model hooks during the destroy operation. Defaults to false
+     * @param options.cascade - If false, skips destroying associations marked `dependent: 'destroy'`. Defaults to true
+     * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when cascade destroying. Defaults to false
+     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade destroying. Defaults to an empty array
+     * @returns The number of records that were removed
+     */
+    reallyDestroy({ skipHooks, cascade, }?: {
+        skipHooks?: boolean;
+        cascade?: boolean;
+    }): Promise<number>;
+    /**
+     * Undestroys a SoftDelete model, unsetting
+     * the `deletedAt` field in the database.
+     *
+     * If the model is not a SoftDelete model,
+     * this will raise an exception.
+     *
+     * ```ts
+     * await User.where({ email: ops.ilike('%burpcollaborator%') }).undestroy()
+     * // 12
+     * ```
+     *
+     * @param options - Options for undestroying the instance
+     * @param options.skipHooks - If true, skips applying model hooks during the undestroy operation. Defaults to false
+     * @param options.cascade - If false, skips undestroying associations marked `dependent: 'destroy'`. Defaults to true
+     * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when cascade undestroying. Defaults to false
+     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade undestroying (soft delete is always bypassed). Defaults to an empty array
+     * @returns The number of records that were removed
+     */
+    undestroy({ cascade, skipHooks, }?: {
+        cascade?: boolean;
+        skipHooks?: boolean;
+    }): Promise<number>;
+    /**
+     * Deletes all records matching query using a single
+     * database query, but does not call underlying callbacks.
+     * Ignores association dependent destroy declarations,
+     * though cascading may still happen at the database level.
+     *
+     * To apply model hooks and association dependent destroy,
+     * use {@link Query.(destroy:instance) | destroy} instead.
+     *
+     * ```ts
+     * await User.where({ email: ops.ilike('%burpcollaborator%').delete() })
+     * // 12
+     * ```
+     *
+     * @returns The number of records that were removed
+     */
+    delete(): Promise<number>;
+    /**
+     * Updates all records matching the Query
+     *
+     * ```ts
+     * await User.where({ email: ops.ilike('%burpcollaborator%') }).updateAll({ email: null })
+     * // 12
+     * ```
+     * @param attributes - The attributes used to update the records
+     * @param options - Options for updating the instance
+     * @param options.skipHooks - If true, skips applying model hooks. Defaults to false
+     * @returns The number of records that were updated
+     */
+    update(attributes: DreamTableSchema<DreamInstance>, { skipHooks }?: {
+        skipHooks?: boolean;
+    }): Promise<number>;
+    private updateWithoutCallingModelHooks;
+    /**
+     * @internal
+     *
+     * Used for applying first and last queries
+     *
+     * @returns A dream instance or null
+     */
+    private takeOne;
+    /**
+     * @internal
+     *
+     * Used to hydrate dreams with the provided associations
+     */
+    private hydrateAssociation;
+    /**
+     * @internal
+     *
+     * Used to bridge through associations
+     */
+    private followThroughAssociation;
+    /**
+     * @internal
+     *
+     * Polymorphic BelongsTo. Since polymorphic associations may point to multiple tables,
+     * preload by loading each target class separately.
+     *
+     * Used to preload polymorphic belongs to associations
+     */
+    private preloadPolymorphicBelongsTo;
+    private preloadPolymorphicAssociationModel;
+    /**
+     * @internal
+     *
+     * Applies a preload statement
+     */
+    private applyOnePreload;
+    /**
+     * @internal
+     *
+     * Used by loadBuider
+     */
+    private hydratePreload;
+    /**
+     * @internal
+     *
+     * Applies a preload statement
+     */
+    private applyPreload;
+    /**
+     * @internal
+     *
+     * retrieves on statements that can be applied to a preload
+     */
+    private applyablePreloadOnStatements;
+    private conditionallyApplyDefaultScopes;
+    private joinsBridgeThroughAssociations;
+    private applyOneJoin;
+    private applyAssociationOnStatementsToJoinStatement;
+    private conditionallyApplyDefaultScopesDependentOnAssociation;
+    private distinctColumnNameForAssociation;
+    private recursivelyJoin;
+    private throwUnlessAllRequiredWhereClausesProvided;
+    private applyOrderStatementForAssociation;
+    private inArrayWithNull_or_notInArrayWithoutNull_ExpressionBuilder;
+    private inArrayWithoutNullExpressionBuilder;
+    private notInArrayWithNullExpressionBuilder;
+    private whereStatementToExpressionWrapper;
+    private dreamWhereStatementToExpressionBuilderParts;
+    private applyJoinOnStatements;
+    private _applyJoinOnStatements;
+    private _applyJoinOnAnyStatements;
+    private joinOnStatementToExpressionWrapper;
+    private buildCommon;
+    private checkForQueryViolations;
+    private aliasWhereStatements;
+    private aliasWhereStatement;
+    private rawifiedSelfOnClause;
+    private buildDelete;
+    private buildSelect;
+    private columnsWithRequiredLoadColumns;
+    private buildUpdate;
+    private attachLimitAndOrderStatementsToNonSelectQuery;
+    private get hasSimilarityClauses();
+    private similarityStatementBuilder;
+    private conditionallyAttachSimilarityColumnsToSelect;
+    private conditionallyAttachSimilarityColumnsToUpdate;
+    private invertOrder;
+}
+export interface QueryOpts<DreamInstance extends Dream, ColumnType extends DreamColumnNames<DreamInstance> = DreamColumnNames<DreamInstance>, Schema extends DreamInstance['schema'] = DreamInstance['schema'], DB extends DreamInstance['DB'] = DreamInstance['DB'], PassthroughColumns extends PassthroughColumnNames<DreamInstance> = PassthroughColumnNames<DreamInstance>> {
+    baseSqlAlias?: TableOrAssociationName<Schema>;
+    baseSelectQuery?: Query<any, any> | null;
+    passthroughOnStatement?: PassthroughOnClause<PassthroughColumns> | null;
+    where?: readonly WhereStatement<DB, Schema, any>[] | null;
+    whereNot?: readonly WhereStatement<DB, Schema, any>[] | null;
+    limit?: LimitStatement | null;
+    offset?: OffsetStatement | null;
+    or?: WhereStatement<DB, Schema, any>[][] | null;
+    order?: OrderQueryStatement<ColumnType>[] | null;
+    loadFromJoins?: boolean;
+    preloadStatements?: RelaxedPreloadStatement;
+    preloadOnStatements?: RelaxedPreloadOnStatement<DB, Schema>;
+    distinctColumn?: ColumnType | null;
+    innerJoinDreamClasses?: readonly (typeof Dream)[];
+    innerJoinStatements?: RelaxedJoinStatement;
+    innerJoinOnStatements?: RelaxedJoinOnStatement<DB, Schema>;
+    leftJoinStatements?: RelaxedJoinStatement;
+    leftJoinOnStatements?: RelaxedJoinOnStatement<DB, Schema>;
+    bypassAllDefaultScopes?: boolean;
+    bypassAllDefaultScopesExceptOnAssociations?: boolean;
+    defaultScopesToBypass?: AllDefaultScopeNames<DreamInstance>[];
+    defaultScopesToBypassExceptOnAssociations?: DefaultScopeName<DreamInstance>[];
+    transaction?: DreamTransaction<Dream> | null | undefined;
+    connection?: DbConnectionType;
+    shouldReallyDestroy?: boolean;
+}
+export interface PreloadedDreamsAndWhatTheyPointTo {
+    dream: Dream;
+    pointsToPrimaryKey: IdType;
+}
+export interface FindEachOpts {
+    batchSize?: number;
+}
+export type ExtendQueryType<OriginalOpts extends Readonly<QueryTypeOptions>, Opts extends Readonly<Partial<QueryTypeOptions>>> = Readonly<{
+    joinedAssociations: Opts['joinedAssociations'] extends Readonly<JoinedAssociation[]> ? Readonly<[...OriginalOpts['joinedAssociations'], ...Opts['joinedAssociations']]> : OriginalOpts['joinedAssociations'];
+    rootTableName: OriginalOpts['rootTableName'];
+    rootTableAlias: OriginalOpts['rootTableAlias'];
+    allowPreload: Opts['allowPreload'] extends false ? false : OriginalOpts['allowPreload'];
+    allowLeftJoinPreload: Opts['allowLeftJoinPreload'] extends false ? false : OriginalOpts['allowLeftJoinPreload'];
+}>;
+export type NamespacedColumnType<ColumnName, Q extends Query<any, any>, DreamInstance extends Dream, JoinedAssociationsArr = Q['queryTypeOpts']['joinedAssociations'], AssociationName = ColumnName extends `${infer Name extends string}.${string}` ? Name : never, RealColumnName = ColumnName extends `${string}.${infer Col extends string}` ? Col : never, JoinedAssociation extends FindInterfaceWithValue<JoinedAssociationsArr, 'alias', AssociationName> = FindInterfaceWithValue<JoinedAssociationsArr, 'alias', AssociationName>, JoinedTable = JoinedAssociation['table'] extends never ? DreamInstance['table'] : JoinedAssociation['table'], ReturnType = TableColumnType<DreamInstance['schema'], JoinedTable, RealColumnName>> = ReturnType;
+type NamespacedColumnTypes<ColumnNames, Q extends Query<any, any>, DreamInstance extends Dream> = ColumnNames extends Readonly<[infer First, ...infer Rest]> ? [
+    NamespacedColumnType<First, Q, DreamInstance>,
+    ...NamespacedColumnTypes<Readonly<Rest>, Q, DreamInstance>
+] : [];
+export type BaseModelColumnTypes<ColumnNames, DreamInstance extends Dream> = ColumnNames extends Readonly<[infer First, ...infer Rest]> ? [
+    TableColumnType<DreamInstance['schema'], DreamInstance['table'], First>,
+    ...BaseModelColumnTypes<Readonly<Rest>, DreamInstance>
+] : [];
+export type NamespacedOrBaseModelColumnTypes<ColumnNames, Q extends Query<any, any>, DreamInstance extends Dream> = Q['queryTypeOpts']['joinedAssociations']['length'] extends 0 ? BaseModelColumnTypes<ColumnNames, DreamInstance> : NamespacedColumnTypes<ColumnNames, Q, DreamInstance>;
+export {};