diff --git a/src/expressions/delete.ts b/src/expressions/delete.ts
index fc2fc6c..9ba178f 100644
--- a/src/expressions/delete.ts
+++ b/src/expressions/delete.ts
@@ -1,4 +1,4 @@
-import type { AnyValueSource, IBooleanValueSource, IExecutableDeleteQuery, IIfValueSource, ValueSourceOf, ValueSourceValueTypeForResult } from "./values"
+import type { AnyValueSource, IAnyBooleanValueSource, IExecutableDeleteQuery, ValueSourceOf, ValueSourceValueTypeForResult } from "./values"
 import type { ForUseInLeftJoin, HasSource, IRawFragment, ITableOrView, OfDB, OfSameDB } from "../utils/ITableOrView"
 import type { ResultObjectValues, ResultObjectValuesProjectedAsNullable } from "../utils/resultUtils"
 import type { NNoTableOrViewRequiredFrom, NSource } from "../utils/sourceName"
@@ -28,16 +28,13 @@ export interface CustomizableExecutableDelete</*in|out*/ TABLE extends HasSource
 }
 
 export interface DynamicExecutableDeleteExpression</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends ReturnableExecutableDelete<TABLE, USING> {
-    and(condition: IIfValueSource <USING[typeof source], any>): DynamicExecutableDeleteExpression<TABLE, USING>
-    and(condition: IBooleanValueSource <USING[typeof source], any>): DynamicExecutableDeleteExpression<TABLE, USING>
-    or(condition: IIfValueSource <USING[typeof source], any>): DynamicExecutableDeleteExpression<TABLE, USING>
-    or(condition: IBooleanValueSource <USING[typeof source], any>): DynamicExecutableDeleteExpression<TABLE, USING>
+    and(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicExecutableDeleteExpression<TABLE, USING>
+    or(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicExecutableDeleteExpression<TABLE, USING>
 }
 
 export interface DeleteWhereExpression</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends DeleteExpressionBase<TABLE, USING> {
     dynamicWhere() : DynamicExecutableDeleteExpression<TABLE, USING>
-    where(condition: IIfValueSource <USING[typeof source], any>): DynamicExecutableDeleteExpression<TABLE, USING>
-    where(condition: IBooleanValueSource <USING[typeof source], any>): DynamicExecutableDeleteExpression<TABLE, USING>
+    where(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicExecutableDeleteExpression<TABLE, USING>
 }
 
 export interface DeleteExpression</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends DeleteWhereExpression<TABLE, USING> {
@@ -50,8 +47,7 @@ export interface DeleteExpression</*in|out*/ TABLE extends HasSource<any>, /*in|
 
 export interface DeleteWhereExpressionAllowingNoWhere</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends ReturnableExecutableDelete<TABLE, USING> {
     dynamicWhere() : DynamicExecutableDeleteExpression<TABLE, USING>
-    where(condition: IIfValueSource <USING[typeof source], any>): DynamicExecutableDeleteExpression<TABLE, USING>
-    where(condition: IBooleanValueSource <USING[typeof source], any>): DynamicExecutableDeleteExpression<TABLE, USING>
+    where(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicExecutableDeleteExpression<TABLE, USING>
 }
 
 export interface DeleteExpressionAllowingNoWhere</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends DeleteWhereExpressionAllowingNoWhere<TABLE, USING> {
@@ -74,16 +70,13 @@ export interface DeleteWhereJoinExpression</*in|out*/ TABLE extends HasSource<an
 }
 
 export interface DynamicOnExpression</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends DeleteWhereJoinExpression<TABLE, USING> {
-    and(condition: IIfValueSource <USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
-    and(condition: IBooleanValueSource <USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
-    or(condition: IIfValueSource <USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
-    or(condition: IBooleanValueSource <USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
+    and(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
+    or(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
 }
 
 export interface OnExpression</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends DeleteWhereJoinExpression<TABLE, USING> {
     dynamicOn(): DynamicOnExpression<TABLE, USING>
-    on(condition: IIfValueSource <USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
-    on(condition: IBooleanValueSource <USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
+    on(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
 }
 
 export interface DeleteExpressionWithoutJoin</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends DeleteWhereExpression<TABLE, USING> {
@@ -121,16 +114,13 @@ export interface DeleteWhereJoinExpressionAllowingNoWhere</*in|out*/ TABLE exten
 }
 
 export interface DynamicOnExpressionAllowingNoWhere</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends DeleteWhereJoinExpressionAllowingNoWhere<TABLE, USING> {
-    and(condition: IIfValueSource <USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
-    and(condition: IBooleanValueSource <USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
-    or(condition: IIfValueSource <USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
-    or(condition: IBooleanValueSource <USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
+    and(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
+    or(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
 }
 
 export interface OnExpressionAllowingNoWhere</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends DeleteWhereJoinExpressionAllowingNoWhere<TABLE, USING> {
     dynamicOn(): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
-    on(condition: IIfValueSource <USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
-    on(condition: IBooleanValueSource <USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
+    on(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
 }
 
 export interface DeleteExpressionWithoutJoinAllowingNoWhere</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends DeleteWhereExpressionAllowingNoWhere<TABLE, USING> {
diff --git a/src/expressions/fragment.ts b/src/expressions/fragment.ts
index 3ba356f..b4d12e4 100644
--- a/src/expressions/fragment.ts
+++ b/src/expressions/fragment.ts
@@ -1,4 +1,4 @@
-import type { BooleanValueSource, NumberValueSource, StringValueSource, LocalDateValueSource, LocalTimeValueSource, LocalDateTimeValueSource, EqualableValueSource, ComparableValueSource, RemapValueSourceType, TypeOfArgument, MapArgumentToValueSource, ArgForFn, IfValueSource, ArgForBuilderIfValue, IBooleanValueSource, IIfValueSource, BigintValueSource, OptionalType, ValueSourceOf, UuidValueSource, CustomIntValueSource, CustomDoubleValueSource, CustomUuidValueSource, CustomLocalDateTimeValueSource, CustomLocalDateValueSource, CustomLocalTimeValueSource, IValueSource, RemapValueSourceTypeWithOptionalType, OptionalTypeOfValue, ArgBaseTypeForFn, MergeOptionalUnion } from "../expressions/values"
+import type { BooleanValueSource, NumberValueSource, StringValueSource, LocalDateValueSource, LocalTimeValueSource, LocalDateTimeValueSource, EqualableValueSource, ComparableValueSource, RemapValueSourceType, TypeOfArgument, MapArgumentToValueSource, ArgForFn, IfValueSource, ArgForBuilderIfValue, IAnyBooleanValueSource, BigintValueSource, OptionalType, ValueSourceOf, UuidValueSource, CustomIntValueSource, CustomDoubleValueSource, CustomUuidValueSource, CustomLocalDateTimeValueSource, CustomLocalDateValueSource, CustomLocalTimeValueSource, IValueSource, RemapValueSourceTypeWithOptionalType, OptionalTypeOfValue, ArgBaseTypeForFn, MergeOptionalUnion } from "../expressions/values"
 import type { optionalType, source } from "../utils/symbols"
 import type { NSource } from "../utils/sourceName"
 
@@ -285,27 +285,27 @@ export interface FragmentFunction5</*in|out*/ NO_SOURCE extends NSource, A1, A2,
 }
 
 export interface FragmentBuilder0IfValue</*in|out*/ NO_SOURCE extends NSource> {
-    as<RESULT extends IBooleanValueSource<NO_SOURCE, any> | IIfValueSource<NO_SOURCE, any>>(impl: () => RESULT): () => IfValueSource<NO_SOURCE, RESULT[typeof optionalType]>
+    as<RESULT extends IAnyBooleanValueSource<NO_SOURCE, any>>(impl: () => RESULT): () => IfValueSource<NO_SOURCE, RESULT[typeof optionalType]>
 }
 
 export interface FragmentBuilder1IfValue</*in|out*/ NO_SOURCE extends NSource, A1> {
-    as<RESULT extends IBooleanValueSource<NO_SOURCE, any> | IIfValueSource<NO_SOURCE, any>>(impl: (a1: ArgForBuilderIfValue<NO_SOURCE, A1>) => RESULT): FragmentFunctionIfValue1<NO_SOURCE, A1, RESULT[typeof optionalType]>
+    as<RESULT extends IAnyBooleanValueSource<NO_SOURCE, any>>(impl: (a1: ArgForBuilderIfValue<NO_SOURCE, A1>) => RESULT): FragmentFunctionIfValue1<NO_SOURCE, A1, RESULT[typeof optionalType]>
 }
 
 export interface FragmentBuilder2IfValue</*in|out*/ NO_SOURCE extends NSource, A1, A2> {
-    as<RESULT extends IBooleanValueSource<NO_SOURCE, any> | IIfValueSource<NO_SOURCE, any>>(impl: (a1: ArgForBuilderIfValue<NO_SOURCE, A1>, a2: ArgForBuilderIfValue<NO_SOURCE, A2>) => RESULT): FragmentFunctionIfValue2<NO_SOURCE, A1, A2, RESULT[typeof optionalType]>
+    as<RESULT extends IAnyBooleanValueSource<NO_SOURCE, any>>(impl: (a1: ArgForBuilderIfValue<NO_SOURCE, A1>, a2: ArgForBuilderIfValue<NO_SOURCE, A2>) => RESULT): FragmentFunctionIfValue2<NO_SOURCE, A1, A2, RESULT[typeof optionalType]>
 }
 
 export interface FragmentBuilder3IfValue</*in|out*/ NO_SOURCE extends NSource, A1, A2, A3> {
-    as<RESULT extends IBooleanValueSource<NO_SOURCE, any> | IIfValueSource<NO_SOURCE, any>>(impl: (a1: ArgForBuilderIfValue<NO_SOURCE, A1>, a2: ArgForBuilderIfValue<NO_SOURCE, A2>, a3: ArgForBuilderIfValue<NO_SOURCE, A3>) => RESULT): FragmentFunctionIfValue3<NO_SOURCE, A1, A2, A3, RESULT[typeof optionalType]>
+    as<RESULT extends IAnyBooleanValueSource<NO_SOURCE, any>>(impl: (a1: ArgForBuilderIfValue<NO_SOURCE, A1>, a2: ArgForBuilderIfValue<NO_SOURCE, A2>, a3: ArgForBuilderIfValue<NO_SOURCE, A3>) => RESULT): FragmentFunctionIfValue3<NO_SOURCE, A1, A2, A3, RESULT[typeof optionalType]>
 }
 
 export interface FragmentBuilder4IfValue</*in|out*/ NO_SOURCE extends NSource, A1, A2, A3, A4> {
-    as<RESULT extends IBooleanValueSource<NO_SOURCE, any> | IIfValueSource<NO_SOURCE, any>>(impl: (a1: ArgForBuilderIfValue<NO_SOURCE, A1>, a2: ArgForBuilderIfValue<NO_SOURCE, A2>, a3: ArgForBuilderIfValue<NO_SOURCE, A3>, a4: ArgForBuilderIfValue<NO_SOURCE, A4>) => RESULT): FragmentFunctionIfValue4<NO_SOURCE, A1, A2, A3, A4, RESULT[typeof optionalType]>
+    as<RESULT extends IAnyBooleanValueSource<NO_SOURCE, any>>(impl: (a1: ArgForBuilderIfValue<NO_SOURCE, A1>, a2: ArgForBuilderIfValue<NO_SOURCE, A2>, a3: ArgForBuilderIfValue<NO_SOURCE, A3>, a4: ArgForBuilderIfValue<NO_SOURCE, A4>) => RESULT): FragmentFunctionIfValue4<NO_SOURCE, A1, A2, A3, A4, RESULT[typeof optionalType]>
 }
 
 export interface FragmentBuilder5IfValue</*in|out*/ NO_SOURCE extends NSource, A1, A2, A3, A4, A5> {
-    as<RESULT extends BooleanValueSource<NO_SOURCE, any> | IIfValueSource<NO_SOURCE, any>>(impl: (a1: ArgForBuilderIfValue<NO_SOURCE, A1>, a2: ArgForBuilderIfValue<NO_SOURCE, A2>, a3: ArgForBuilderIfValue<NO_SOURCE, A3>, a4: ArgForBuilderIfValue<NO_SOURCE, A4>, a5: ArgForBuilderIfValue<NO_SOURCE, A5>) => RESULT): FragmentFunctionIfValue5<NO_SOURCE, A1, A2, A3, A4, A5, RESULT[typeof optionalType]>
+    as<RESULT extends IAnyBooleanValueSource<NO_SOURCE, any>>(impl: (a1: ArgForBuilderIfValue<NO_SOURCE, A1>, a2: ArgForBuilderIfValue<NO_SOURCE, A2>, a3: ArgForBuilderIfValue<NO_SOURCE, A3>, a4: ArgForBuilderIfValue<NO_SOURCE, A4>, a5: ArgForBuilderIfValue<NO_SOURCE, A5>) => RESULT): FragmentFunctionIfValue5<NO_SOURCE, A1, A2, A3, A4, A5, RESULT[typeof optionalType]>
 }
 
 export interface FragmentFunctionIfValue1</*in|out*/ NO_SOURCE extends NSource, A1, /*in|out*/ OPTIONAL_TYPE extends OptionalType> {
diff --git a/src/expressions/insert.ts b/src/expressions/insert.ts
index af59284..a9c4f4c 100644
--- a/src/expressions/insert.ts
+++ b/src/expressions/insert.ts
@@ -1,4 +1,4 @@
-import type { IExecutableSelectQuery, RemapIValueSourceType, ValueSourceValueType, AnyValueSource, ValueSourceOf, ValueSourceValueTypeForResult, RemapIValueSourceTypeWithOptionalType, IExecutableInsertQuery, IIfValueSource, IBooleanValueSource, IStringValueSource } from "./values"
+import type { IExecutableSelectQuery, RemapIValueSourceType, ValueSourceValueType, AnyValueSource, ValueSourceOf, ValueSourceValueTypeForResult, RemapIValueSourceTypeWithOptionalType, IExecutableInsertQuery, IAnyBooleanValueSource, IStringValueSource } from "./values"
 import type { HasSource, IRawFragment, OfDB, ResolvedShape } from "../utils/ITableOrView"
 import type { from, source, using } from "../utils/symbols"
 import type { ColumnWithDefaultValue } from "../utils/Column"
@@ -882,16 +882,13 @@ export interface ShapedInsertOnConflictSetsExpression</*in|out*/ TABLE extends H
 }
 
 export interface DynamicOnConflictWhereExpression</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>, NEXT> {
-    and(condition: IIfValueSource<USING[typeof source], any>): DynamicOnConflictWhereExpression<TABLE, USING,  NEXT> & NEXT
-    and(condition: IBooleanValueSource<USING[typeof source], any>): DynamicOnConflictWhereExpression<TABLE, USING,  NEXT> & NEXT
-    or(condition: IIfValueSource<USING[typeof source], any>): DynamicOnConflictWhereExpression<TABLE, USING,  NEXT> & NEXT
-    or(condition: IBooleanValueSource<USING[typeof source], any>): DynamicOnConflictWhereExpression<TABLE, USING,  NEXT> & NEXT
+    and(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnConflictWhereExpression<TABLE, USING,  NEXT> & NEXT
+    or(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnConflictWhereExpression<TABLE, USING,  NEXT> & NEXT
 }
 
 export interface OnConflictOnColumnWhere</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>, NEXT> {
     dynamicWhere() : DynamicOnConflictWhereExpression<TABLE, USING,  NEXT> & NEXT
-    where(condition: IIfValueSource<USING[typeof source], any>): DynamicOnConflictWhereExpression<TABLE, USING,  NEXT> & NEXT
-    where(condition: IBooleanValueSource<USING[typeof source], any>): DynamicOnConflictWhereExpression<TABLE, USING,  NEXT> & NEXT
+    where(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnConflictWhereExpression<TABLE, USING,  NEXT> & NEXT
 }
 
 type OnConflictDoNothingFnType<TABLE extends HasSource<any>, _USING extends HasSource<any>, NEXT> =
@@ -934,8 +931,7 @@ type OnConflictDoUpdateWhereFnType<TABLE extends HasSource<any>, USING extends H
     : never
 
 interface OnConflictDoUpdateWhereFnTypeInterface</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>, /*in|out*/ NEXT> {
-    (condition: IIfValueSource<USING[typeof source], any>): DynamicOnConflictWhereExpression<TABLE, USING,  NEXT> & NEXT
-    (condition: IBooleanValueSource<USING[typeof source], any>): DynamicOnConflictWhereExpression<TABLE, USING,  NEXT> & NEXT
+    (condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnConflictWhereExpression<TABLE, USING,  NEXT> & NEXT
 }
 
 type OnConflictOnColumnFnType<TABLE extends HasSource<any>, USING extends HasSource<any>, NEXT> =
diff --git a/src/expressions/select.ts b/src/expressions/select.ts
index 619da4a..110872c 100644
--- a/src/expressions/select.ts
+++ b/src/expressions/select.ts
@@ -1,4 +1,4 @@
-import type { IBooleanValueSource, INumberValueSource, IIfValueSource, IExecutableSelectQuery, AnyValueSource, ValueSourceOf, ValueSourceValueTypeForResult, RemapValueSourceType, RemapValueSourceTypeWithOptionalType, AggregatedArrayValueSource, IValueSource, RemapIValueSourceType } from "./values"
+import type { IBooleanValueSource, INumberValueSource, IAnyBooleanValueSource, IExecutableSelectQuery, AnyValueSource, ValueSourceOf, ValueSourceValueTypeForResult, RemapValueSourceType, RemapValueSourceTypeWithOptionalType, AggregatedArrayValueSource, IValueSource, RemapIValueSourceType } from "./values"
 import type { ForUseInLeftJoin, HasSource, IRawFragment, ITableOrView, NoTableOrViewRequiredOfSameDB, OfDB, OfSameDB } from "../utils/ITableOrView"
 import type { WithView } from "../utils/tableOrViewUtils"
 import type { resultType, compoundableColumns, valueType, from, using, source, selectColumnsType } from "../utils/symbols"
@@ -146,15 +146,12 @@ export interface CompoundableExecutableSelectExpressionWithoutWhere</*in|out*/ F
 
 export interface WhereableCompoundableExecutableSelectExpressionWithoutWhere</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends CompoundableExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
     dynamicWhere(): DynamicWhereLastCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    where(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereLastCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    where(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereLastCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    where(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereLastCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 }
 
 export interface DynamicWhereLastCompoundableCustomizableExecutableSelectExpression</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends WithableExecutableSelect<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
-    and(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereLastCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    and(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereLastCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    or(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereLastCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    or(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereLastCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    and(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereLastCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    or(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereLastCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 }
 
 export interface CompoundableCustomizableExecutableSelectExpression</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends CompoundableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
@@ -214,8 +211,7 @@ export interface OrderableExecutableSelectExpressionWithoutWhere</*in|out*/ FROM
 
 export interface LimitExecutableSelectExpressionWithoutWhere</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends CompoundableCustomizableExecutableSelectExpressionWitoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
     dynamicWhere(): DynamicWhereLimitExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    where(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereLimitExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    where(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereLimitExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    where(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereLimitExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
     
     limit(limit: number): OffsetExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
     limitIfValue(limit: number | null | undefined): OffsetExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
@@ -238,31 +234,25 @@ export interface OffsetExecutableSelectExpressionWithoutWhere</*in|out*/ FROM ex
     offsetIfValue(offset: number | null | undefined): CompoundableCustomizableExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 
     dynamicWhere(): DynamicWhereCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    where(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    where(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    where(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 }
 
 export interface CompoundableCustomizableExpressionWithoutWhere</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends CompoundableCustomizableExecutableSelectExpressionWitoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
     dynamicWhere(): DynamicWhereCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    where(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    where(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    where(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 }
 
 export interface DynamicWhereLimitExecutableSelectExpression</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends CompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
-    and(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereLimitExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    and(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereLimitExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    or(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereLimitExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    or(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereLimitExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    and(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereLimitExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    or(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereLimitExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 
     limit(limit: number): OffsetExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
     limitIfValue(limit: number | null | undefined): OffsetExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 }
 
 export interface DynamicWhereCompoundableCustomizableExecutableSelectExpression</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends CompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
-    and(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    and(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    or(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    or(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    and(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    or(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereCompoundableCustomizableExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 }
 
 export interface RecursivelyConnectedExecutableSelectExpression</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends OrderByExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
@@ -285,27 +275,22 @@ export interface GroupByOrderByHavingExecutableSelectExpression</*in|out*/ FROM
     groupBy(...columns: ValueSourceOf<FROM[typeof source]>[]): GroupByOrderByHavingExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES | 'groupBy'>
 
     dynamicHaving(): DynamicHavingExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    having(condition: IIfValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    having(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    having(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 }
 
 export interface DynamicHavingExecutableSelectExpression</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends OrderByExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
-    and(condition: IIfValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    and(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    or(condition: IIfValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    or(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    and(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    or(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 }
 
 export interface GroupByOrderHavingByExpressionWithoutSelect</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ FEATURES> extends SelectExpressionBase<FROM, REQUIRED> {
     groupBy(...columns: ValueSourceOf<FROM[typeof source]>[]): GroupByOrderHavingByExpressionWithoutSelect<FROM, REQUIRED, FEATURES | 'groupBy'>
 
     dynamicHaving(): DynamicHavingExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    having(condition: IIfValueSource<FROM[typeof source], any>): DynamicHavingExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    having(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicHavingExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
+    having(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicHavingExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
 
     dynamicWhere(): DynamicWhereSelectExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    where(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereSelectExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    where(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereSelectExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
+    where(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereSelectExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
 
     select<COLUMNS extends SelectColumns<FROM[typeof source]>>(columns: COLUMNS): WhereableExecutableSelectExpressionWithGroupByProjectableAsNullable<FROM, REQUIRED, COLUMNS, ResultObjectValues<COLUMNS>, FEATURES>
     selectOneColumn<COLUMN extends ValueSourceOf<FROM[typeof source]>>(column: COLUMN): WhereableExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMN, ValueSourceValueTypeForResult<COLUMN>, FEATURES>
@@ -313,14 +298,11 @@ export interface GroupByOrderHavingByExpressionWithoutSelect</*in|out*/ FROM ext
 }
 
 export interface DynamicHavingExpressionWithoutSelect</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ FEATURES> extends SelectExpressionBase<FROM, REQUIRED> {
-    and(condition: IIfValueSource<FROM[typeof source], any>): DynamicHavingExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    and(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicHavingExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    or(condition: IIfValueSource<FROM[typeof source], any>): DynamicHavingExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    or(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicHavingExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
+    and(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicHavingExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
+    or(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicHavingExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
 
     dynamicWhere(): DynamicWhereSelectExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    where(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereSelectExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    where(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereSelectExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
+    where(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereSelectExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
 
     select<COLUMNS extends SelectColumns<FROM[typeof source]>>(columns: COLUMNS): WhereableExecutableSelectExpressionWithGroupByProjectableAsNullable<FROM, REQUIRED, COLUMNS, ResultObjectValues<COLUMNS>, FEATURES>
     selectOneColumn<COLUMN extends ValueSourceOf<FROM[typeof source]>>(column: COLUMN): WhereableExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMN, ValueSourceValueTypeForResult<COLUMN>, FEATURES>
@@ -328,10 +310,8 @@ export interface DynamicHavingExpressionWithoutSelect</*in|out*/ FROM extends Ha
 }
 
 export interface DynamicWhereSelectExpressionWithoutSelect</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ FEATURES> extends SelectExpressionBase<FROM, REQUIRED> {
-    and(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereSelectExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    and(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereSelectExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    or(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereSelectExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    or(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereSelectExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
+    and(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereSelectExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
+    or(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereSelectExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
 
     select<COLUMNS extends SelectColumns<FROM[typeof source]>>(columns: COLUMNS): OrderByExecutableSelectExpressionProjectableAsNullable<FROM, REQUIRED, COLUMNS, ResultObjectValues<COLUMNS>, FEATURES>
     selectOneColumn<COLUMN extends ValueSourceOf<FROM[typeof source]>>(column: COLUMN): OrderByExecutableSelectExpression<FROM, REQUIRED, COLUMN, ValueSourceValueTypeForResult<COLUMN>, FEATURES>
@@ -347,10 +327,8 @@ export interface RecursivelyConnectedExpressionWithoutSelect</*in|out*/ FROM ext
 }
 
 export interface DynamicWhereExpressionWithoutSelect</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ FEATURES> extends RecursivelyConnectedExpressionWithoutSelect<FROM, REQUIRED, FEATURES> {
-    and(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    and(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    or(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    or(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
+    and(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
+    or(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
 
     startWith: StartWithFnType<FROM, REQUIRED, RecursivelyConnectedExpressionWithoutSelect<FROM, REQUIRED, FEATURES | 'connectBy'>>
     connectBy: ConnectByFnType<FROM, REQUIRED, RecursivelyConnectedExpressionWithoutSelect<FROM, REQUIRED, FEATURES | 'connectBy'>>
@@ -358,16 +336,13 @@ export interface DynamicWhereExpressionWithoutSelect</*in|out*/ FROM extends Has
 }
 
 export interface DynamicWhereExecutableSelectExpression</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends GroupByOrderByExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
-    and(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    and(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    or(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    or(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    and(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    or(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 }
 
 export interface WhereableExecutableSelectExpressionWithGroupBy</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends OrderableExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
     dynamicWhere(): DynamicWhereExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    where(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    where(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    where(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 }
 
 export interface WhereableExecutableSelectExpressionWithGroupByProjectableAsNullable</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends WhereableExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
@@ -375,10 +350,8 @@ export interface WhereableExecutableSelectExpressionWithGroupByProjectableAsNull
 }
 
 export interface DynamicWhereExecutableSelectExpressionWithGroupBy</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends OrderByExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
-    and(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    and(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    or(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    or(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    and(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    or(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 }
 
 export interface GroupByOrderByHavingExecutableSelectExpressionWithoutWhere</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends WhereableExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
@@ -386,15 +359,12 @@ export interface GroupByOrderByHavingExecutableSelectExpressionWithoutWhere</*in
     groupBy(...columns: ValueSourceOf<FROM[typeof source]>[]): GroupByOrderByHavingExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES | 'groupBy'>
 
     dynamicHaving(): DynamicHavingExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    having(condition: IIfValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    having(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    having(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 }
 
 export interface DynamicHavingExecutableSelectExpressionWithoutWhere</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends WhereableExecutableSelectExpressionWithGroupBy<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
-    and(condition: IIfValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    and(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    or(condition: IIfValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    or(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    and(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    or(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicHavingExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 }
 
 export interface RecursivelyConnectedExecutableSelectExpressionWithoutWhere</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends OrderableExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
@@ -402,8 +372,7 @@ export interface RecursivelyConnectedExecutableSelectExpressionWithoutWhere</*in
     groupBy(...columns: ValueSourceOf<FROM[typeof source]>[]): GroupByOrderByHavingExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES | 'groupBy'>
     
     dynamicWhere(): DynamicWhereExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    where(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
-    where(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
+    where(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereExecutableSelectExpression<FROM, REQUIRED, COLUMNS, RESULT, FEATURES>
 }
 
 export interface ExecutableSelectExpressionWithoutWhere</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ COLUMNS, /*in|out*/ RESULT, /*in|out*/ FEATURES> extends RecursivelyConnectedExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMNS, RESULT, FEATURES> {
@@ -421,8 +390,7 @@ export interface RecursivelyConnectedSelectWhereExpression</*in|out*/ FROM exten
     selectOneColumn<COLUMN extends ValueSourceOf<FROM[typeof source]>>(column: COLUMN): ExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, COLUMN, ValueSourceValueTypeForResult<COLUMN>, FEATURES>
     selectCountAll(): ExecutableSelectExpressionWithoutWhere<FROM, REQUIRED, INumberValueSource<NNoTableOrViewRequiredFrom<REQUIRED[typeof source]>, 'required'>, number, FEATURES| 'requiredResult'>
     dynamicWhere(): DynamicWhereExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    where(condition: IIfValueSource<FROM[typeof source], any>): DynamicWhereExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
-    where(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicWhereExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
+    where(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicWhereExpressionWithoutSelect<FROM, REQUIRED, FEATURES>
     groupBy(...columns: ValueSourceOf<FROM[typeof source]>[]): GroupByOrderHavingByExpressionWithoutSelect<FROM, REQUIRED, FEATURES | 'groupBy'>
 }
 
@@ -444,16 +412,13 @@ export interface SelectWhereJoinExpression</*in|out*/ FROM extends HasSource<any
 }
 
 export interface DynamicOnExpression</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ FEATURES> extends SelectWhereJoinExpression<FROM, REQUIRED, FEATURES> {
-    and(condition: IIfValueSource<FROM[typeof source], any>): DynamicOnExpression<FROM, REQUIRED, FEATURES>
-    and(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicOnExpression<FROM, REQUIRED, FEATURES>
-    or(condition: IIfValueSource<FROM[typeof source], any>): DynamicOnExpression<FROM, REQUIRED, FEATURES>
-    or(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicOnExpression<FROM, REQUIRED, FEATURES>
+    and(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicOnExpression<FROM, REQUIRED, FEATURES>
+    or(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicOnExpression<FROM, REQUIRED, FEATURES>
 }
 
 export interface OnExpression</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ FEATURES> extends SelectWhereJoinExpression<FROM, REQUIRED, FEATURES> {
     dynamicOn(): DynamicOnExpression<FROM, REQUIRED, FEATURES>
-    on(condition: IIfValueSource<FROM[typeof source], any>): DynamicOnExpression<FROM, REQUIRED, FEATURES>
-    on(condition: IBooleanValueSource<FROM[typeof source], any>): DynamicOnExpression<FROM, REQUIRED, FEATURES>
+    on(condition: IAnyBooleanValueSource<FROM[typeof source], any>): DynamicOnExpression<FROM, REQUIRED, FEATURES>
 }
 
 export interface SelectExpressionWithoutJoin</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ FEATURES> extends SelectWhereExpression<FROM, REQUIRED, FEATURES> {
@@ -534,8 +499,7 @@ type StartWithFnType<FROM extends HasSource<any>, REQUIRED extends HasSource<any
         : never
 
 export interface StartWithFn</*in|out*/ FROM extends HasSource<any>, /*in|out*/ REQUIRED extends HasSource<any>, /*in|out*/ NEXT> {
-    (condition: IIfValueSource<FROM[typeof source], any>): ConnectByExpression<FROM, REQUIRED, NEXT>
-    (condition: IBooleanValueSource<FROM[typeof source], any>): ConnectByExpression<FROM, REQUIRED, NEXT>
+    (condition: IAnyBooleanValueSource<FROM[typeof source], any>): ConnectByExpression<FROM, REQUIRED, NEXT>
 }
 
 export interface ConnectByExpression</*in|out*/ FROM extends HasSource<any>, /*in|out*/ _REQUIRED extends HasSource<any>, NEXT> {
diff --git a/src/expressions/update.ts b/src/expressions/update.ts
index fea7ec3..d56c3ba 100644
--- a/src/expressions/update.ts
+++ b/src/expressions/update.ts
@@ -1,4 +1,4 @@
-import type { AnyValueSource, IBooleanValueSource, IExecutableUpdateQuery, IIfValueSource, RemapIValueSourceType, RemapIValueSourceTypeWithOptionalType, ValueSourceOf, ValueSourceValueType, ValueSourceValueTypeForResult } from "./values"
+import type { AnyValueSource, IExecutableUpdateQuery, IAnyBooleanValueSource, RemapIValueSourceType, RemapIValueSourceTypeWithOptionalType, ValueSourceOf, ValueSourceValueType, ValueSourceValueTypeForResult } from "./values"
 import type { ForUseInLeftJoin, HasSource, IRawFragment, ITable, ITableOrView, OfDB, OfSameDB, ResolvedShape } from "../utils/ITableOrView"
 import type { from, source, using } from "../utils/symbols"
 import type { ColumnsForSetOf, ColumnsForSetOfWithShape, ColumnsKeyOf, OptionalColumnsForSetOf, RequiredColumnsForSetOf, ResolveShape } from "../utils/tableOrViewUtils"
@@ -88,8 +88,7 @@ export interface ExecutableUpdateExpression</*in|out*/ TABLE extends HasSource<a
     disallowAnyOtherSetWhen(when: boolean, error: Error, ...columns: ColumnsForSetOf<TABLE>[]): ExecutableUpdateExpression<TABLE, USING>
 
     dynamicWhere() : DynamicExecutableUpdateExpression<TABLE, USING>
-    where(condition: IIfValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
-    where(condition: IBooleanValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
+    where(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
 }
 
 export interface ShapedExecutableUpdateExpression</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>, /*in|out*/ SHAPE> extends ReturnableExecutableUpdate<TABLE, USING> {
@@ -112,8 +111,7 @@ export interface ShapedExecutableUpdateExpression</*in|out*/ TABLE extends HasSo
     ignoreAnySetWithNoValue(): ShapedExecutableUpdateExpression<TABLE, USING, SHAPE>
 
     dynamicWhere() : DynamicExecutableUpdateExpression<TABLE, USING>
-    where(condition: IIfValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
-    where(condition: IBooleanValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
+    where(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
 }
 
 export interface NotExecutableUpdateExpression</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends UpdateExpressionBase<TABLE, USING> {
@@ -135,8 +133,7 @@ export interface NotExecutableUpdateExpression</*in|out*/ TABLE extends HasSourc
     ignoreAnySetWithNoValue(): NotExecutableUpdateExpression<TABLE, USING>
 
     dynamicWhere() : DynamicExecutableUpdateExpression<TABLE, USING>
-    where(condition: IIfValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
-    where(condition: IBooleanValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
+    where(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
 }
 
 export interface ShapedNotExecutableUpdateExpression</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>, /*in|out*/ SHAPE> extends UpdateExpressionBase<TABLE, USING> {
@@ -159,15 +156,12 @@ export interface ShapedNotExecutableUpdateExpression</*in|out*/ TABLE extends Ha
     ignoreAnySetWithNoValue(): ShapedNotExecutableUpdateExpression<TABLE, USING, SHAPE>
 
     dynamicWhere() : DynamicExecutableUpdateExpression<TABLE, USING>
-    where(condition: IIfValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
-    where(condition: IBooleanValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
+    where(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
 }
 
 export interface DynamicExecutableUpdateExpression</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends ReturnableExecutableUpdate<TABLE, USING> {
-    and(condition: IIfValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
-    and(condition: IBooleanValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
-    or(condition: IIfValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
-    or(condition: IBooleanValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
+    and(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
+    or(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicExecutableUpdateExpression<TABLE, USING>
 }
 
 export interface UpdateSetExpression</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends UpdateExpressionBase<TABLE, USING> {
@@ -305,16 +299,13 @@ export interface UpdateSetJoinExpression</*in|out*/ TABLE extends HasSource<any>
 }
 
 export interface DynamicOnExpression</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends UpdateSetJoinExpression<TABLE, USING> {
-    and(condition: IIfValueSource<USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
-    and(condition: IBooleanValueSource<USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
-    or(condition: IIfValueSource<USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
-    or(condition: IBooleanValueSource<USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
+    and(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
+    or(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
 }
 
 export interface OnExpression</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends UpdateSetJoinExpression<TABLE, USING> {
     dynamicOn(): DynamicOnExpression<TABLE, USING>
-    on(condition: IIfValueSource<USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
-    on(condition: IBooleanValueSource<USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
+    on(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnExpression<TABLE, USING>
 }
 
 export interface UpdateExpressionWithoutJoin</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends UpdateSetExpression<TABLE, USING> {
@@ -352,16 +343,13 @@ export interface UpdateSetJoinExpressionAllowingNoWhere</*in|out*/ TABLE extends
 }
 
 export interface DynamicOnExpressionAllowingNoWhere</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends UpdateSetJoinExpressionAllowingNoWhere<TABLE, USING> {
-    and(condition: IIfValueSource<USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
-    and(condition: IBooleanValueSource<USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
-    or(condition: IIfValueSource<USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
-    or(condition: IBooleanValueSource<USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
+    and(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
+    or(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
 }
 
 export interface OnExpressionAllowingNoWhere</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends UpdateSetJoinExpressionAllowingNoWhere<TABLE, USING> {
     dynamicOn(): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
-    on(condition: IIfValueSource<USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
-    on(condition: IBooleanValueSource<USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
+    on(condition: IAnyBooleanValueSource<USING[typeof source], any>): DynamicOnExpressionAllowingNoWhere<TABLE, USING>
 }
 
 export interface UpdateExpressionWithoutJoinAllowingNoWhere</*in|out*/ TABLE extends HasSource<any>, /*in|out*/ USING extends HasSource<any>> extends UpdateSetExpressionAllowingNoWhere<TABLE, USING> {
diff --git a/src/expressions/values.ts b/src/expressions/values.ts
index 175d9a3..d5143c9 100644
--- a/src/expressions/values.ts
+++ b/src/expressions/values.ts
@@ -186,7 +186,7 @@ export function __getValueSourceOfObject(obj: AnyTableOrView, prop: string): Val
     }
 }
 
-export function __getValueSourcePrivate(valueSource: AnyValueSource | IIfValueSource<any, any>): __ValueSourcePrivate {
+export function __getValueSourcePrivate(valueSource: AnyValueSource | IAnyBooleanValueSource<any, any>): __ValueSourcePrivate {
     return valueSource as any
 }
 
@@ -307,19 +307,22 @@ export interface ComparableValueSource</*in|out*/ SOURCE extends NSource, /*in|o
     ignoreWhenAsNull(when: boolean): ComparableValueSource<SOURCE, TYPE, TYPE_NAME, 'optional'>
 }
 
-export interface IBooleanValueSource</*in|out*/ SOURCE extends NSource, /*in|out*/ OPTIONAL_TYPE extends OptionalType> extends IEqualableValueSource<SOURCE, boolean, 'BooleanValueSource', OPTIONAL_TYPE> {
-    [booleanValueSource]: 'BooleanValueSource'
+export interface IAnyBooleanValueSource</*in|out*/ SOURCE extends NSource, /*in|out*/ OPTIONAL_TYPE extends OptionalType> extends HasSource<SOURCE> {
+    [valueType]: boolean
+    [optionalType]: OPTIONAL_TYPE
     [anyBooleanValueSource]: 'AnyBooleanValueSource'
 }
 
+export interface IBooleanValueSource</*in|out*/ SOURCE extends NSource, /*in|out*/ OPTIONAL_TYPE extends OptionalType> extends IEqualableValueSource<SOURCE, boolean, 'BooleanValueSource', OPTIONAL_TYPE>, IAnyBooleanValueSource<SOURCE, OPTIONAL_TYPE> {
+    [booleanValueSource]: 'BooleanValueSource'
+}
+
 export interface BooleanValueSource</*in|out*/ SOURCE extends NSource, /*in|out*/ OPTIONAL_TYPE extends OptionalType> extends EqualableValueSource<SOURCE, boolean, 'BooleanValueSource', OPTIONAL_TYPE>, IBooleanValueSource<SOURCE, OPTIONAL_TYPE> {
     negate(): BooleanValueSource<SOURCE, OPTIONAL_TYPE>
     and(value: boolean): BooleanValueSource<SOURCE, OPTIONAL_TYPE>
-    and<VALUE extends IIfValueSource<any, any>>(value: VALUE): BooleanValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
-    and<VALUE extends IBooleanValueSource<any, any>>(value: VALUE): BooleanValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
+    and<VALUE extends IAnyBooleanValueSource<any, any>>(value: VALUE): BooleanValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
     or(value: boolean): BooleanValueSource<SOURCE, OPTIONAL_TYPE>
-    or<VALUE extends IIfValueSource<any, any>>(value: VALUE): BooleanValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
-    or<VALUE extends IBooleanValueSource<any, any>>(value: VALUE): BooleanValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
+    or<VALUE extends IAnyBooleanValueSource<any, any>>(value: VALUE): BooleanValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
     onlyWhen(condition: boolean): IIfValueSource<SOURCE, OPTIONAL_TYPE>
     ignoreWhen(condition: boolean): IIfValueSource<SOURCE, OPTIONAL_TYPE>
     // Redefined methods
@@ -333,53 +336,39 @@ export interface BooleanValueSource</*in|out*/ SOURCE extends NSource, /*in|out*
     ignoreWhenAsNull(when: boolean): BooleanValueSource<SOURCE, 'optional'>
 }
 
-export interface IIfValueSource</*in|out*/ SOURCE extends NSource, /*in|out*/ OPTIONAL_TYPE extends OptionalType> {
-    [source]: SOURCE
-    [valueType]: boolean
-    [optionalType]: OPTIONAL_TYPE
+export interface IIfValueSource</*in|out*/ SOURCE extends NSource, /*in|out*/ OPTIONAL_TYPE extends OptionalType> extends IAnyBooleanValueSource<SOURCE, OPTIONAL_TYPE> {
     [ifValueSource]: 'IfValueSource'
-    [anyBooleanValueSource]: 'AnyBooleanValueSource'
 }
 
 export interface IfValueSource</*in|out*/ SOURCE extends NSource, /*in|out*/ OPTIONAL_TYPE extends OptionalType> extends IIfValueSource<SOURCE, OPTIONAL_TYPE> {
     negate(): IIfValueSource<SOURCE, OPTIONAL_TYPE>
     and(value: boolean): BooleanValueSource<SOURCE, OPTIONAL_TYPE>
-    and<VALUE extends IIfValueSource<any, any>>(value: VALUE): IfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
     and<VALUE extends IBooleanValueSource<any, any>>(value: VALUE): BooleanValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
+    and<VALUE extends IAnyBooleanValueSource<any, any>>(value: VALUE): IfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
     or(value: boolean): BooleanValueSource<SOURCE, OPTIONAL_TYPE>
-    or<VALUE extends IIfValueSource<any, any>>(value: VALUE): IfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
     or<VALUE extends IBooleanValueSource<any, any>>(value: VALUE): BooleanValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
+    or<VALUE extends IAnyBooleanValueSource<any, any>>(value: VALUE): IfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
     onlyWhen(condition: boolean): IIfValueSource<SOURCE, OPTIONAL_TYPE>
     ignoreWhen(condition: boolean): IIfValueSource<SOURCE, OPTIONAL_TYPE>
     trueWhenNoValue(): BooleanValueSource<SOURCE, OPTIONAL_TYPE>
     falseWhenNoValue(): BooleanValueSource<SOURCE, OPTIONAL_TYPE>
     valueWhenNoValue(value: boolean): BooleanValueSource<SOURCE, OPTIONAL_TYPE>
-    valueWhenNoValue<VALUE extends IIfValueSource<any, any>>(value: VALUE): IIfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
     valueWhenNoValue<VALUE extends IBooleanValueSource<any, any>>(value: VALUE): BooleanValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
-}
-
-export interface IAnyBooleanValueSource</*in|out*/ SOURCE extends NSource, /*in|out*/ OPTIONAL_TYPE extends OptionalType> {
-    [source]: SOURCE
-    [valueType]: boolean
-    [optionalType]: OPTIONAL_TYPE
-    [anyBooleanValueSource]: 'AnyBooleanValueSource'
+    valueWhenNoValue<VALUE extends IAnyBooleanValueSource<any, any>>(value: VALUE): IIfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
 }
 
 export interface AlwaysIfValueSource</*in|out*/ SOURCE extends NSource, /*in|out*/ OPTIONAL_TYPE extends OptionalType> extends IIfValueSource<SOURCE, OPTIONAL_TYPE> {
     negate(): AlwaysIfValueSource<SOURCE, OPTIONAL_TYPE>
     and(value: boolean): AlwaysIfValueSource<SOURCE, OPTIONAL_TYPE>
-    and<VALUE extends IIfValueSource<any, any>>(value: VALUE): AlwaysIfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
-    and<VALUE extends IBooleanValueSource<any, any>>(value: VALUE): AlwaysIfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
+    and<VALUE extends IAnyBooleanValueSource<any, any>>(value: VALUE): AlwaysIfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
     or(value: boolean): AlwaysIfValueSource<SOURCE, OPTIONAL_TYPE>
-    or<VALUE extends IIfValueSource<any, any>>(value: VALUE): AlwaysIfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
-    or<VALUE extends IBooleanValueSource<any, any>>(value: VALUE): AlwaysIfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
+    or<VALUE extends IAnyBooleanValueSource<any, any>>(value: VALUE): AlwaysIfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
     onlyWhen(condition: boolean): AlwaysIfValueSource<SOURCE, OPTIONAL_TYPE>
     ignoreWhen(condition: boolean): AlwaysIfValueSource<SOURCE, OPTIONAL_TYPE>
     trueWhenNoValue(): AlwaysIfValueSource<SOURCE, OPTIONAL_TYPE>
     falseWhenNoValue(): AlwaysIfValueSource<SOURCE, OPTIONAL_TYPE>
     valueWhenNoValue(value: boolean): AlwaysIfValueSource<SOURCE, OPTIONAL_TYPE>
-    valueWhenNoValue<VALUE extends IIfValueSource<any, any>>(value: VALUE): AlwaysIfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
-    valueWhenNoValue<VALUE extends IBooleanValueSource<any, any>>(value: VALUE): AlwaysIfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
+    valueWhenNoValue<VALUE extends IAnyBooleanValueSource<any, any>>(value: VALUE): AlwaysIfValueSource<SOURCE | VALUE[typeof source], MergeOptional<OPTIONAL_TYPE, VALUE[typeof optionalType]>>
 }
 
 export interface INumberValueSource</*in|out*/ SOURCE extends NSource, /*in|out*/ OPTIONAL_TYPE extends OptionalType> extends IComparableValueSource<SOURCE, number, 'NumberValueSource', OPTIONAL_TYPE> {
diff --git a/src/queryBuilders/DeleteQueryBuilder.ts b/src/queryBuilders/DeleteQueryBuilder.ts
index 7df5104..c88257f 100644
--- a/src/queryBuilders/DeleteQueryBuilder.ts
+++ b/src/queryBuilders/DeleteQueryBuilder.ts
@@ -1,6 +1,6 @@
 import { SqlBuilder, DeleteData, JoinData, ToSql, isAllowedQueryColumns } from "../sqlBuilders/SqlBuilder"
 import { AnyTableOrView, ForUseInLeftJoin, HasAddWiths, HasIsValue, ITable, IWithView, __addWiths, __getTableOrViewPrivate, __isAllowed } from "../utils/ITableOrView"
-import { IBooleanValueSource, IIfValueSource, AnyValueSource, AlwaysIfValueSource, isValueSource } from "../expressions/values"
+import { IAnyBooleanValueSource, AnyValueSource, AlwaysIfValueSource, isValueSource } from "../expressions/values"
 import type { DeleteExpression, ExecutableDelete, DynamicExecutableDeleteExpression, DeleteExpressionAllowingNoWhere, DeleteCustomization, CustomizableExecutableDelete, ComposableCustomizableExecutableDelete, ReturnableExecutableDelete, ExecutableDeleteReturning, DeleteColumns, DeleteWhereExpression, DeleteWhereExpressionAllowingNoWhere, DeleteWhereJoinExpression, DynamicOnExpression, OnExpression, DeleteExpressionWithoutJoin, DeleteUsingExpression, DeleteWhereJoinExpressionAllowingNoWhere, DynamicOnExpressionAllowingNoWhere, OnExpressionAllowingNoWhere, DeleteExpressionWithoutJoinAllowingNoWhere, DeleteUsingExpressionAllowingNoWhere, CustomizableExecutableDeleteProjectableAsNullable } from "../expressions/delete"
 import ChainedError from "chained-error"
 import { attachSource } from "../utils/attachSource"
@@ -217,7 +217,7 @@ export class DeleteQueryBuilder extends AbstractQueryBuilder implements HasAddWi
         this.__query = ''
         return this
     }
-    where(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): this {
+    where(condition: IAnyBooleanValueSource<any, any>): this {
         this.__finishJoin()
         this.__query = ''
         if (this.__where) {
@@ -227,7 +227,7 @@ export class DeleteQueryBuilder extends AbstractQueryBuilder implements HasAddWi
         __getValueSourcePrivate(condition).__addWiths(this.__sqlBuilder, this.__withs)
         return this
     }
-    and(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): this {
+    and(condition: IAnyBooleanValueSource<any, any>): this {
         this.__query = ''
         __getValueSourcePrivate(condition).__addWiths(this.__sqlBuilder, this.__withs)
         if (this.__lastJoin) {
@@ -245,7 +245,7 @@ export class DeleteQueryBuilder extends AbstractQueryBuilder implements HasAddWi
         }
         return this
     }
-    or(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): this {
+    or(condition: IAnyBooleanValueSource<any, any>): this {
         this.__query = ''
         __getValueSourcePrivate(condition).__addWiths(this.__sqlBuilder, this.__withs)
         if (this.__lastJoin) {
@@ -332,7 +332,7 @@ export class DeleteQueryBuilder extends AbstractQueryBuilder implements HasAddWi
         this.__query = ''
         return this
     }
-    on(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): any {
+    on(condition: IAnyBooleanValueSource<any, any>): any {
         this.__query = ''
         if (!this.__lastJoin) {
             throw new Error('Illegal state')
diff --git a/src/queryBuilders/InsertQueryBuilder.ts b/src/queryBuilders/InsertQueryBuilder.ts
index 8bbc125..1d5eb7d 100644
--- a/src/queryBuilders/InsertQueryBuilder.ts
+++ b/src/queryBuilders/InsertQueryBuilder.ts
@@ -6,7 +6,7 @@ import { __getColumnOfObject, __getColumnPrivate } from "../utils/Column"
 import ChainedError from "chained-error"
 import { attachSource } from "../utils/attachSource"
 import { from, resultType, source, type, using } from "../utils/symbols"
-import { AlwaysIfValueSource, AnyValueSource, asAlwaysIfValueSource, IBooleanValueSource, IExecutableSelectQuery, IIfValueSource, IStringValueSource, isValueSource, __getValueSourcePrivate } from "../expressions/values"
+import { AlwaysIfValueSource, AnyValueSource, asAlwaysIfValueSource, IExecutableSelectQuery, IAnyBooleanValueSource, IStringValueSource, isValueSource, __getValueSourcePrivate } from "../expressions/values"
 import { __addWiths } from "../utils/ITableOrView"
 import { AbstractQueryBuilder, __setQueryMetadata } from "./AbstractQueryBuilder"
 import type { RawFragment } from "../utils/RawFragment"
@@ -1804,7 +1804,7 @@ export class InsertQueryBuilder extends AbstractQueryBuilder implements HasAddWi
         this.__query = ''
         return this
     }
-    where(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): this {
+    where(condition: IAnyBooleanValueSource<any, any>): this {
         this.__query = ''
 
         if (this.__onConflictUpdateSets) {
@@ -1826,7 +1826,7 @@ export class InsertQueryBuilder extends AbstractQueryBuilder implements HasAddWi
         }
         return this
     }
-    and(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): this {
+    and(condition: IAnyBooleanValueSource<any, any>): this {
         this.__query = ''
         if (this.__onConflictUpdateSets) {
             if (!this.__onConflictUpdateWhere) {
@@ -1849,7 +1849,7 @@ export class InsertQueryBuilder extends AbstractQueryBuilder implements HasAddWi
         }
         return this
     }
-    or(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): this {
+    or(condition: IAnyBooleanValueSource<any, any>): this {
         this.__query = ''
         if (this.__onConflictUpdateSets) {
             if (!this.__onConflictUpdateWhere) {
diff --git a/src/queryBuilders/SelectQueryBuilder.ts b/src/queryBuilders/SelectQueryBuilder.ts
index 5c357af..f3c6831 100644
--- a/src/queryBuilders/SelectQueryBuilder.ts
+++ b/src/queryBuilders/SelectQueryBuilder.ts
@@ -1,7 +1,7 @@
 import { SqlBuilder, JoinData, ToSql, SelectData, CompoundOperator, CompoundSelectData, PlainSelectData, QueryColumns, isAllowedQueryColumns, OrderByEntry } from "../sqlBuilders/SqlBuilder"
 import type { SelectExpression, SelectColumns, OrderByMode, SelectExpressionSubquery, ExecutableSelectExpressionWithoutWhere, DynamicWhereExecutableSelectExpression, GroupByOrderByExecutableSelectExpression, OffsetExecutableSelectExpression, DynamicWhereExpressionWithoutSelect, /*SelectExpressionFromNoTable,*/ SelectWhereJoinExpression, DynamicOnExpression, OnExpression, SelectExpressionWithoutJoin, SelectWhereExpression, OrderByExecutableSelectExpression, GroupByOrderByHavingExecutableSelectExpression, DynamicHavingExecutableSelectExpression, GroupByOrderHavingByExpressionWithoutSelect, DynamicHavingExpressionWithoutSelect, ICompoundableSelect, CompoundableCustomizableExecutableSelectExpression, CompoundedExecutableSelectExpression, ExecutableSelect, WithableExecutableSelect, SelectCustomization, WhereableExecutableSelectExpressionWithGroupBy, DynamicWhereExecutableSelectExpressionWithGroupBy, GroupByOrderByHavingExecutableSelectExpressionWithoutWhere, DynamicHavingExecutableSelectExpressionWithoutWhere, DynamicWhereSelectExpressionWithoutSelect, CompoundableExecutableSelectExpression, CompoundedOrderByExecutableSelectExpression, CompoundedOffsetExecutableSelectExpression, CompoundedCustomizableExecutableSelect, OrderableExecutableSelectExpressionWithoutWhere, OrderByExecutableSelectExpressionWithoutWhere, OffsetExecutableSelectExpressionWithoutWhere, CompoundableCustomizableExpressionWithoutWhere, DynamicWhereLimitExecutableSelectExpression, DynamicWhereCompoundableCustomizableExecutableSelectExpression, WithableExecutableSelectWithoutWhere, CompoundableExecutableSelectExpressionWithoutWhere, CompoundableCustomizableExecutableSelectExpressionWitoutWhere, WhereableCompoundableExecutableSelectExpressionWithoutWhere, RecursivelyConnectedExecutableSelectExpression, RecursivelyConnectedExpressionWithoutSelect, RecursivelyConnectedExecutableSelectExpressionWithoutWhere, CompoundedLimitExecutableSelectExpression, CompoundedOrderedExecutableSelectExpression, LimitExecutableSelectExpression, OrderedExecutableSelectExpression, LimitExecutableSelectExpressionWithoutWhere, OrderedExecutableSelectExpressionWithoutWhere, RecursivelyConnectedSelectWhereExpression, ConnectByExpression, OrderByExecutableSelectExpressionProjectableAsNullable, GroupByOrderByExecutableSelectExpressionProjectableAsNullable, WhereableExecutableSelectExpressionWithGroupByProjectableAsNullable } from "../expressions/select"
 import { AnyTableOrView, ForUseInLeftJoin, HasAddWiths, HasIsValue, IWithView, __getOldValues, __getValuesForInsert, __isAllowed, __registerRequiredColumn, __registerTableOrView } from "../utils/ITableOrView"
-import { IIfValueSource, IBooleanValueSource, INumberValueSource, IExecutableSelectQuery, AnyValueSource, AlwaysIfValueSource, isValueSource } from "../expressions/values"
+import { IAnyBooleanValueSource, IBooleanValueSource, INumberValueSource, IExecutableSelectQuery, AnyValueSource, AlwaysIfValueSource, isValueSource } from "../expressions/values"
 import { __addWiths, __getTableOrViewPrivate } from "../utils/ITableOrView"
 import { __getValueSourcePrivate } from "../expressions/values"
 import ChainedError from "chained-error"
@@ -862,7 +862,7 @@ export class SelectQueryBuilder extends AbstractSelect implements ToSql, PlainSe
         this.__query = ''
         return this
     }
-    on(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): any {
+    on(condition: IAnyBooleanValueSource<any, any>): any {
         this.__query = ''
         if (!this.__lastJoin) {
             throw new Error('Illegal state')
@@ -883,7 +883,7 @@ export class SelectQueryBuilder extends AbstractSelect implements ToSql, PlainSe
         this.__query = ''
         return this
     }
-    where(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): any {
+    where(condition: IAnyBooleanValueSource<any, any>): any {
         this.__finishJoinHaving()
         this.__query = ''
         if (this.__where) {
@@ -893,7 +893,7 @@ export class SelectQueryBuilder extends AbstractSelect implements ToSql, PlainSe
         __getValueSourcePrivate(condition).__addWiths(this.__sqlBuilder, this.__withs)
         return this
     }
-    and(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): any {
+    and(condition: IAnyBooleanValueSource<any, any>): any {
         this.__query = ''
         __getValueSourcePrivate(condition).__addWiths(this.__sqlBuilder, this.__withs)
         if (this.__lastJoin) {
@@ -919,7 +919,7 @@ export class SelectQueryBuilder extends AbstractSelect implements ToSql, PlainSe
         }
         return this
     }
-    or(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): any {
+    or(condition: IAnyBooleanValueSource<any, any>): any {
         this.__query = ''
         __getValueSourcePrivate(condition).__addWiths(this.__sqlBuilder, this.__withs)
         if (this.__lastJoin) {
@@ -951,7 +951,7 @@ export class SelectQueryBuilder extends AbstractSelect implements ToSql, PlainSe
         this.__inHaving = true
         return this
     }
-    having(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): any {
+    having(condition: IAnyBooleanValueSource<any, any>): any {
         this.__finishJoinHaving()
         this.__query = ''
         this.__inHaving = true
@@ -980,7 +980,7 @@ export class SelectQueryBuilder extends AbstractSelect implements ToSql, PlainSe
         }
         return this
     }
-    startWith(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): any {
+    startWith(condition: IAnyBooleanValueSource<any, any>): any {
         this.__finishJoinHaving()
         this.__query = ''
         if (this.__startWith) {
diff --git a/src/queryBuilders/UpdateQueryBuilder.ts b/src/queryBuilders/UpdateQueryBuilder.ts
index 9478c37..166a1cb 100644
--- a/src/queryBuilders/UpdateQueryBuilder.ts
+++ b/src/queryBuilders/UpdateQueryBuilder.ts
@@ -1,6 +1,6 @@
 import { isAllowedQueryColumns, JoinData, SqlBuilder, ToSql, UpdateData } from "../sqlBuilders/SqlBuilder"
 import { AnyTableOrView, ForUseInLeftJoin, HasAddWiths, HasIsValue, ITable, IWithView, __getTableOrViewPrivate, __isAllowed } from "../utils/ITableOrView"
-import { AlwaysIfValueSource, AnyValueSource, IBooleanValueSource, IIfValueSource, isValueSource } from "../expressions/values"
+import { AlwaysIfValueSource, AnyValueSource, IAnyBooleanValueSource, isValueSource } from "../expressions/values"
 import type { UpdateExpression, ExecutableUpdate, ExecutableUpdateExpression, DynamicExecutableUpdateExpression, UpdateExpressionAllowingNoWhere, NotExecutableUpdateExpression, CustomizableExecutableUpdate, UpdateCustomization, CustomizableExecutableUpdateReturning, ReturnableExecutableUpdate, ExecutableUpdateReturning, UpdateColumns, UpdateSetExpression, UpdateSetExpressionAllowingNoWhere, UpdateSetJoinExpression, DynamicOnExpression, OnExpression, UpdateExpressionWithoutJoin, UpdateFromExpression, UpdateSetJoinExpressionAllowingNoWhere, DynamicOnExpressionAllowingNoWhere, OnExpressionAllowingNoWhere, UpdateExpressionWithoutJoinAllowingNoWhere, UpdateFromExpressionAllowingNoWhere, ShapedUpdateSetExpression, ShapedUpdateSetExpressionAllowingNoWhere, ShapedExecutableUpdateExpression, ShapedNotExecutableUpdateExpression, CustomizableExecutableUpdateProjectableAsNullable } from "../expressions/update"
 import ChainedError from "chained-error"
 import { attachSource } from "../utils/attachSource"
@@ -797,7 +797,7 @@ export class UpdateQueryBuilder extends AbstractQueryBuilder implements HasAddWi
         this.__query = ''
         return this
     }
-    where(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): this {
+    where(condition: IAnyBooleanValueSource<any, any>): this {
         this.__query = ''
         if (this.__where) {
             throw new Error('Illegal state')
@@ -806,7 +806,7 @@ export class UpdateQueryBuilder extends AbstractQueryBuilder implements HasAddWi
         __getValueSourcePrivate(condition).__addWiths(this.__sqlBuilder, this.__withs)
         return this
     }
-    and(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): this {
+    and(condition: IAnyBooleanValueSource<any, any>): this {
         this.__query = ''
         __getValueSourcePrivate(condition).__addWiths(this.__sqlBuilder, this.__withs)
         if (this.__lastJoin) {
@@ -824,7 +824,7 @@ export class UpdateQueryBuilder extends AbstractQueryBuilder implements HasAddWi
         }
         return this
     }
-    or(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): this {
+    or(condition: IAnyBooleanValueSource<any, any>): this {
         this.__query = ''
         __getValueSourcePrivate(condition).__addWiths(this.__sqlBuilder, this.__withs)
         if (this.__lastJoin) {
@@ -911,7 +911,7 @@ export class UpdateQueryBuilder extends AbstractQueryBuilder implements HasAddWi
         this.__query = ''
         return this
     }
-    on(condition: IBooleanValueSource<any, any> | IIfValueSource<any, any>): any {
+    on(condition: IAnyBooleanValueSource<any, any>): any {
         this.__query = ''
         if (!this.__lastJoin) {
             throw new Error('Illegal state')
diff --git a/src/utils/ITableOrView.ts b/src/utils/ITableOrView.ts
index 42428a4..5baa1dc 100644
--- a/src/utils/ITableOrView.ts
+++ b/src/utils/ITableOrView.ts
@@ -6,10 +6,6 @@ export interface HasSource</*in|out*/ SOURCE extends NSource> {
     [source]: SOURCE
 }
 
-export interface AvailableIn</*in|out*/ SOURCE extends NSource> {
-    [source]: SOURCE
-}
-
 export interface OfDB</*in|out*/ DB_TYPE extends NDbType> {
     [source]: NDBWithType<DB_TYPE>
 }