diff --git a/source/and.d.ts b/source/and.d.ts
index b6d94124a..452442a2d 100644
--- a/source/and.d.ts
+++ b/source/and.d.ts
@@ -1,4 +1,6 @@
-import type {IsEqual} from './is-equal.d.ts';
+import type {IsTrue} from './internal/type.d.ts';
+import type {Includes} from './includes.d.ts';
+import type {IsAny} from './is-any.d.ts';
 
 /**
 Returns a boolean for whether two given types are both true.
@@ -14,12 +16,50 @@ And<true, true>;
 
 And<true, false>;
 //=> false
+
+And<true, boolean>;
+//=> never
+
+And<false, boolean>;
+//=> false
+
+```
+
+@see Or, AndAll
+*/
+export type And<A extends boolean, B extends boolean> = AndAll<[A, B]>;
+
+/**
+Returns a boolean for whether All given types are true.
+
+Use-case: Constructing complex conditional types where multiple conditions must be satisfied.
+
+@example
+```
+import type {AndAll} from 'type-fest';
+
+AndAll<[true, true, true]>;
+//=> true
+
+AndAll<[true, false, true]>;
+//=> false
+
+AndAll<[true, boolean, true]>;
+//=> never
+
+AndAll<[false, boolean, true]>;
+//=> false
+
 ```
 
-@see {@link Or}
+@see And, OrAll
 */
-export type And<A extends boolean, B extends boolean> = [A, B][number] extends true
-	? true
-	: true extends [IsEqual<A, false>, IsEqual<B, false>][number]
-		? false
-		: never;
+export type AndAll<T extends boolean[]> = (
+	IsAny<T[number]> extends false
+		? IsTrue<T[number]> extends true
+			? true
+			: Includes<T, false> extends true
+				? false
+				: never
+		: never
+);
diff --git a/source/internal/type.d.ts b/source/internal/type.d.ts
index 85dac83ff..f6b2c149c 100644
--- a/source/internal/type.d.ts
+++ b/source/internal/type.d.ts
@@ -1,7 +1,8 @@
-import type {If} from '../if.d.ts';
-import type {IsAny} from '../is-any.d.ts';
-import type {IsNever} from '../is-never.d.ts';
 import type {Primitive} from '../primitive.d.ts';
+import type {IsNever} from '../is-never.d.ts';
+import type {IsAny} from '../is-any.d.ts';
+import type {Or} from '../or.d.ts';
+import type {If} from '../if.d.ts';
 
 /**
 Matches any primitive, `void`, `Date`, or `RegExp` value.
@@ -13,6 +14,13 @@ Matches non-recursive types.
 */
 export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
 
+/**
+ * Checks if one type extends another. Note: this is not quite the same as `Left extends Right` because:
+ * 1. If either type is `never`, the result is `true` iff the other type is also `never`.
+ * 2. Types are wrapped in a 1-tuple so that union types are not distributed - instead we consider `string | number` to _not_ extend `number`. If we used `Left extends Right` directly you would get `Extends<string | number, number>` => `false | true` => `boolean`.
+ */
+export type Extends<Left, Right> = IsNever<Left> extends true ? IsNever<Right> : [Left] extends [Right] ? true : false;
+
 /**
 Returns a boolean for whether the two given types extends the base type.
 */
@@ -40,9 +48,19 @@ export type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknow
 		: false;
 
 /**
-Returns a boolean for whether the given `boolean` is not `false`.
+Returns a boolean for whether the given `boolean` Union containe's `false`.
 */
-export type IsNotFalse<T extends boolean> = [T] extends [false] ? false : true;
+export type IsNotFalse<T extends boolean> = Not<IsFalse<T>>;
+
+/**
+Returns a boolean for whether the given `boolean` Union members are all `true`.
+*/
+export type IsTrue<T extends boolean> = Extends<T, true>;
+
+/**
+Returns a boolean for whether the given `boolean` Union members are all `false`.
+*/
+export type IsFalse<T extends boolean> = Extends<T, false>;
 
 /**
 Returns a boolean for whether the given type is primitive value or primitive type.
@@ -59,7 +77,7 @@ IsPrimitive<Object>
 //=> false
 ```
 */
-export type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
+export type IsPrimitive<T> = Extends<T, Primitive>;
 
 /**
 Returns a boolean for whether A is false.
@@ -99,3 +117,8 @@ type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
 */
 export type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> =
 	If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAnyOrNever>>;
+
+/**
+Determines if a type is either `never` or `any`.
+*/
+export type IsAnyOrNever<T> = Or<IsAny<T>, IsNever<T>>;
diff --git a/source/or.d.ts b/source/or.d.ts
index 3e393e197..e909673a9 100644
--- a/source/or.d.ts
+++ b/source/or.d.ts
@@ -1,4 +1,6 @@
-import type {IsEqual} from './is-equal.d.ts';
+import type {IsFalse} from './internal/type.d.ts';
+import type {Includes} from './includes.d.ts';
+import type {IsAny} from './is-any.d.ts';
 
 /**
 Returns a boolean for whether either of two given types are true.
@@ -14,12 +16,50 @@ Or<true, false>;
 
 Or<false, false>;
 //=> false
+
+Or<true, boolean>;
+//=> true
+
+Or<false, booelan>;
+//=> never
+
+```
+
+@see And, OrAll
+*/
+export type Or<A extends boolean, B extends boolean> = OrAll<[A, B]>;
+
+/**
+Returns a boolean for whether either of All given types are true.
+
+Use-case: Constructing complex conditional types where multiple conditions must be satisfied.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+OrAll<[true, false, true]>;
+//=> true
+
+OrAll<[false, false, false]>;
+//=> false
+
+OrAll<[true, boolean, true]>;
+//=> true
+
+OrAll<[false, boolean, true]>;
+//=> never
+
 ```
 
-@see {@link And}
+@see Or, AndAll
 */
-export type Or<A extends boolean, B extends boolean> = [A, B][number] extends false
-	? false
-	: true extends [IsEqual<A, true>, IsEqual<B, true>][number]
-		? true
-		: never;
+export type OrAll<T extends boolean[]> = (
+	IsAny<T[number]> extends false
+		? IsFalse<T[number]> extends true
+			? false
+			: Includes<T, true> extends true
+				? true
+				: never
+		: never
+);
diff --git a/test-d/and.ts b/test-d/and.ts
index ea30eb183..6bc67a4aa 100644
--- a/test-d/and.ts
+++ b/test-d/and.ts
@@ -1,8 +1,9 @@
 import {expectType} from 'tsd';
-import type {And} from '../source/and.d.ts';
+import type {And, AndAll} from '../source/and.d.ts';
 
 declare const never: never;
 
+// And
 expectType<And<true, true>>(true);
 expectType<And<true, false>>(false);
 expectType<And<false, true>>(false);
@@ -10,3 +11,43 @@ expectType<And<false, false>>(false);
 expectType<And<true, boolean>>(never);
 expectType<And<false, boolean>>(false);
 expectType<And<boolean, boolean>>(never);
+
+expectType<And<boolean, never>>(never);
+expectType<And<never, boolean>>(never);
+expectType<And<false, never>>(false);
+expectType<And<never, false>>(false);
+expectType<And<never, true>>(true);
+expectType<And<true, never>>(true);
+expectType<And<never, never>>(never);
+
+// AndAll
+expectType<AndAll<[true, true, true]>>(true);
+expectType<AndAll<[false, true, true]>>(false);
+expectType<AndAll<[false, false, true]>>(false);
+expectType<AndAll<[false, false, false]>>(false);
+expectType<AndAll<[true, false, false]>>(false);
+expectType<AndAll<[true, true, false]>>(false);
+
+// @ts-expect-error
+expectType<And>({} as any);
+expectType<AndAll<[]>>(never);
+expectType<And<never, any>>(never);
+expectType<And<any, any>>(never);
+
+// Single value
+expectType<AndAll<[true]>>(true);
+expectType<AndAll<[false]>>(false);
+expectType<AndAll<[boolean]>>(never);
+expectType<AndAll<[never]>>(never);
+expectType<AndAll<[any]>>(never);
+
+// Test if boolean is position dependent
+expectType<AndAll<[boolean, true, true, true]>>(never);
+expectType<AndAll<[true, boolean, true, true]>>(never);
+expectType<AndAll<[true, true, boolean, true]>>(never);
+expectType<AndAll<[true, true, true, boolean]>>(never);
+
+expectType<AndAll<[boolean, false, false, false]>>(false);
+expectType<AndAll<[false, boolean, false, false]>>(false);
+expectType<AndAll<[false, false, boolean, false]>>(false);
+expectType<AndAll<[false, false, false, boolean]>>(false);
diff --git a/test-d/or.ts b/test-d/or.ts
index a7377a592..0bcd335e5 100644
--- a/test-d/or.ts
+++ b/test-d/or.ts
@@ -1,8 +1,9 @@
 import {expectType} from 'tsd';
-import type {Or} from '../source/or.d.ts';
+import type {Or, OrAll} from '../source/or.d.ts';
 
 declare const never: never;
 
+// Or
 expectType<Or<true, true>>(true);
 expectType<Or<true, false>>(true);
 expectType<Or<false, true>>(true);
@@ -10,3 +11,43 @@ expectType<Or<false, false>>(false);
 expectType<Or<true, boolean>>(true);
 expectType<Or<false, boolean>>(never);
 expectType<Or<boolean, boolean>>(never);
+
+expectType<Or<boolean, never>>(never);
+expectType<Or<never, boolean>>(never);
+expectType<Or<false, never>>(false);
+expectType<Or<never, false>>(false);
+expectType<Or<never, true>>(true);
+expectType<Or<true, never>>(true);
+expectType<Or<never, never>>(never);
+
+// OrAll
+expectType<OrAll<[true, true, true]>>(true);
+expectType<OrAll<[false, true, true]>>(true);
+expectType<OrAll<[false, false, true]>>(true);
+expectType<OrAll<[false, false, false]>>(false);
+expectType<OrAll<[true, false, false]>>(true);
+expectType<OrAll<[true, true, false]>>(true);
+
+// @ts-expect-error
+expectType<Or>({} as any);
+expectType<OrAll<[]>>(never);
+expectType<Or<never, any>>(never);
+expectType<Or<any, any>>(never);
+
+// Single value
+expectType<OrAll<[true]>>(true);
+expectType<OrAll<[false]>>(false);
+expectType<OrAll<[boolean]>>(never);
+expectType<OrAll<[never]>>(never);
+expectType<OrAll<[any]>>(never);
+
+// Test if boolean is position dependent
+expectType<OrAll<[boolean, true, true, true]>>(true);
+expectType<OrAll<[true, boolean, true, true]>>(true);
+expectType<OrAll<[true, true, boolean, true]>>(true);
+expectType<OrAll<[true, true, true, boolean]>>(true);
+
+expectType<OrAll<[boolean, false, false, false]>>(never);
+expectType<OrAll<[false, boolean, false, false]>>(never);
+expectType<OrAll<[false, false, boolean, false]>>(never);
+expectType<OrAll<[false, false, false, boolean]>>(never);