@rvoh/dream 2.6.1-alpha.1 → 2.7.0

package/dist/types/src/ops/index.d.ts

@@ -4,45 +4,290 @@ import CurriedOpsStatement from './curried-ops-statement.js';
 import OpsStatement from './ops-statement.js';
 type ArrayOperatorType = 'in' | 'not in';
 declare const ops: {
+    /**
+     * Creates an `OpsStatement` with an arbitrary Kysely comparison operator or trigram operator.
+     * Use this as an escape hatch when none of the named helpers cover your use case.
+     *
+     * @param operator - Any Kysely comparison operator (e.g. `'='`, `'<'`) or trigram operator.
+     * @param value - The value to compare against.
+     * @returns An `OpsStatement` wrapping the given operator and value.
+     *
+     * @example
+     * User.where({ name: ops.expression('like', '%ello%') })
+     */
     expression: <const T, const Operator extends KyselyComparisonOperatorExpression | TrigramOperator, const ComputedT extends Operator extends ArrayOperatorType ? (T & Readonly<unknown[]>)[number] : T>(operator: Operator, value: T) => OpsStatement<Operator, ComputedT, any>;
+    /**
+     * Creates an `OpsStatement` that checks whether a JSONB column contains the given object
+     * using the PostgreSQL `@>` (contains) operator.
+     *
+     * @param searchObj - A plain object whose key/value pairs must be present in the JSONB column.
+     * @returns An `OpsStatement` using `@> <searchObj>::jsonb`.
+     *
+     * @example
+     * Post.where({ metadata: ops.jsonb({ published: true }) })
+     */
+    jsonb: (searchObj: object) => OpsStatement<"@>", import("kysely").RawBuilder<unknown>, undefined>;
+    /**
+     * Creates an `OpsStatement` for a SQL `IN` clause, matching rows whose column value
+     * is one of the provided array elements.
+     *
+     * @param arr - The array of values to match against.
+     * @returns An `OpsStatement` using the `in` operator.
+     *
+     * @example
+     * User.where({ status: ops.in(['active', 'pending']) })
+     */
     in: <const T extends unknown[]>(arr: T) => OpsStatement<"in", T[number], undefined>;
+    /**
+     * Creates a `CurriedOpsStatement` that checks whether a PostgreSQL array column contains
+     * the given value using `@> ARRAY[value]::type`. The column type is resolved at query-build
+     * time from the Dream model's schema.
+     *
+     * Throws `AnyRequiresArrayColumn` if the target column is not a database array type.
+     *
+     * @param value - The scalar value that must be present in the array column.
+     * @returns A `CurriedOpsStatement` that resolves to an `OpsStatement` once bound to a model and field.
+     *
+     * @example
+     * Post.where({ tags: ops.any('typescript') })
+     */
     any: <const AnyT>(value: AnyT) => CurriedOpsStatement<any, any, any, AnyT>;
+    /**
+     * Creates an `OpsStatement` using the SQL `LIKE` operator for case-sensitive pattern matching.
+     * Use `%` as a wildcard in the pattern string.
+     *
+     * @param like - The pattern string (e.g. `'%hello%'`).
+     * @returns An `OpsStatement` using the `like` operator.
+     *
+     * @example
+     * User.where({ name: ops.like('%alice%') })
+     */
     like: (like: string) => OpsStatement<"like", string, undefined>;
+    /**
+     * Creates an `OpsStatement` using the SQL `ILIKE` operator for case-insensitive pattern matching.
+     * Use `%` as a wildcard in the pattern string.
+     *
+     * @param ilike - The pattern string (e.g. `'%hello%'`).
+     * @returns An `OpsStatement` using the `ilike` operator.
+     *
+     * @example
+     * User.where({ name: ops.ilike('%alice%') })
+     */
     ilike: (ilike: string) => OpsStatement<"ilike", string, undefined>;
+    /**
+     * Creates an `OpsStatement` that matches a column against a POSIX regular expression.
+     * By default the match is case-sensitive (`~`); pass `{ caseInsensitive: true }` to use `~*`.
+     *
+     * @param match - The regular expression pattern.
+     * @param options.caseInsensitive - When `true`, uses the `~*` operator instead of `~`. Defaults to `false`.
+     * @returns An `OpsStatement` using `~` or `~*`.
+     *
+     * @example
+     * User.where({ email: ops.match('^admin', { caseInsensitive: true }) })
+     */
     match: (match: string, { caseInsensitive }?: {
         caseInsensitive?: boolean;
     }) => OpsStatement<"~" | "~*", string, undefined>;
+    /**
+     * Creates an `OpsStatement` using the `=` operator for strict equality.
+     *
+     * @param equal - The value the column must equal.
+     * @returns An `OpsStatement` using the `=` operator.
+     *
+     * @example
+     * User.where({ role: ops.equal('admin') })
+     */
     equal: <const T>(equal: T) => OpsStatement<"=", T, undefined>;
+    /**
+     * Creates an `OpsStatement` using the `<` operator.
+     *
+     * @param lessThan - The value the column must be less than.
+     * @returns An `OpsStatement` using the `<` operator.
+     *
+     * @example
+     * Order.where({ total: ops.lessThan(100) })
+     */
     lessThan: <const T>(lessThan: T) => OpsStatement<"<", T, undefined>;
+    /**
+     * Creates an `OpsStatement` using the `<=` operator.
+     *
+     * @param lessThanOrEqualTo - The value the column must be less than or equal to.
+     * @returns An `OpsStatement` using the `<=` operator.
+     *
+     * @example
+     * Order.where({ total: ops.lessThanOrEqualTo(100) })
+     */
     lessThanOrEqualTo: <const T>(lessThanOrEqualTo: T) => OpsStatement<"<=", T, undefined>;
+    /**
+     * Creates an `OpsStatement` using the `>` operator.
+     *
+     * @param greaterThan - The value the column must be greater than.
+     * @returns An `OpsStatement` using the `>` operator.
+     *
+     * @example
+     * Order.where({ total: ops.greaterThan(50) })
+     */
     greaterThan: <const T>(greaterThan: T) => OpsStatement<">", T, undefined>;
+    /**
+     * Creates an `OpsStatement` using the `>=` operator.
+     *
+     * @param greaterThanOrEqualTo - The value the column must be greater than or equal to.
+     * @returns An `OpsStatement` using the `>=` operator.
+     *
+     * @example
+     * Order.where({ total: ops.greaterThanOrEqualTo(50) })
+     */
     greaterThanOrEqualTo: <const T>(greaterThanOrEqualTo: T) => OpsStatement<">=", T, undefined>;
+    /**
+     * Creates an `OpsStatement` for PostgreSQL trigram similarity (`%` operator).
+     * Rows are included when the similarity score meets or exceeds `score`.
+     *
+     * Requires the `pg_trgm` extension to be enabled.
+     *
+     * @param similarity - The string to compare against the column.
+     * @param options.score - Minimum similarity threshold (0–1). Defaults to `0.3`.
+     * @returns An `OpsStatement` using the `%` trigram operator.
+     *
+     * @example
+     * User.where({ name: ops.similarity('alice', { score: 0.4 }) })
+     */
     similarity: (similarity: string, { score }?: {
         score?: number;
     }) => OpsStatement<"%", string, {
         score: number;
     }>;
+    /**
+     * Creates an `OpsStatement` for PostgreSQL word similarity (`<%` operator).
+     * Rows are included when the word similarity score meets or exceeds `score`.
+     *
+     * Requires the `pg_trgm` extension to be enabled.
+     *
+     * @param similarity - The string to compare against the column.
+     * @param options.score - Minimum word similarity threshold (0–1). Defaults to `0.5`.
+     * @returns An `OpsStatement` using the `<%` trigram operator.
+     *
+     * @example
+     * Article.where({ title: ops.wordSimilarity('postgres', { score: 0.6 }) })
+     */
     wordSimilarity: (similarity: string, { score }?: {
         score?: number;
     }) => OpsStatement<"<%", string, {
         score: number;
     }>;
+    /**
+     * Creates an `OpsStatement` for PostgreSQL strict word similarity (`<<%` operator).
+     * Rows are included when the strict word similarity score meets or exceeds `score`.
+     *
+     * Requires the `pg_trgm` extension to be enabled.
+     *
+     * @param similarity - The string to compare against the column.
+     * @param options.score - Minimum strict word similarity threshold (0–1). Defaults to `0.6`.
+     * @returns An `OpsStatement` using the `<<%` trigram operator.
+     *
+     * @example
+     * Article.where({ title: ops.strictWordSimilarity('postgres', { score: 0.7 }) })
+     */
     strictWordSimilarity: (similarity: string, { score }?: {
         score?: number;
     }) => OpsStatement<"<<%", string, {
         score: number;
     }>;
+    /** Negated variants of the standard comparison operators. */
     not: {
+        /**
+         * Creates an `OpsStatement` for a SQL `NOT IN` clause, excluding rows whose column value
+         * is one of the provided array elements.
+         *
+         * @param arr - The array of values to exclude.
+         * @returns An `OpsStatement` using the `not in` operator.
+         *
+         * @example
+         * User.where({ status: ops.not.in(['banned', 'deleted']) })
+         */
         in: <const T extends unknown[]>(arr: T) => OpsStatement<"not in", T[number], undefined>;
+        /**
+         * Creates an `OpsStatement` using the `NOT LIKE` operator for case-sensitive pattern exclusion.
+         *
+         * @param like - The pattern string (e.g. `'%spam%'`).
+         * @returns An `OpsStatement` using the `not like` operator.
+         *
+         * @example
+         * User.where({ email: ops.not.like('%@example.com') })
+         */
         like: (like: string) => OpsStatement<"not like", string, undefined>;
+        /**
+         * Creates an `OpsStatement` using the `NOT ILIKE` operator for case-insensitive pattern exclusion.
+         *
+         * @param ilike - The pattern string (e.g. `'%spam%'`).
+         * @returns An `OpsStatement` using the `not ilike` operator.
+         *
+         * @example
+         * User.where({ email: ops.not.ilike('%@example.com') })
+         */
         ilike: (ilike: string) => OpsStatement<"not ilike", string, undefined>;
+        /**
+         * Creates an `OpsStatement` that excludes rows matching a POSIX regular expression.
+         * By default the match is case-sensitive (`!~`); pass `{ caseInsensitive: true }` to use `!~*`.
+         *
+         * @param match - The regular expression pattern.
+         * @param options.caseInsensitive - When `true`, uses `!~*` instead of `!~`. Defaults to `false`.
+         * @returns An `OpsStatement` using `!~` or `!~*`.
+         *
+         * @example
+         * User.where({ email: ops.not.match('^admin', { caseInsensitive: true }) })
+         */
         match: (match: string, { caseInsensitive }?: {
             caseInsensitive?: boolean;
         }) => OpsStatement<"!~" | "!~*", string, undefined>;
+        /**
+         * Creates an `OpsStatement` using the `!=` operator for inequality.
+         *
+         * @param equal - The value the column must not equal.
+         * @returns An `OpsStatement` using the `!=` operator.
+         *
+         * @example
+         * User.where({ role: ops.not.equal('guest') })
+         */
         equal: <const T>(equal: T) => OpsStatement<"!=", T, undefined>;
+        /**
+         * Creates an `OpsStatement` that negates `<`, equivalent to `>=`.
+         *
+         * @param lessThan - The value used as the lower bound (inclusive).
+         * @returns An `OpsStatement` using `>=`.
+         *
+         * @example
+         * Order.where({ total: ops.not.lessThan(100) }) // total >= 100
+         */
         lessThan: <const T>(lessThan: T) => OpsStatement<">=", T, undefined>;
+        /**
+         * Creates an `OpsStatement` that negates `<=`, equivalent to `>`.
+         *
+         * @param lessThanOrEqualTo - The value used as the lower bound (exclusive).
+         * @returns An `OpsStatement` using `>`.
+         *
+         * @example
+         * Order.where({ total: ops.not.lessThanOrEqualTo(100) }) // total > 100
+         */
         lessThanOrEqualTo: <const T>(lessThanOrEqualTo: T) => OpsStatement<">", T, undefined>;
+        /**
+         * Creates an `OpsStatement` that negates `>`, equivalent to `<=`.
+         *
+         * @param greaterThan - The value used as the upper bound (inclusive).
+         * @returns An `OpsStatement` using `<=`.
+         *
+         * @example
+         * Order.where({ total: ops.not.greaterThan(50) }) // total <= 50
+         */
         greaterThan: <const T>(greaterThan: T) => OpsStatement<"<=", T, undefined>;
+        /**
+         * Creates an `OpsStatement` that negates `>=`, equivalent to `<`.
+         *
+         * @param greaterThanOrEqualTo - The value used as the upper bound (exclusive).
+         * @returns An `OpsStatement` using `<`.
+         *
+         * @example
+         * Order.where({ total: ops.not.greaterThanOrEqualTo(50) }) // total < 50
+         */
         greaterThanOrEqualTo: <const T>(greaterThanOrEqualTo: T) => OpsStatement<"<", T, undefined>;
     };
 };

package/dist/types/src/types/associations/shared.d.ts

@@ -1,4 +1,4 @@
-import { ComparisonOperatorExpression as KyselyComparisonOperatorExpression, Selectable, SelectQueryBuilder } from 'kysely';
+import { ComparisonOperatorExpression as KyselyComparisonOperatorExpression, RawBuilder, Selectable, SelectQueryBuilder } from 'kysely';
 import Dream from '../../Dream.js';
 import { DreamConst } from '../../dream/constants.js';
 import { Range } from '../../helpers/range.js';
@@ -25,7 +25,7 @@ export type PassthroughOnClause<PassthroughColumns extends string[]> = Partial<R
 type DreamSelectable<DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB> = Partial<{
     [ColumnName in keyof DB[TableName]]: NonKyselySupportedSupplementalWhereClauseValues<DB, Schema, TableName, ColumnName>;
 }>;
-type NonKyselySupportedSupplementalWhereClauseValues<DB, Schema, TableName, Column, ModelPropertyType = ModelColumnType<Schema, TableName, Column>, ColumnType = TableColumnType<Schema, TableName, Column>, EnumTypeArray extends string[] | null = TableColumnEnumTypeArray<Schema, TableName, Column>, PermanentOpsValTypes = null | readonly [], OpsValType = EnumTypeArray extends null ? ColumnType extends 'bigint' ? TypesAllowedForBigintAgainstTheDb | PermanentOpsValTypes : ModelPropertyType extends DateTime | CalendarDate ? DateTime | CalendarDate | null : ModelPropertyType extends ClockTime ? ClockTime | null : ModelPropertyType extends ClockTimeTz ? ClockTimeTz | null : ModelPropertyType extends number | string ? ModelPropertyType | PermanentOpsValTypes : never : EnumTypeArray extends string[] ? EnumTypeArray[number] | PermanentOpsValTypes : never, PartialTypes = EnumTypeArray extends null ? ModelPropertyType extends DateTime ? Range<DateTime | CalendarDate> | Range<null, DateTime | CalendarDate> | (() => Range<DateTime | CalendarDate>) | (() => Range<null, DateTime | CalendarDate>) | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any> : ModelPropertyType extends ClockTime ? Range<ClockTime> | Range<null, ClockTime> | (() => Range<ClockTime>) | (() => Range<null, ClockTime>) | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any> : ModelPropertyType extends ClockTimeTz ? Range<ClockTimeTz> | Range<null, ClockTimeTz> | (() => Range<ClockTimeTz>) | (() => Range<null, ClockTimeTz>) | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any> : ModelPropertyType extends CalendarDate ? Range<DateTime | CalendarDate> | Range<null, DateTime | CalendarDate> | (() => Range<DateTime | CalendarDate>) | (() => Range<null, DateTime | CalendarDate>) | OpsStatement<KyselyComparisonOperatorExpression, OpsValType> : ColumnType extends 'bigint' ? Range<TypesAllowedForBigintAgainstTheDb> | Range<null, TypesAllowedForBigintAgainstTheDb> | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any> : ModelPropertyType extends number ? Range<ModelPropertyType> | Range<null, ModelPropertyType> | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any> : ModelPropertyType extends string ? Range<string> | Range<null, string> | OpsStatement<KyselyComparisonOperatorExpression, string, any> | OpsStatement<TrigramOperator, OpsValType, ExtraSimilarityArgs> : never : EnumTypeArray extends string[] ? EnumTypeArray | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any> : never> = PartialTypes extends never ? OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any> | CurriedOpsStatement<any, any, any, OpsValType> | SelectQueryBuilder<DB, keyof DB, any> : PartialTypes | CurriedOpsStatement<any, any, any, OpsValType> | SelectQueryBuilder<DB, keyof DB, any>;
+type NonKyselySupportedSupplementalWhereClauseValues<DB, Schema, TableName, Column, ModelPropertyType = ModelColumnType<Schema, TableName, Column>, ColumnType = TableColumnType<Schema, TableName, Column>, EnumTypeArray extends string[] | null = TableColumnEnumTypeArray<Schema, TableName, Column>, PermanentOpsValTypes = null | readonly [], OpsValType = EnumTypeArray extends null ? ColumnType extends 'bigint' ? TypesAllowedForBigintAgainstTheDb | PermanentOpsValTypes : ModelPropertyType extends DateTime | CalendarDate ? DateTime | CalendarDate | null : ModelPropertyType extends ClockTime ? ClockTime | null : ModelPropertyType extends ClockTimeTz ? ClockTimeTz | null : ModelPropertyType extends number | string ? ModelPropertyType | PermanentOpsValTypes : never : EnumTypeArray extends string[] ? EnumTypeArray[number] | PermanentOpsValTypes : never, ResolvedOpsValType = OpsValType | RawBuilder<unknown>, PartialTypes = EnumTypeArray extends null ? ModelPropertyType extends DateTime ? Range<DateTime | CalendarDate> | Range<null, DateTime | CalendarDate> | (() => Range<DateTime | CalendarDate>) | (() => Range<null, DateTime | CalendarDate>) | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType, any> : ModelPropertyType extends ClockTime ? Range<ClockTime> | Range<null, ClockTime> | (() => Range<ClockTime>) | (() => Range<null, ClockTime>) | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType, any> : ModelPropertyType extends ClockTimeTz ? Range<ClockTimeTz> | Range<null, ClockTimeTz> | (() => Range<ClockTimeTz>) | (() => Range<null, ClockTimeTz>) | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType, any> : ModelPropertyType extends CalendarDate ? Range<DateTime | CalendarDate> | Range<null, DateTime | CalendarDate> | (() => Range<DateTime | CalendarDate>) | (() => Range<null, DateTime | CalendarDate>) | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType> : ColumnType extends 'bigint' ? Range<TypesAllowedForBigintAgainstTheDb> | Range<null, TypesAllowedForBigintAgainstTheDb> | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType, any> : ModelPropertyType extends number ? Range<ModelPropertyType> | Range<null, ModelPropertyType> | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType, any> : ModelPropertyType extends string ? Range<string> | Range<null, string> | OpsStatement<KyselyComparisonOperatorExpression, string, any> | OpsStatement<TrigramOperator, ResolvedOpsValType, ExtraSimilarityArgs> : never : EnumTypeArray extends string[] ? EnumTypeArray | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType, any> : never> = PartialTypes extends never ? OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType, any> | CurriedOpsStatement<any, any, any, ResolvedOpsValType> | SelectQueryBuilder<DB, keyof DB, any> : PartialTypes | CurriedOpsStatement<any, any, any, ResolvedOpsValType> | SelectQueryBuilder<DB, keyof DB, any>;
 export type WhereStatementForDreamClass<DreamClass extends typeof Dream> = WhereStatement<InstanceType<DreamClass>>;
 export type WhereStatementForDream<DreamInstance extends Dream> = WhereStatement<DreamInstance>;
 type AssociationNameToDotReferencedColumns<DB, TableName extends keyof DB, AssociationName> = `${AssociationName & string}.${TableColumnNames<DB, TableName>}`;

package/dist/types/src/types/associations/shared.ts

@@ -1,5 +1,6 @@
 import {
   ComparisonOperatorExpression as KyselyComparisonOperatorExpression,
+  RawBuilder,
   Selectable,
   SelectQueryBuilder,
 } from 'kysely'
@@ -105,6 +106,8 @@ type NonKyselySupportedSupplementalWhereClauseValues<
       ? EnumTypeArray[number] | PermanentOpsValTypes
       : never,
   //
+  ResolvedOpsValType = OpsValType | RawBuilder<unknown>,
+  //
   PartialTypes = EnumTypeArray extends null
     ? ModelPropertyType extends DateTime
       ?
@@ -112,54 +115,57 @@ type NonKyselySupportedSupplementalWhereClauseValues<
           | Range<null, DateTime | CalendarDate>
           | (() => Range<DateTime | CalendarDate>)
           | (() => Range<null, DateTime | CalendarDate>)
-          | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any>
+          | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType, any>
       : ModelPropertyType extends ClockTime
         ?
             | Range<ClockTime>
             | Range<null, ClockTime>
             | (() => Range<ClockTime>)
             | (() => Range<null, ClockTime>)
-            | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any>
+            | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType, any>
         : ModelPropertyType extends ClockTimeTz
           ?
               | Range<ClockTimeTz>
               | Range<null, ClockTimeTz>
               | (() => Range<ClockTimeTz>)
               | (() => Range<null, ClockTimeTz>)
-              | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any>
+              | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType, any>
           : ModelPropertyType extends CalendarDate
             ?
                 | Range<DateTime | CalendarDate>
                 | Range<null, DateTime | CalendarDate>
                 | (() => Range<DateTime | CalendarDate>)
                 | (() => Range<null, DateTime | CalendarDate>)
-                | OpsStatement<KyselyComparisonOperatorExpression, OpsValType>
+                | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType>
             : ColumnType extends 'bigint'
               ?
                   | Range<TypesAllowedForBigintAgainstTheDb>
                   | Range<null, TypesAllowedForBigintAgainstTheDb>
-                  | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any>
+                  | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType, any>
               : ModelPropertyType extends number
                 ?
                     | Range<ModelPropertyType>
                     | Range<null, ModelPropertyType>
-                    | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any>
+                    | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType, any>
                 : ModelPropertyType extends string
                   ?
                       | Range<string>
                       | Range<null, string>
                       | OpsStatement<KyselyComparisonOperatorExpression, string, any>
-                      | OpsStatement<TrigramOperator, OpsValType, ExtraSimilarityArgs>
+                      | OpsStatement<TrigramOperator, ResolvedOpsValType, ExtraSimilarityArgs>
                   : never
     : EnumTypeArray extends string[]
-      ? EnumTypeArray | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any>
+      ? EnumTypeArray | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType, any>
       : never,
 > = PartialTypes extends never
   ?
-      | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any>
-      | CurriedOpsStatement<any, any, any, OpsValType>
+      | OpsStatement<KyselyComparisonOperatorExpression, ResolvedOpsValType, any>
+      | CurriedOpsStatement<any, any, any, ResolvedOpsValType>
+      | SelectQueryBuilder<DB, keyof DB, any>
+  :
+      | PartialTypes
+      | CurriedOpsStatement<any, any, any, ResolvedOpsValType>
       | SelectQueryBuilder<DB, keyof DB, any>
-  : PartialTypes | CurriedOpsStatement<any, any, any, OpsValType> | SelectQueryBuilder<DB, keyof DB, any>
 
 export type WhereStatementForDreamClass<DreamClass extends typeof Dream> = WhereStatement<
   InstanceType<DreamClass>

package/docs/assets/search.js

@@ -1 +1 @@
-window.searchData = "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";
+window.searchData = "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";