@react-querybuilder/bootstrap 8.9.2 → 8.11.0

package/dist/cjs/react-querybuilder_bootstrap.cjs.development.d.ts

@@ -1,408 +1,481 @@
 import * as React from "react";
 import { ComponentType, ForwardRefExoticComponent, MouseEvent, ReactNode, Ref, RefAttributes } from "react";
 
-//#region ../core/src/types/type-fest/is-equal.d.ts
+//#region ../../node_modules/type-fest/source/union-to-intersection.d.ts
 
 /**
-Returns a boolean for whether the two given types are equal.
+Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
 
-@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
-@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
 
-Use-cases:
-- If you want to make a conditional branch based on the result of a comparison of two types.
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void; great(arg: string): void; escape: boolean};
+```
+
+A more applicable example which could make its way into your library code follows.
 
 @example
 ```
-import type {IsEqual} from 'type-fest';
+import type {UnionToIntersection} from 'type-fest';
 
-// This type returns a boolean for whether the given array includes the given item.
-// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
-type Includes<Value extends readonly any[], Item> =
-Value extends readonly [Value[0], ...infer rest]
-? IsEqual<Value[0], Item> extends true
-? true
-: Includes<rest, Item>
-: false;
+class CommandOne {
+	commands: {
+		a1: () => undefined,
+		b1: () => undefined,
+	}
+}
+
+class CommandTwo {
+	commands: {
+		a2: (argA: string) => undefined,
+		b2: (argB: string) => undefined,
+	}
+}
+
+const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
+type Union = typeof union;
+//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
+
+type Intersection = UnionToIntersection<Union>;
+//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
 ```
 
-@group type-fest
-*/
-type IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
+@category Type
+*/
+type UnionToIntersection<Union> = (
+// `extends unknown` is always going to be the case and is used to convert the
+// `Union` into a [distributive conditional
+// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+Union extends unknown
+// The union type is used as the only argument to a function since the union
+// of function arguments is an intersection.
+? (distributedUnion: Union) => void
+// This won't happen.
+: never
+// Infer the `Intersection` type since TypeScript represents the positional
+// arguments of unions of functions as an intersection of the union.
+) extends ((mergedIntersection: infer Intersection) => void)
+// The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
+? Intersection & Union : never;
 //#endregion
-//#region ../core/src/types/type-fest/is-never.d.ts
+//#region ../../node_modules/type-fest/source/keys-of-union.d.ts
 /**
-Returns a boolean for whether the given type is `never`.
+Create a union of all keys from a given type, even those exclusive to specific union members.
 
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
+Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
 
-Useful in type utilities, such as checking if something does not occur.
+@link https://stackoverflow.com/a/49402091
 
 @example
 ```
-import type {IsNever, And} from 'type-fest';
+import type {KeysOfUnion} from 'type-fest';
 
-// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
-type AreStringsEqual<A extends string, B extends string> =
-And<
-IsNever<Exclude<A, B>> extends true ? true : false,
-IsNever<Exclude<B, A>> extends true ? true : false
->;
+type A = {
+	common: string;
+	a: number;
+};
 
-type EndIfEqual<I extends string, O extends string> =
-AreStringsEqual<I, O> extends true
-? never
-: void;
+type B = {
+	common: string;
+	b: string;
+};
 
-function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-if (input === output) {
-process.exit(0);
-}
-}
+type C = {
+	common: string;
+	c: boolean;
+};
 
-endIfEqual('abc', 'abc');
-//=> never
+type Union = A | B | C;
 
-endIfEqual('abc', '123');
-//=> void
+type CommonKeys = keyof Union;
+//=> 'common'
+
+type AllKeys = KeysOfUnion<Union>;
+//=> 'common' | 'a' | 'b' | 'c'
 ```
 
-@group type-fest
+@category Object
 */
-type IsNever<T> = [T] extends [never] ? true : false;
+type KeysOfUnion<ObjectType> =
+// Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
 //#endregion
-//#region ../core/src/types/type-fest/if-never.d.ts
+//#region ../../node_modules/type-fest/source/is-any.d.ts
 /**
-An if-else-like type that resolves depending on whether the given type is `never`.
+Returns a boolean for whether the given type is `any`.
 
-@see {@link IsNever}
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
 
 @example
 ```
-import type {IfNever} from 'type-fest';
+import type {IsAny} from 'type-fest';
 
-type ShouldBeTrue = IfNever<never>;
-//=> true
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
 
-type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
-//=> 'bar'
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
+	return obj[key];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
 ```
 
-@group type-fest
+@category Type Guard
+@category Utilities
 */
-type IfNever$1<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
+type IsAny<T$1> = 0 extends 1 & NoInfer<T$1> ? true : false;
 //#endregion
-//#region ../core/src/types/type-fest/unknown-array.d.ts
+//#region ../../node_modules/type-fest/source/is-optional-key-of.d.ts
 /**
-Represents an array with `unknown` value.
+Returns a boolean for whether the given key is an optional key of type.
 
-Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
+This is useful when writing utility types or schema validators that need to differentiate `optional` keys.
 
 @example
 ```
-import type {UnknownArray} from 'type-fest';
+import type {IsOptionalKeyOf} from 'type-fest';
 
-type IsArray<T> = T extends UnknownArray ? true : false;
+interface User {
+	name: string;
+	surname: string;
 
-type A = IsArray<['foo']>;
-//=> true
+	luckyNumber?: number;
+}
 
-type B = IsArray<readonly number[]>;
+interface Admin {
+	name: string;
+	surname?: string;
+}
+
+type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
 //=> true
 
-type C = IsArray<string>;
+type T2 = IsOptionalKeyOf<User, 'name'>;
 //=> false
-```
 
-@group type-fest
-*/
-type UnknownArray = readonly unknown[];
-//#endregion
-//#region ../core/src/types/type-fest/internal/array.d.ts
+type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
+//=> boolean
 
-/**
-Returns whether the given array `T` is readonly.
+type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
+//=> false
+
+type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
+//=> boolean
+```
 
-@group type-fest
+@category Type Guard
+@category Utilities
 */
-type IsArrayReadonly<T extends UnknownArray> = IfNever$1<T, false, T extends unknown[] ? false : true>;
+type IsOptionalKeyOf<Type extends object, Key$1 extends keyof Type> = IsAny<Type | Key$1> extends true ? never : Key$1 extends keyof Type ? Type extends Record<Key$1, Type[Key$1]> ? false : true : false;
+//#endregion
+//#region ../../node_modules/type-fest/source/optional-keys-of.d.ts
 /**
-An if-else-like type that resolves depending on whether the given array is readonly.
+Extract all optional keys from the given type.
 
-@see {@link IsArrayReadonly}
+This is useful when you want to create a new type that contains different type values for the optional keys only.
 
 @example
 ```
-import type {ArrayTail} from 'type-fest';
+import type {OptionalKeysOf, Except} from 'type-fest';
 
-type ReadonlyPreservingArrayTail<TArray extends readonly unknown[]> =
-ArrayTail<TArray> extends infer Tail
-? IfArrayReadonly<TArray, Readonly<Tail>, Tail>
-: never;
+interface User {
+	name: string;
+	surname: string;
 
-type ReadonlyTail = ReadonlyPreservingArrayTail<readonly [string, number, boolean]>;
-//=> readonly [number, boolean]
+	luckyNumber?: number;
+}
 
-type NonReadonlyTail = ReadonlyPreservingArrayTail<[string, number, boolean]>;
-//=> [number, boolean]
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
 
-type ShouldBeTrue = IfArrayReadonly<readonly unknown[]>;
-//=> true
+const update1: UpdateOperation<User> = {
+	name: 'Alice'
+};
 
-type ShouldBeBar = IfArrayReadonly<unknown[], 'foo', 'bar'>;
-//=> 'bar'
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD
+};
 ```
 
-@group type-fest
+@category Utilities
 */
-type IfArrayReadonly<T extends UnknownArray, TypeIfArrayReadonly = true, TypeIfNotArrayReadonly = false> = IsArrayReadonly<T> extends infer Result ? Result extends true ? TypeIfArrayReadonly : TypeIfNotArrayReadonly : never;
+type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
+: never;
 //#endregion
-//#region ../core/src/types/type-fest/is-any.d.ts
-type NoInfer<T> = T extends infer U ? U : never;
+//#region ../../node_modules/type-fest/source/required-keys-of.d.ts
 /**
-Returns a boolean for whether the given type is `any`.
-
-@link https://stackoverflow.com/a/49928360/1490091
+Extract all required keys from the given type.
 
-Useful in type utilities, such as disallowing `any`s to be passed to a function.
+This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
 
 @example
 ```
-import type {IsAny} from 'type-fest';
+import type {RequiredKeysOf} from 'type-fest';
 
-const typedObject = {a: 1, b: 2} as const;
-const anyObject: any = {a: 1, b: 2};
+declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
 
-function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
-return obj[key];
-}
+interface User {
+	name: string;
+	surname: string;
 
-const typedA = get(typedObject, 'a');
-//=> 1
+	luckyNumber?: number;
+}
 
-const anyA = get(anyObject, 'a');
-//=> any
+const validator1 = createValidation<User>('name', value => value.length < 25);
+const validator2 = createValidation<User>('surname', value => value.length < 25);
 ```
 
-@group type-fest
+@category Utilities
 */
-type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
 //#endregion
-//#region ../core/src/types/type-fest/simplify.d.ts
+//#region ../../node_modules/type-fest/source/is-never.d.ts
 /**
-Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
 
 @example
 ```
-import type {Simplify} from 'type-fest';
+import type {IsNever, And} from 'type-fest';
 
-type PositionProps = {
-top: number;
-left: number;
-};
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
 
-type SizeProps = {
-width: number;
-height: number;
-};
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
 
-// In your editor, hovering over `Props` will show a flattened object with all the properties.
-type Props = Simplify<PositionProps & SizeProps>;
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
 ```
 
-Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T$1> = [T$1] extends [never] ? true : false;
+//#endregion
+//#region ../../node_modules/type-fest/source/if.d.ts
+/**
+An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
 
-If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+Use-cases:
+- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.
+
+Note:
+- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.
+- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.
 
 @example
 ```
-import type {Simplify} from 'type-fest';
+import {If} from 'type-fest';
 
-interface SomeInterface {
-foo: number;
-bar?: string;
-baz: number | undefined;
-}
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
 
-type SomeType = {
-foo: number;
-bar?: string;
-baz: number | undefined;
-};
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
 
-const literal = {foo: 123, bar: 'hello', baz: 456};
-const someType: SomeType = literal;
-const someInterface: SomeInterface = literal;
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
 
-function fn(object: Record<string, unknown>): void {}
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
 
-fn(literal); // Good: literal object type is sealed
-fn(someType); // Good: type is sealed
-fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
-fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
 ```
 
-@link https://github.com/microsoft/TypeScript/issues/15300
-@see SimplifyDeep
+@example
+```
+import {If, IsAny, IsNever} from 'type-fest';
 
-@group type-fest
-*/
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
-//#endregion
-//#region ../core/src/types/type-fest/union-to-intersection.d.ts
-/**
-Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
 
-Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
 
 @example
 ```
-import type {UnionToIntersection} from 'type-fest';
+import {If, IsEqual} from 'type-fest';
 
-type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
 
-type Intersection = UnionToIntersection<Union>;
-//=> {the(): void; great(arg: string): void; escape: boolean};
+type A = IfEqual<string, string, 'equal', 'not equal'>;
+//=> 'equal'
+
+type B = IfEqual<string, number, 'equal', 'not equal'>;
+//=> 'not equal'
 ```
 
-A more applicable example which could make its way into your library code follows.
+@category Type Guard
+@category Utilities
+*/
+type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
+//#endregion
+//#region ../../node_modules/type-fest/source/unknown-array.d.ts
+/**
+Represents an array with `unknown` value.
+
+Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
 
 @example
 ```
-import type {UnionToIntersection} from 'type-fest';
+import type {UnknownArray} from 'type-fest';
 
-class CommandOne {
-commands: {
-a1: () => undefined,
-b1: () => undefined,
-}
-}
+type IsArray<T> = T extends UnknownArray ? true : false;
 
-class CommandTwo {
-commands: {
-a2: (argA: string) => undefined,
-b2: (argB: string) => undefined,
-}
-}
+type A = IsArray<['foo']>;
+//=> true
 
-const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
-type Union = typeof union;
-//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
+type B = IsArray<readonly number[]>;
+//=> true
 
-type Intersection = UnionToIntersection<Union>;
-//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
+type C = IsArray<string>;
+//=> false
 ```
 
-@group type-fest
+@category Type
+@category Array
 */
-type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection & Union : never;
+type UnknownArray = readonly unknown[];
 //#endregion
-//#region ../core/src/types/type-fest/keys-of-union.d.ts
-/**
-Create a union of all keys from a given type, even those exclusive to specific union members.
-
-Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
+//#region ../../node_modules/type-fest/source/internal/array.d.ts
 
-@link https://stackoverflow.com/a/49402091
+/**
+Returns whether the given array `T` is readonly.
+*/
+type IsArrayReadonly<T$1 extends UnknownArray> = If<IsNever<T$1>, false, T$1 extends unknown[] ? false : true>;
+//#endregion
+//#region ../../node_modules/type-fest/source/simplify.d.ts
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
 
 @example
 ```
-import type {KeysOfUnion} from 'type-fest';
-
-type A = {
-common: string;
-a: number;
-};
+import type {Simplify} from 'type-fest';
 
-type B = {
-common: string;
-b: string;
+type PositionProps = {
+	top: number;
+	left: number;
 };
 
-type C = {
-common: string;
-c: boolean;
+type SizeProps = {
+	width: number;
+	height: number;
 };
 
-type Union = A | B | C;
-
-type CommonKeys = keyof Union;
-//=> 'common'
-
-type AllKeys = KeysOfUnion<Union>;
-//=> 'common' | 'a' | 'b' | 'c'
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
 ```
 
-@group type-fest
-*/
-type KeysOfUnion<ObjectType> = keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
-//#endregion
-//#region ../core/src/types/type-fest/optional-keys-of.d.ts
-/**
-Extract all optional keys from the given type.
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
 
-This is useful when you want to create a new type that contains different type values for the optional keys only.
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
 
 @example
 ```
-import type {OptionalKeysOf, Except} from 'type-fest';
-
-interface User {
-name: string;
-surname: string;
+import type {Simplify} from 'type-fest';
 
-luckyNumber?: number;
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
 }
 
-const REMOVE_FIELD = Symbol('remove field symbol');
-type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
-[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
 };
 
-const update1: UpdateOperation<User> = {
-name: 'Alice'
-};
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+function fn(object: Record<string, unknown>): void {}
 
-const update2: UpdateOperation<User> = {
-name: 'Bob',
-luckyNumber: REMOVE_FIELD
-};
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
 ```
 
-@group type-fest
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see SimplifyDeep
+@category Object
 */
-type OptionalKeysOf<BaseType extends object> = BaseType extends unknown ? (keyof { [Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never }) & (keyof BaseType) : never;
+type Simplify<T$1> = { [KeyType in keyof T$1]: T$1[KeyType] } & {};
 //#endregion
-//#region ../core/src/types/type-fest/required-keys-of.d.ts
+//#region ../../node_modules/type-fest/source/is-equal.d.ts
 /**
-Extract all required keys from the given type.
+Returns a boolean for whether the two given types are equal.
 
-This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
 
 @example
 ```
-import type {RequiredKeysOf} from 'type-fest';
-
-declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
-
-interface User {
-name: string;
-surname: string;
-
-luckyNumber?: number;
-}
+import type {IsEqual} from 'type-fest';
 
-const validator1 = createValidation<User>('name', value => value.length < 25);
-const validator2 = createValidation<User>('surname', value => value.length < 25);
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
 ```
 
-@group type-fest
+@category Type Guard
+@category Utilities
 */
-type RequiredKeysOf<BaseType extends object> = BaseType extends unknown ? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never;
+type IsEqual<A, B> = [A, B] extends [infer AA, infer BB] ? [AA] extends [never] ? [BB] extends [never] ? true : false : [BB] extends [never] ? false : _IsEqual<AA, BB> : false;
+// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
+type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
 //#endregion
-//#region ../core/src/types/type-fest/omit-index-signature.d.ts
+//#region ../../node_modules/type-fest/source/omit-index-signature.d.ts
 /**
 Omit any index signatures from the given object type, leaving only explicitly defined properties.
 
@@ -428,13 +501,13 @@ Instead of causing a type error like the above, you can also use a [conditional
 
 ```
 type Indexed = {} extends Record<string, unknown>
-? '✅ `{}` is assignable to `Record<string, unknown>`'
-: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
 // => '✅ `{}` is assignable to `Record<string, unknown>`'
 
 type Keyed = {} extends Record<'foo' | 'bar', unknown>
-? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
-: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
+	? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
+	: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
 // => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
 ```
 
@@ -444,8 +517,8 @@ Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-type
 import type {OmitIndexSignature} from 'type-fest';
 
 type OmitIndexSignature<ObjectType> = {
-[KeyType in keyof ObjectType // Map each key of `ObjectType`...
-]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
 };
 ```
 
@@ -455,12 +528,12 @@ type OmitIndexSignature<ObjectType> = {
 import type {OmitIndexSignature} from 'type-fest';
 
 type OmitIndexSignature<ObjectType> = {
-[KeyType in keyof ObjectType
-// Is `{}` assignable to `Record<KeyType, unknown>`?
-as {} extends Record<KeyType, unknown>
-? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
-: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
-]: ObjectType[KeyType];
+	[KeyType in keyof ObjectType
+		// Is `{}` assignable to `Record<KeyType, unknown>`?
+		as {} extends Record<KeyType, unknown>
+			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
 };
 ```
 
@@ -471,19 +544,19 @@ If `{}` is assignable, it means that `KeyType` is an index signature and we want
 import type {OmitIndexSignature} from 'type-fest';
 
 interface Example {
-// These index signatures will be removed.
-[x: string]: any
-[x: number]: any
-[x: symbol]: any
-[x: `head-${string}`]: string
-[x: `${string}-tail`]: string
-[x: `head-${string}-tail`]: string
-[x: `${bigint}`]: string
-[x: `embedded-${number}`]: string
-
-// These explicitly defined keys will remain.
-foo: 'bar';
-qux?: 'baz';
+	// These index signatures will be removed.
+	[x: string]: any
+	[x: number]: any
+	[x: symbol]: any
+	[x: `head-${string}`]: string
+	[x: `${string}-tail`]: string
+	[x: `head-${string}-tail`]: string
+	[x: `${bigint}`]: string
+	[x: `embedded-${number}`]: string
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
 }
 
 type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
@@ -491,12 +564,11 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 ```
 
 @see PickIndexSignature
-
-@group type-fest
+@category Object
 */
 type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
 //#endregion
-//#region ../core/src/types/type-fest/pick-index-signature.d.ts
+//#region ../../node_modules/type-fest/source/pick-index-signature.d.ts
 /**
 Pick only index signatures from the given object type, leaving out all explicitly defined properties.
 
@@ -509,21 +581,21 @@ import type {PickIndexSignature} from 'type-fest';
 declare const symbolKey: unique symbol;
 
 type Example = {
-// These index signatures will remain.
-[x: string]: unknown;
-[x: number]: unknown;
-[x: symbol]: unknown;
-[x: `head-${string}`]: string;
-[x: `${string}-tail`]: string;
-[x: `head-${string}-tail`]: string;
-[x: `${bigint}`]: string;
-[x: `embedded-${number}`]: string;
-
-// These explicitly defined keys will be removed.
-['kebab-case-key']: string;
-[symbolKey]: string;
-foo: 'bar';
-qux?: 'baz';
+	// These index signatures will remain.
+	[x: string]: unknown;
+	[x: number]: unknown;
+	[x: symbol]: unknown;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will be removed.
+	['kebab-case-key']: string;
+	[symbolKey]: string;
+	foo: 'bar';
+	qux?: 'baz';
 };
 
 type ExampleIndexSignature = PickIndexSignature<Example>;
@@ -540,13 +612,14 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 ```
 
 @see OmitIndexSignature
-
-@group type-fest
+@category Object
 */
 type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
 //#endregion
-//#region ../core/src/types/type-fest/merge.d.ts
+//#region ../../node_modules/type-fest/source/merge.d.ts
+// Merges two objects without worrying about index signatures.
 type SimpleMerge<Destination, Source> = { [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source;
+
 /**
 Merge two types into a new type. Keys of the second type overrides keys of the first type.
 
@@ -555,17 +628,17 @@ Merge two types into a new type. Keys of the second type overrides keys of the f
 import type {Merge} from 'type-fest';
 
 interface Foo {
-[x: string]: unknown;
-[x: number]: unknown;
-foo: string;
-bar: symbol;
+	[x: string]: unknown;
+	[x: number]: unknown;
+	foo: string;
+	bar: symbol;
 }
 
 type Bar = {
-[x: number]: number;
-[x: symbol]: unknown;
-bar: Date;
-baz: boolean;
+	[x: number]: number;
+	[x: symbol]: unknown;
+	bar: Date;
+	baz: boolean;
 };
 
 export type FooBar = Merge<Foo, Bar>;
@@ -579,55 +652,11 @@ export type FooBar = Merge<Foo, Bar>;
 // }
 ```
 
-@group type-fest
+@category Object
 */
 type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 //#endregion
-//#region ../core/src/types/type-fest/if-any.d.ts
-/**
-An if-else-like type that resolves depending on whether the given type is `any`.
-
-@see {@link IsAny}
-
-@example
-```
-import type {IfAny} from 'type-fest';
-
-type ShouldBeTrue = IfAny<any>;
-//=> true
-
-type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@group type-fest
-*/
-type IfAny$1<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny<T> extends true ? TypeIfAny : TypeIfNotAny);
-//#endregion
-//#region ../core/src/types/type-fest/internal/type.d.ts
-/**
-An if-else-like type that resolves depending on whether the given type is `any` or `never`.
-
-@example
-```
-// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
-type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
-//=> 'VALID'
-
-// When `T` is `any` => Returns `IfAny` branch
-type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
-//=> 'IS_ANY'
-
-// When `T` is `never` => Returns `IfNever` branch
-type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
-//=> 'IS_NEVER'
-```
-
-@group type-fest
-*/
-type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> = IsAny<T> extends true ? IfAny : IsNever<T> extends true ? IfNever : IfNotAnyOrNever;
-//#endregion
-//#region ../core/src/types/type-fest/internal/object.d.ts
+//#region ../../node_modules/type-fest/source/internal/object.d.ts
 /**
 Works similar to the built-in `Pick` utility type, except for the following differences:
 - Distributes over union types and allows picking keys from any member of the union type.
@@ -638,15 +667,15 @@ Works similar to the built-in `Pick` utility type, except for the following diff
 @example
 ```
 type ImageUpload = {
-url: string;
-size: number;
-thumbnailUrl: string;
+	url: string;
+	size: number;
+	thumbnailUrl: string;
 };
 
 type VideoUpload = {
-url: string;
-duration: number;
-encodingFormat: string;
+	url: string;
+	duration: number;
+	encodingFormat: string;
 };
 
 // Distributes over union types and allows picking keys from any member of the union type
@@ -664,10 +693,8 @@ type Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;
 // Doesn't pick `number` from a `string` index signature
 type IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;
 //=> {}
-
-@group type-fest
 */
-type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = { [P in keyof T as Extract<P, Keys>]: T[P] };
+type HomomorphicPick<T$1, Keys extends KeysOfUnion<T$1>> = { [P in keyof T$1 as Extract<P, Keys>]: T$1[P] };
 /**
 Merges user specified options with default options.
 
@@ -719,12 +746,10 @@ type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOp
 //                                                                   ~~~~~~~~~~~~~~~~
 // Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
 ```
-
-@group type-fest
 */
-type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = IfAny$1<SpecifiedOptions, Defaults, IfNever$1<SpecifiedOptions, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? Extract<SpecifiedOptions[Key], undefined> extends never ? Key : never : Key]: SpecifiedOptions[Key] }> & Required<Options>>>>;
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key]: SpecifiedOptions[Key] }> & Required<Options>>>>;
 //#endregion
-//#region ../core/src/types/type-fest/except.d.ts
+//#region ../../node_modules/type-fest/source/except.d.ts
 /**
 Filter out keys from an object.
 
@@ -752,20 +777,19 @@ type Filtered = Filter<'bar', 'foo'>;
 
 @see {Except}
 */
-type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+type Filter<KeyType$1, ExcludeType> = IsEqual<KeyType$1, ExcludeType> extends true ? never : (KeyType$1 extends ExcludeType ? never : KeyType$1);
 type ExceptOptions = {
   /**
   Disallow assigning non-specified properties.
-  
-  Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
-  
-  @default false
+  	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+  	@default false
   */
   requireExactProps?: boolean;
 };
 type DefaultExceptOptions = {
   requireExactProps: false;
 };
+
 /**
 Create a type from an object type without certain keys.
 
@@ -780,8 +804,8 @@ This type was proposed to the TypeScript team, which declined it, saying they pr
 import type {Except} from 'type-fest';
 
 type Foo = {
-a: number;
-b: string;
+	a: number;
+	b: string;
 };
 
 type FooWithoutA = Except<Foo, 'a'>;
@@ -801,10 +825,10 @@ const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
 // Consider the following example:
 
 type UserData = {
-[metadata: string]: string;
-email: string;
-name: string;
-role: 'admin' | 'user';
+	[metadata: string]: string;
+	email: string;
+	name: string;
+	role: 'admin' | 'user';
 };
 
 // `Omit` clearly doesn't behave as expected in this case:
@@ -817,37 +841,64 @@ type PostPayload = Except<UserData, 'email'>;
 //=> type PostPayload = { [x: string]: string; name: string; role: 'admin' | 'user'; }
 ```
 
-@group type-fest
+@category Object
 */
 type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = _Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
-type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options["requireExactProps"] extends true ? Partial<Record<KeysType, never>> : {});
+type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
 //#endregion
-//#region ../core/src/types/type-fest/require-at-least-one.d.ts
+//#region ../../node_modules/type-fest/source/set-required.d.ts
 /**
-Create a type that requires at least one of the given keys. The remaining keys are kept as is.
+Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
 
 @example
 ```
-import type {RequireAtLeastOne} from 'type-fest';
+import type {SetRequired} from 'type-fest';
 
-type Responder = {
-text?: () => string;
-json?: () => string;
-secure?: boolean;
-};
+type Foo = {
+	a?: number;
+	b: string;
+	c?: boolean;
+}
 
-const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
-json: () => '{"message": "ok"}',
-secure: true
-};
+type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
+// type SomeRequired = {
+// 	a?: number;
+// 	b: string; // Was already required and still is.
+// 	c: boolean; // Is now required.
+// }
+
+// Set specific indices in an array to be required.
+type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;
+//=> [number, number, number?]
 ```
 
-@group type-fest
+@category Object
+*/
+type SetRequired<BaseType, Keys extends keyof BaseType> = (BaseType extends ((...arguments_: never) => any) ? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType> : unknown) & _SetRequired<BaseType, Keys>;
+type _SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? If<IsArrayReadonly<BaseType>, Readonly<ResultantArray>, ResultantArray> : never : Simplify<
+// Pick just the keys that are optional from the base type.
+Except<BaseType, Keys> &
+// Pick the keys that should be required from the base type and make them required.
+Required<HomomorphicPick<BaseType, Keys>>>;
+
+/**
+Remove the optional modifier from the specified keys in an array.
 */
-type RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, IfNever$1<KeysType, never, _RequireAtLeastOne<ObjectType, IfAny$1<KeysType, keyof ObjectType, KeysType>>>>;
-type _RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType> = { [Key in KeysType]-?: Required<Pick<ObjectType, Key>> & Partial<Pick<ObjectType, Exclude<KeysType, Key>>> }[KeysType] & Except<ObjectType, KeysType>;
+type SetArrayRequired<TArray extends UnknownArray, Keys, Counter extends any[] = [], Accumulator extends UnknownArray = []> = TArray extends unknown // For distributing `TArray` when it's a union
+? keyof TArray & `${number}` extends never
+// Exit if `TArray` is empty (e.g., []), or
+// `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+? [...Accumulator, ...TArray] : TArray extends readonly [(infer First)?, ...infer Rest] ? '0' extends OptionalKeysOf<TArray> // If the first element of `TArray` is optional
+? `${Counter['length']}` extends `${Keys & (string | number)}` // If the current index needs to be required
+? SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, First]>
+// If the current element is optional, but it doesn't need to be required,
+// then we can exit early, since no further elements can now be made required.
+: [...Accumulator, ...TArray] : SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, TArray[0]]> : never // Should never happen, since `[(infer F)?, ...infer R]` is a top-type for arrays.
+: never; // Should never happen
 //#endregion
-//#region ../core/src/types/type-fest/set-non-nullable.d.ts
+//#region ../../node_modules/type-fest/source/set-non-nullable.d.ts
 /**
 Create a type that makes the given keys non-nullable, where the remaining keys are kept as is.
 
@@ -860,9 +911,9 @@ Use-case: You want to define a single model where the only thing that changes is
 import type {SetNonNullable} from 'type-fest';
 
 type Foo = {
-a: number | null;
-b: string | undefined;
-c?: boolean | null;
+	a: number | null;
+	b: string | undefined;
+	c?: boolean | null;
 }
 
 type SomeNonNullable = SetNonNullable<Foo, 'b' | 'c'>;
@@ -880,47 +931,12 @@ type AllNonNullable = SetNonNullable<Foo>;
 // }
 ```
 
-@group type-fest
+@category Object
 */
 type SetNonNullable<BaseType, Keys extends keyof BaseType = keyof BaseType> = { [Key in keyof BaseType]: Key extends Keys ? NonNullable<BaseType[Key]> : BaseType[Key] };
 //#endregion
-//#region ../core/src/types/type-fest/set-required.d.ts
-/**
-Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
-
-Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
-
-@example
-```
-import type {SetRequired} from 'type-fest';
-
-type Foo = {
-a?: number;
-b: string;
-c?: boolean;
-}
-
-type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
-// type SomeRequired = {
-// 	a?: number;
-// 	b: string; // Was already required and still is.
-// 	c: boolean; // Is now required.
-// }
-
-// Set specific indices in an array to be required.
-type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;
-//=> [number, number, number?]
-```
-
-@group type-fest
-*/
-type SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? IfArrayReadonly<BaseType, Readonly<ResultantArray>, ResultantArray> : never : Simplify<Except<BaseType, Keys> & Required<HomomorphicPick<BaseType, Keys>>>;
-/**
-Remove the optional modifier from the specified keys in an array.
-*/
-type SetArrayRequired<TArray extends UnknownArray, Keys, Counter extends any[] = [], Accumulator extends UnknownArray = []> = TArray extends unknown ? keyof TArray & `${number}` extends never ? [...Accumulator, ...TArray] : TArray extends readonly [(infer First)?, ...infer Rest] ? "0" extends OptionalKeysOf<TArray> ? `${Counter["length"]}` extends `${Keys & (string | number)}` ? SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, First]> : [...Accumulator, ...TArray] : SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, TArray[0]]> : never : never;
-//#endregion
 //#region ../core/src/types/options.d.ts
+type RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType> = { [Key in KeysType]-?: Required<Pick<ObjectType, Key>> & Partial<Pick<ObjectType, Exclude<KeysType, Key>>> }[KeysType] & Except<ObjectType, KeysType>;
 type StringUnionToFullOptionArray<Op extends string> = Array<Op extends unknown ? FullOption<Op> : never>;
 /**
 * Extracts the type of the identifying property from a {@link Option},
@@ -928,11 +944,11 @@ type StringUnionToFullOptionArray<Op extends string> = Array<Op extends unknown
 *
 * @group Option Lists
 */
-type GetOptionIdentifierType<Opt extends BaseOption> = Opt extends Option<infer NameType> | ValueOption<infer NameType> ? NameType : string;
+type GetOptionIdentifierType<Opt$1 extends BaseOption> = Opt$1 extends Option<infer NameType> | ValueOption<infer NameType> ? NameType : string;
 /**
 * Adds an `unknown` index property to an interface.
 */
-type WithUnknownIndex<T> = T & {
+type WithUnknownIndex<T$1> = T$1 & {
   [key: string]: unknown;
 };
 /**
@@ -964,8 +980,8 @@ type Option<N extends string = string> = Simplify<WithUnknownIndex<SetRequired<B
 type ValueOption<N extends string = string> = Simplify<WithUnknownIndex<SetRequired<BaseOption<N>, "value">>>;
 /**
 * A generic {@link Option} with either a `name` or `value` as its primary identifier.
-* {@link OptionList}-type props on the {@link QueryBuilder} component accept this type,
-* but corresponding props passed down to subcomponents will always be translated
+* {@link OptionList}-type props on the {@link react-querybuilder!QueryBuilder QueryBuilder} component accept this type,
+* but corresponding props passed down to subcomponents will always be augmented
 * to {@link FullOption} first.
 *
 * @group Option Lists
@@ -977,11 +993,11 @@ type FlexibleOption<N extends string = string> = Simplify<WithUnknownIndex<Requi
 *
 * @group Option Lists
 */
-type ToFlexibleOption<Opt extends BaseOption | string> = WithUnknownIndex<RequireAtLeastOne<Opt extends string ? FlexibleOption<Opt> : Opt, "name" | "value">>;
+type ToFlexibleOption<Opt$1 extends BaseOption | string> = WithUnknownIndex<RequireAtLeastOne<Opt$1 extends string ? FlexibleOption<Opt$1> : Opt$1, "name" | "value">>;
 /**
 * A generic {@link Option} requiring both `name` _and_ `value` properties.
 * Props that extend {@link OptionList} accept {@link BaseOption}, but
-* corresponding props sent to subcomponents will always be translated to this
+* corresponding props sent to subcomponents will always be augmented to this
 * type first to ensure both `name` and `value` are available.
 *
 * NOTE: Do not extend from this type directly. Use {@link BaseFullOption}
@@ -1005,45 +1021,45 @@ type BaseFullOption<N extends string = string> = Simplify<SetRequired<BaseOption
 *
 * @group Option Lists
 */
-type ToFullOption<Opt extends BaseOption> = Opt extends BaseFullOption ? Opt : Opt extends BaseOption<infer IdentifierType> ? WithUnknownIndex<Opt & FullOption<IdentifierType>> : never;
+type ToFullOption<Opt$1 extends BaseOption> = Opt$1 extends BaseFullOption ? Opt$1 : Opt$1 extends BaseOption<infer IdentifierType> ? WithUnknownIndex<Opt$1 & FullOption<IdentifierType>> : never;
 /**
 * A group of {@link Option}s, usually within an {@link OptionList}.
 *
 * @group Option Lists
 */
-interface OptionGroup<Opt extends BaseOption = FlexibleOption> {
+interface OptionGroup<Opt$1 extends BaseOption = FlexibleOption> {
   label: string;
-  options: WithUnknownIndex<Opt>[];
+  options: WithUnknownIndex<Opt$1>[];
 }
 /**
 * A group of {@link BaseOption}s, usually within a {@link FlexibleOptionList}.
 *
 * @group Option Lists
 */
-type FlexibleOptionGroup<Opt extends BaseOption | string = BaseOption> = {
+type FlexibleOptionGroup<Opt$1 extends BaseOption | string = BaseOption> = {
   label: string;
-  options: (Opt extends BaseFullOption ? Opt : ToFlexibleOption<Opt>)[];
+  options: (Opt$1 extends BaseFullOption ? Opt$1 : ToFlexibleOption<Opt$1>)[];
 };
 /**
 * Either an array of {@link Option}s or an array of {@link OptionGroup}s.
 *
 * @group Option Lists
 */
-type OptionList<Opt extends Option = Option> = Opt[] | OptionGroup<Opt>[];
+type OptionList<Opt$1 extends Option = Option> = Opt$1[] | OptionGroup<Opt$1>[];
 /**
 * An array of options or option groups, like {@link OptionList} but the option type
 * may use either `name` or `value` as the primary identifier.
 *
 * @group Option Lists
 */
-type FlexibleOptionList<Opt extends BaseOption> = ToFlexibleOption<Opt>[] | FlexibleOptionGroup<ToFlexibleOption<Opt>>[];
+type FlexibleOptionList<Opt$1 extends BaseOption> = ToFlexibleOption<Opt$1>[] | FlexibleOptionGroup<ToFlexibleOption<Opt$1>>[];
 /**
 * An array of options or option groups, like {@link OptionList} but the option type
 * may use either `name` or `value` as the primary identifier.
 *
 * @group Option Lists
 */
-type FlexibleOptionListProp<Opt extends BaseOption> = (ToFlexibleOption<Opt> | GetOptionIdentifierType<Opt>)[] | FlexibleOptionGroup<ToFlexibleOption<Opt> | GetOptionIdentifierType<Opt>>[];
+type FlexibleOptionListProp<Opt$1 extends BaseOption> = (ToFlexibleOption<Opt$1> | GetOptionIdentifierType<Opt$1>)[] | FlexibleOptionGroup<ToFlexibleOption<Opt$1> | GetOptionIdentifierType<Opt$1>>[];
 /**
 * An array of options or option groups, like {@link OptionList}, but using
 * {@link FullOption} instead of {@link Option}. This means that every member is
@@ -1051,13 +1067,13 @@ type FlexibleOptionListProp<Opt extends BaseOption> = (ToFlexibleOption<Opt> | G
 *
 * @group Option Lists
 */
-type FullOptionList<Opt extends BaseOption> = Opt extends BaseFullOption ? Opt[] | OptionGroup<Opt>[] : ToFullOption<Opt>[] | OptionGroup<ToFullOption<Opt>>[];
+type FullOptionList<Opt$1 extends BaseOption> = Opt$1 extends BaseFullOption ? Opt$1[] | OptionGroup<Opt$1>[] : ToFullOption<Opt$1>[] | OptionGroup<ToFullOption<Opt$1>>[];
 /**
 * Map of option identifiers to their respective {@link Option}.
 *
 * @group Option Lists
 */
-type BaseOptionMap<V extends BaseOption = BaseOption, K extends string = GetOptionIdentifierType<V>> = { [k in K]?: ToFlexibleOption<V> };
+type BaseOptionMap<V$1 extends BaseOption = BaseOption, K$1 extends string = GetOptionIdentifierType<V$1>> = { [k in K$1]?: ToFlexibleOption<V$1> };
 //#endregion
 //#region ../core/src/types/ruleGroups.d.ts
 /**
@@ -1067,15 +1083,21 @@ interface CommonRuleAndGroupProperties {
   path?: Path;
   id?: string;
   disabled?: boolean;
+  /**
+  * Whether this rule or group is muted. When muted, the rule or group
+  * is excluded from query export formats (SQL, JSON, MongoDB, etc.).
+  * For groups, muting recursively mutes all children.
+  */
+  muted?: boolean;
 }
 /**
 * The main rule type. The `field`, `operator`, and `value` properties
 * can be narrowed with generics.
 */
-interface RuleType<F extends string = string, O extends string = string, V = any, C extends string = string> extends CommonRuleAndGroupProperties {
+interface RuleType<F extends string = string, O extends string = string, V$1 = any, C extends string = string> extends CommonRuleAndGroupProperties {
   field: F;
   operator: O;
-  value: V;
+  value: V$1;
   valueSource?: ValueSource;
   match?: MatchConfig;
   /**
@@ -1087,15 +1109,15 @@ interface RuleType<F extends string = string, O extends string = string, V = any
 * The main rule group type. This type is used for query definitions as well as
 * all sub-groups of queries.
 */
-interface RuleGroupType<R extends RuleType = RuleType, C extends string = string> extends CommonRuleAndGroupProperties {
+interface RuleGroupType<R$1 extends RuleType = RuleType, C extends string = string> extends CommonRuleAndGroupProperties {
   combinator: C;
-  rules: RuleGroupArray<RuleGroupType<R, C>, R>;
+  rules: RuleGroupArray<RuleGroupType<R$1, C>, R$1>;
   not?: boolean;
 }
 /**
 * The type of the `rules` array in a {@link RuleGroupType}.
 */
-type RuleGroupArray<RG extends RuleGroupType = RuleGroupType, R extends RuleType = RuleType> = (R | RG)[];
+type RuleGroupArray<RG$1 extends RuleGroupType = RuleGroupType, R$1 extends RuleType = RuleType> = (R$1 | RG$1)[];
 //#endregion
 //#region ../core/src/types/ruleGroupsIC.utils.d.ts
 type MAXIMUM_ALLOWED_BOUNDARY = 80;
@@ -1106,9 +1128,9 @@ type MappedTuple<Tuple extends Array<unknown>, Result extends Array<unknown> = [
 * The main rule group interface when using independent combinators. This type is used
 * for query definitions as well as all sub-groups of queries.
 */
-interface RuleGroupTypeIC<R extends RuleType = RuleType, C extends string = string> extends Except<RuleGroupType<R, C>, "combinator" | "rules"> {
+interface RuleGroupTypeIC<R$1 extends RuleType = RuleType, C extends string = string> extends Except<RuleGroupType<R$1, C>, "combinator" | "rules"> {
   combinator?: undefined;
-  rules: RuleGroupICArray<RuleGroupTypeIC<R, C>, R, C>;
+  rules: RuleGroupICArray<RuleGroupTypeIC<R$1, C>, R$1, C>;
   /**
   * Only used when adding a rule to a query that uses independent combinators
   */
@@ -1117,11 +1139,11 @@ interface RuleGroupTypeIC<R extends RuleType = RuleType, C extends string = stri
 /**
 * Shorthand for "either {@link RuleGroupType} or {@link RuleGroupTypeIC}".
 */
-type RuleGroupTypeAny<R extends RuleType = RuleType, C extends string = string> = RuleGroupType<R, C> | RuleGroupTypeIC<R, C>;
+type RuleGroupTypeAny<R$1 extends RuleType = RuleType, C extends string = string> = RuleGroupType<R$1, C> | RuleGroupTypeIC<R$1, C>;
 /**
 * The type of the `rules` array in a {@link RuleGroupTypeIC}.
 */
-type RuleGroupICArray<RG extends RuleGroupTypeIC = RuleGroupTypeIC, R extends RuleType = RuleType, C extends string = string> = [R | RG] | [R | RG, ...MappedTuple<[C, R | RG]>] | ((R | RG)[] & {
+type RuleGroupICArray<RG$1 extends RuleGroupTypeIC = RuleGroupTypeIC, R$1 extends RuleType = RuleType, C extends string = string> = [R$1 | RG$1] | [R$1 | RG$1, ...MappedTuple<[C, R$1 | RG$1]>] | ((R$1 | RG$1)[] & {
   length: 0;
 });
 /**
@@ -1131,7 +1153,7 @@ type RuleOrGroupArray = RuleGroupArray | RuleGroupICArray;
 /**
 * Converts a narrowed rule group type to its most generic form.
 */
-type GenericizeRuleGroupType<RG> = RG extends RuleGroupType ? RuleGroupType : RuleGroupTypeIC;
+type GenericizeRuleGroupType<RG$1> = RG$1 extends RuleGroupType ? RuleGroupType : RuleGroupTypeIC;
 //#endregion
 //#region ../core/src/types/validation.d.ts
 /**
@@ -1170,7 +1192,7 @@ type Classname = string | string[] | Record<string, any>;
 */
 type ValueSource = "value" | "field";
 /**
-* Type of {@link ValueEditor} that will be displayed.
+* Type of {@link react-querybuilder!ValueEditor ValueEditor} that will be displayed.
 */
 type ValueEditorType = "text" | "select" | "checkbox" | "radio" | "textarea" | "switch" | "multiselect" | null;
 /**
@@ -1187,7 +1209,7 @@ type ToOptionArrays<Sources extends readonly string[]> = Sources extends unknown
   label: string;
 } } : never;
 type ToFlexibleOptionArrays<Sources extends readonly string[]> = Sources extends unknown ? { [K in keyof Sources]: FlexibleOption<Sources[K]> } : never;
-type WithOptionalClassName<T> = T & {
+type WithOptionalClassName<T$1> = T$1 & {
   className?: Classname;
 };
 /**
@@ -1213,24 +1235,24 @@ type ValueChangeEventHandler = (value?: any, context?: any) => void;
 /**
 * Base for all Field types/interfaces.
 */
-interface BaseFullField<FieldName extends string = string, OperatorName extends string = string, ValueName extends string = string, OperatorObj extends FullOption = FullOption<OperatorName>, ValueObj extends FullOption = FullOption<ValueName>> extends WithOptionalClassName<BaseFullOption<FieldName>> {
+interface BaseFullField<FieldName extends string = string, OperatorName$1 extends string = string, ValueName extends string = string, OperatorObj extends FullOption = FullOption<OperatorName$1>, ValueObj extends FullOption = FullOption<ValueName>> extends WithOptionalClassName<BaseFullOption<FieldName>> {
   id?: string;
-  operators?: FlexibleOptionList<OperatorObj> | OperatorName[] | FlexibleOption<OperatorName>[] | (OperatorName | FlexibleOption<OperatorName>)[];
-  valueEditorType?: ValueEditorType | ((operator: OperatorName) => ValueEditorType);
-  valueSources?: ValueSources | ValueSourceFlexibleOptions | ((operator: OperatorName) => ValueSources | ValueSourceFlexibleOptions);
+  operators?: FlexibleOptionList<OperatorObj> | OperatorName$1[] | FlexibleOption<OperatorName$1>[] | (OperatorName$1 | FlexibleOption<OperatorName$1>)[];
+  valueEditorType?: ValueEditorType | ((operator: OperatorName$1) => ValueEditorType);
+  valueSources?: ValueSources | ValueSourceFlexibleOptions | ((operator: OperatorName$1) => ValueSources | ValueSourceFlexibleOptions);
   inputType?: InputType | null;
   values?: FlexibleOptionList<ValueObj>;
   matchModes?: boolean | MatchMode[] | FlexibleOption<MatchMode>[];
   /** Properties of items in the value. */
   subproperties?: FlexibleOptionList<FullField>;
-  defaultOperator?: OperatorName;
+  defaultOperator?: OperatorName$1;
   defaultValue?: any;
   placeholder?: string;
   validator?: RuleValidator;
   comparator?: string | ((f: FullField, operator: string) => boolean);
 }
 /**
-* Full field definition used in the `fields` prop of {@link QueryBuilder}.
+* Full field definition used in the `fields` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
 * This type requires both `name` and `value`, but the `fields` prop itself
 * can use a {@link FlexibleOption} where only one of `name` or `value` is
 * required (along with `label`), or {@link Field} where only `name` and
@@ -1241,15 +1263,15 @@ interface BaseFullField<FieldName extends string = string, OperatorName extends
 *
 * @group Option Lists
 */
-type FullField<FieldName extends string = string, OperatorName extends string = string, ValueName extends string = string, OperatorObj extends FullOption = FullOption<OperatorName>, ValueObj extends FullOption = FullOption<ValueName>> = Simplify<FullOption<FieldName> & BaseFullField<FieldName, OperatorName, ValueName, OperatorObj, ValueObj>>;
+type FullField<FieldName extends string = string, OperatorName$1 extends string = string, ValueName extends string = string, OperatorObj extends FullOption = FullOption<OperatorName$1>, ValueObj extends FullOption = FullOption<ValueName>> = Simplify<FullOption<FieldName> & BaseFullField<FieldName, OperatorName$1, ValueName, OperatorObj, ValueObj>>;
 /**
 * Allowed values of the {@link FullOperator} property `arity`. A value of `"unary"` or
-* a number less than two will cause the default {@link ValueEditor} to render `null`.
+* a number less than two will cause the default {@link react-querybuilder!ValueEditor ValueEditor} to render `null`.
 */
 type Arity = number | "unary" | "binary" | "ternary";
 /**
 * Full operator definition used in the `operators`/`getOperators` props of
-* {@link QueryBuilder}. This type requires both `name` and `value`, but the
+* {@link react-querybuilder!QueryBuilder QueryBuilder}. This type requires both `name` and `value`, but the
 * `operators`/`getOperators` props themselves can use a {@link FlexibleOption}
 * where only one of `name` or `value` is required, or {@link FullOperator} where
 * only `name` is required.
@@ -1262,7 +1284,7 @@ interface FullOperator<N extends string = string> extends WithOptionalClassName<
   arity?: Arity;
 }
 /**
-* Full combinator definition used in the `combinators` prop of {@link QueryBuilder}.
+* Full combinator definition used in the `combinators` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
 * This type requires both `name` and `value`, but the `combinators` prop itself
 * can use a {@link FlexibleOption} where only one of `name` or `value` is required,
 * or {@link Combinator} where only `name` is required.
@@ -1279,12 +1301,12 @@ type ParseNumberMethodName = "enhanced" | "native" | "strict";
 
 type ParseNumbersModerationLevel = "-limited" | "";
 /**
-* Options for the `parseNumbers` prop of {@link QueryBuilder}.
+* Options for the `parseNumbers` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
 */
 type ParseNumbersPropConfig = boolean | `${ParseNumberMethodName}${ParseNumbersModerationLevel}`;
 /**
-* Signature of `accessibleDescriptionGenerator` prop, used by {@link QueryBuilder} to generate
-* accessible descriptions for each {@link RuleGroup}.
+* Signature of `accessibleDescriptionGenerator` prop, used by {@link react-querybuilder!QueryBuilder QueryBuilder} to generate
+* accessible descriptions for each {@link react-querybuilder!RuleGroup RuleGroup}.
 */
 type AccessibleDescriptionGenerator = (props: {
   path: Path;
@@ -1294,7 +1316,7 @@ type AccessibleDescriptionGenerator = (props: {
 //#region ../core/src/types/dnd.d.ts
 type DropEffect = "move" | "copy";
 //#endregion
-//#region ../core/src/types/props.d.ts
+//#region ../core/src/types/queryBuilder.d.ts
 /**
 * Base interface for all rule subcomponents.
 *
@@ -1398,82 +1420,278 @@ interface Classnames {
   */
   lockGroup: Classname;
   /**
+  * Classnames applied to the `<button>` to mute a Rule.
+  */
+  muteRule: Classname;
+  /**
+  * Classnames applied to the `<button>` to mute a RuleGroup.
+  */
+  muteGroup: Classname;
+  /**
   * Classnames applied to the `<select>` control for value sources.
   */
-  valueSource: Classname;
+  valueSource: Classname;
+  /**
+  * Classnames applied to all action elements.
+  */
+  actionElement: Classname;
+  /**
+  * Classnames applied to all select elements.
+  */
+  valueSelector: Classname;
+  /**
+  * Classname(s) applied to inline combinator elements.
+  */
+  betweenRules: Classname;
+  /**
+  * Classname(s) applied to valid rules and groups.
+  */
+  valid: Classname;
+  /**
+  * Classname(s) applied to invalid rules and groups.
+  */
+  invalid: Classname;
+  /**
+  * Classname(s) applied to rules and groups while being dragged.
+  */
+  dndDragging: Classname;
+  /**
+  * Classname(s) applied to rules and groups hovered over by a dragged element.
+  */
+  dndOver: Classname;
+  /**
+  * Classname(s) applied to rules and groups hovered over by a dragged element
+  * when the drop effect is "copy" (modifier key is pressed).
+  */
+  dndCopy: Classname;
+  /**
+  * Classname(s) applied to rules and groups hovered over by a dragged element
+  * when the Ctrl key is pressed, indicating the items will form a new group.
+  */
+  dndGroup: Classname;
+  /**
+  * Classname(s) applied to rules and groups that cannot accept a drop from
+  * the dragged element hovering over it.
+  */
+  dndDropNotAllowed: Classname;
+  /**
+  * Classname(s) applied to disabled elements.
+  */
+  disabled: Classname;
+  /**
+  * Classname(s) applied to muted elements.
+  */
+  muted: Classname;
+  /**
+  * Classname(s) applied to each element in a series of value editors.
+  */
+  valueListItem: Classname;
+  /**
+  * Not applied, but see CSS styles.
+  */
+  branches: Classname;
+  /**
+  * Classname(s) rules that render a subquery.
+  */
+  hasSubQuery: Classname;
+}
+/**
+* Placeholder strings for option lists.
+*
+* @group Props
+*/
+interface Placeholder {
+  /**
+  * Value for the placeholder field option if autoSelectField is false,
+  * or the placeholder operator option if autoSelectOperator is false.
+  */
+  placeholderName?: string;
+  /**
+  * Label for the placeholder field option if autoSelectField is false,
+  * or the placeholder operator option if autoSelectOperator is false.
+  */
+  placeholderLabel?: string;
+  /**
+  * Label for the placeholder field optgroup if autoSelectField is false,
+  * or the placeholder operator optgroup if autoSelectOperator is false.
+  */
+  placeholderGroupLabel?: string;
+}
+/**
+* A translation for a component with `title` only.
+*
+* @group Props
+*/
+interface BaseTranslation {
+  title?: string;
+}
+/**
+* A translation for a component with `title` and `label`.
+*
+* @group Props
+*/
+interface BaseTranslationWithLabel<LabelType = string> extends BaseTranslation {
+  label?: LabelType;
+}
+/**
+* A translation for a component with `title` and a placeholder.
+*
+* @group Props
+*/
+interface BaseTranslationWithPlaceholders extends BaseTranslation, Placeholder {}
+/**
+* The shape of the `translations` prop.
+*
+* @group Props
+*/
+interface BaseTranslations<LabelType = string> {
+  fields: BaseTranslationWithPlaceholders;
+  operators: BaseTranslationWithPlaceholders;
+  values: BaseTranslationWithPlaceholders;
+  matchMode: BaseTranslation;
+  matchThreshold: BaseTranslation;
+  value: BaseTranslation;
+  removeRule: BaseTranslationWithLabel<LabelType>;
+  removeGroup: BaseTranslationWithLabel<LabelType>;
+  addRule: BaseTranslationWithLabel<LabelType>;
+  addGroup: BaseTranslationWithLabel<LabelType>;
+  combinators: BaseTranslation;
+  notToggle: BaseTranslationWithLabel<LabelType>;
+  cloneRule: BaseTranslationWithLabel<LabelType>;
+  cloneRuleGroup: BaseTranslationWithLabel<LabelType>;
+  shiftActionUp: BaseTranslationWithLabel<LabelType>;
+  shiftActionDown: BaseTranslationWithLabel<LabelType>;
+  dragHandle: BaseTranslationWithLabel<LabelType>;
+  lockRule: BaseTranslationWithLabel<LabelType>;
+  lockGroup: BaseTranslationWithLabel<LabelType>;
+  lockRuleDisabled: BaseTranslationWithLabel<LabelType>;
+  lockGroupDisabled: BaseTranslationWithLabel<LabelType>;
+  muteRule: BaseTranslationWithLabel<LabelType>;
+  muteGroup: BaseTranslationWithLabel<LabelType>;
+  unmuteRule: BaseTranslationWithLabel<LabelType>;
+  unmuteGroup: BaseTranslationWithLabel<LabelType>;
+  valueSourceSelector: BaseTranslation;
+}
+/**
+* Functions included in the `actions` prop passed to every subcomponent.
+*
+* @group Props
+*/
+interface QueryActions {
+  onGroupAdd(group: RuleGroupTypeAny, parentPath: Path, context?: any): void;
+  onGroupRemove(path: Path): void;
+  onPropChange(prop: Exclude<keyof RuleType | keyof RuleGroupType, "id" | "path">, value: any, path: Path, context?: any): void;
+  onRuleAdd(rule: RuleType, parentPath: Path, context?: any): void;
+  onRuleRemove(path: Path): void;
+  moveRule(oldPath: Path, newPath: Path | "up" | "down", clone?: boolean, context?: any): void;
+  groupRule(sourcePath: Path, targetPath: Path, clone?: boolean, context?: any): void;
+}
+interface QueryBuilderFlags {
+  /**
+  * Set to `false` to avoid calling the `onQueryChange` callback
+  * when the component mounts.
+  *
+  * @default true
+  */
+  enableMountQueryChange?: boolean;
+  /**
+  * Enables drag-and-drop features.
+  *
+  * @default false
+  */
+  enableDragAndDrop?: boolean;
+  /**
+  * Enables debug logging for query builders (and React DnD when applicable).
+  *
+  * @default false
+  */
+  debugMode?: boolean;
   /**
-  * Classnames applied to all action elements.
+  * Show group combinator selectors in the body of the group, between each child rule/group,
+  * instead of in the group header.
+  *
+  * @default false
   */
-  actionElement: Classname;
+  showCombinatorsBetweenRules?: boolean;
   /**
-  * Classnames applied to all select elements.
+  * Show the "not" (aka inversion) toggle for rule groups.
+  *
+  * @default false
   */
-  valueSelector: Classname;
+  showNotToggle?: boolean;
   /**
-  * Classname(s) applied to inline combinator elements.
+  * Show the "Shift up"/"Shift down" actions.
+  *
+  * @default false
   */
-  betweenRules: Classname;
+  showShiftActions?: boolean;
   /**
-  * Classname(s) applied to valid rules and groups.
+  * Show the "Clone rule" and "Clone group" buttons.
+  *
+  * @default false
   */
-  valid: Classname;
+  showCloneButtons?: boolean;
   /**
-  * Classname(s) applied to invalid rules and groups.
+  * Show the "Lock rule" and "Lock group" buttons.
+  *
+  * @default false
   */
-  invalid: Classname;
+  showLockButtons?: boolean;
   /**
-  * Classname(s) applied to rules and groups while being dragged.
+  * Show the "Mute rule" and "Mute group" buttons.
+  *
+  * @default false
   */
-  dndDragging: Classname;
+  showMuteButtons?: boolean;
   /**
-  * Classname(s) applied to rules and groups hovered over by a dragged element.
+  * Reset the `operator` and `value` when the `field` changes.
+  *
+  * @default true
   */
-  dndOver: Classname;
+  resetOnFieldChange?: boolean;
   /**
-  * Classname(s) applied to rules and groups hovered over by a dragged element
-  * when the drop effect is "copy" (modifier key is pressed).
+  * Reset the `value` when the `operator` changes.
+  *
+  * @default false
   */
-  dndCopy: Classname;
+  resetOnOperatorChange?: boolean;
   /**
-  * Classname(s) applied to rules and groups hovered over by a dragged element
-  * when the Ctrl key is pressed, indicating the items will form a new group.
+  * Select the first field in the array automatically.
+  *
+  * @default true
   */
-  dndGroup: Classname;
+  autoSelectField?: boolean;
   /**
-  * Classname(s) applied to rules and groups that cannot accept a drop from
-  * the dragged element hovering over it.
+  * Select the first operator in the array automatically.
+  *
+  * @default true
   */
-  dndDropNotAllowed: Classname;
+  autoSelectOperator?: boolean;
   /**
-  * Classname(s) applied to disabled elements.
+  * Select the first value in the array automatically. Only applicable when the value editor renders a select list.
+  *
+  * @default false
   */
-  disabled: Classname;
+  autoSelectValue?: boolean;
   /**
-  * Classname(s) applied to each element in a series of value editors.
+  * Adds a new default rule automatically to each new group.
+  *
+  * @default false
   */
-  valueListItem: Classname;
+  addRuleToNewGroups?: boolean;
   /**
-  * Not applied, but see CSS styles.
+  * Store list-type values as native arrays instead of comma-separated strings.
+  *
+  * @default false
   */
-  branches: Classname;
+  listsAsArrays?: boolean;
   /**
-  * Classname(s) rules that render a subquery.
+  * Prevent _any_ assignment of standard classes to elements. This includes conditional
+  * and event-based classes for validation, drag-and-drop, etc.
+  *
+  * @default false
   */
-  hasSubQuery: Classname;
-}
-/**
-* Functions included in the `actions` prop passed to every subcomponent.
-*
-* @group Props
-*/
-interface QueryActions {
-  onGroupAdd(group: RuleGroupTypeAny, parentPath: Path, context?: any): void;
-  onGroupRemove(path: Path): void;
-  onPropChange(prop: Exclude<keyof RuleType | keyof RuleGroupType, "id" | "path">, value: any, path: Path, context?: any): void;
-  onRuleAdd(rule: RuleType, parentPath: Path, context?: any): void;
-  onRuleRemove(path: Path): void;
-  moveRule(oldPath: Path, newPath: Path | "up" | "down", clone?: boolean, context?: any): void;
-  groupRule(sourcePath: Path, targetPath: Path, clone?: boolean, context?: any): void;
+  suppressStandardClassnames?: boolean;
 }
 //#endregion
 //#region ../core/src/utils/queryTools.d.ts
@@ -1525,7 +1743,8 @@ interface UseRuleGroup extends RuleGroupProps {
   addGroup: ActionElementEventHandler;
   addRule: ActionElementEventHandler;
   accessibleDescription: string;
-  classNames: Pick<{ [k in keyof Classnames]: string }, "header" | "shiftActions" | "dragHandle" | "combinators" | "notToggle" | "addRule" | "addGroup" | "cloneGroup" | "lockGroup" | "removeGroup" | "body">;
+  muted?: boolean;
+  classNames: Pick<{ [k in keyof Classnames]: string }, "header" | "shiftActions" | "dragHandle" | "combinators" | "notToggle" | "addRule" | "addGroup" | "cloneGroup" | "lockGroup" | "muteGroup" | "removeGroup" | "body">;
   cloneGroup: ActionElementEventHandler;
   onCombinatorChange: ValueChangeEventHandler;
   onGroupAdd: (group: RuleGroupTypeAny, parentPath: Path, context?: any) => void;
@@ -1541,6 +1760,7 @@ interface UseRuleGroup extends RuleGroupProps {
   shiftGroupDown: (event?: MouseEvent, context?: any) => void;
   shiftGroupUp: (event?: MouseEvent, context?: any) => void;
   toggleLockGroup: ActionElementEventHandler;
+  toggleMuteGroup: ActionElementEventHandler;
   validationClassName: string;
   validationResult: boolean | ValidationResult;
 }
@@ -1677,74 +1897,13 @@ interface ValueSourceSelectorProps extends BaseSelectorProps<FullOption>, Common
 *
 * @group Props
 */
-interface TranslationWithLabel extends Translation {
-  label?: ReactNode;
-}
-/**
-* A translation for a component with `title` only.
-*
-* @group Props
-*/
-interface Translation {
-  title?: string;
-}
-/**
-* Placeholder strings for option lists.
-*
-* @group Props
-*/
-interface Placeholder {
-  /**
-  * Value for the placeholder field option if autoSelectField is false,
-  * or the placeholder operator option if autoSelectOperator is false.
-  */
-  placeholderName?: string;
-  /**
-  * Label for the placeholder field option if autoSelectField is false,
-  * or the placeholder operator option if autoSelectOperator is false.
-  */
-  placeholderLabel?: string;
-  /**
-  * Label for the placeholder field optgroup if autoSelectField is false,
-  * or the placeholder operator optgroup if autoSelectOperator is false.
-  */
-  placeholderGroupLabel?: string;
-}
-/**
-* A translation for a component with `title` and a placeholder.
-*
-* @group Props
-*/
-interface TranslationWithPlaceholders extends Translation, Placeholder {}
+interface TranslationWithLabel extends BaseTranslationWithLabel<ReactNode> {}
 /**
 * The shape of the `translations` prop.
 *
 * @group Props
 */
-interface Translations {
-  fields: TranslationWithPlaceholders;
-  operators: TranslationWithPlaceholders;
-  values: TranslationWithPlaceholders;
-  matchMode: Translation;
-  matchThreshold: Translation;
-  value: Translation;
-  removeRule: TranslationWithLabel;
-  removeGroup: TranslationWithLabel;
-  addRule: TranslationWithLabel;
-  addGroup: TranslationWithLabel;
-  combinators: Translation;
-  notToggle: TranslationWithLabel;
-  cloneRule: TranslationWithLabel;
-  cloneRuleGroup: TranslationWithLabel;
-  shiftActionUp: TranslationWithLabel;
-  shiftActionDown: TranslationWithLabel;
-  dragHandle: TranslationWithLabel;
-  lockRule: TranslationWithLabel;
-  lockGroup: TranslationWithLabel;
-  lockRuleDisabled: TranslationWithLabel;
-  lockGroupDisabled: TranslationWithLabel;
-  valueSourceSelector: Translation;
-}
+interface Translations extends BaseTranslations<ReactNode> {}
 /**
 * Props passed to every action component (rendered as `<button>` by default).
 *
@@ -1948,6 +2107,18 @@ type ControlElementsProp<F extends FullField, O extends string> = Partial<{
   */
   lockRuleAction: ComponentType<ActionProps> | null;
   /**
+  * Mutes the current group (sets the `muted` property to `true`).
+  *
+  * @default ActionElement
+  */
+  muteGroupAction: ComponentType<ActionProps> | null;
+  /**
+  * Mutes the current rule (sets the `muted` property to `true`).
+  *
+  * @default ActionElement
+  */
+  muteRuleAction: ComponentType<ActionProps> | null;
+  /**
   * Selects the `match` property for the current rule.
   *
   * @default MatchModeEditor
@@ -2077,6 +2248,7 @@ interface Schema<F extends FullField, O extends string> {
   showShiftActions: boolean;
   showCloneButtons: boolean;
   showLockButtons: boolean;
+  showMuteButtons: boolean;
   autoSelectField: boolean;
   autoSelectOperator: boolean;
   autoSelectValue: boolean;
@@ -2097,6 +2269,7 @@ interface CommonRuleAndGroupProps<F extends FullField = FullField, O extends str
   id?: string;
   path: Path;
   parentDisabled?: boolean;
+  parentMuted?: boolean;
   translations: Translations;
   schema: Schema<F, O>;
   actions: QueryActions;
@@ -2187,19 +2360,12 @@ interface RuleProps<F extends string = string, O extends string = string> extend
 *
 * @group Props
 */
-interface QueryBuilderContextProps<F extends FullField, O extends string> {
+interface QueryBuilderContextProps<F extends FullField = FullField, O extends string = string> extends QueryBuilderFlags {
   /**
   * Defines replacement components.
   */
   controlElements?: ControlElementsProp<F, O>;
   /**
-  * Set to `false` to avoid calling the `onQueryChange` callback
-  * when the component mounts.
-  *
-  * @default true
-  */
-  enableMountQueryChange?: boolean;
-  /**
   * This can be used to assign specific CSS classes to various controls
   * that are rendered by {@link QueryBuilder}.
   */
@@ -2209,23 +2375,11 @@ interface QueryBuilderContextProps<F extends FullField, O extends string> {
   * controls that are rendered by {@link QueryBuilder}.
   */
   translations?: Partial<Translations>;
-  /**
-  * Enables drag-and-drop features.
-  *
-  * @default false
-  */
-  enableDragAndDrop?: boolean;
-  /**
-  * Enables debug logging for {@link QueryBuilder} (and React DnD when applicable).
-  *
-  * @default false
-  */
-  debugMode?: boolean;
 }
 /**
 * @group Props
 */
-interface QueryBuilderContextProviderProps extends QueryBuilderContextProps<FullField, string> {
+interface QueryBuilderContextProviderProps extends QueryBuilderContextProps {
   children?: ReactNode;
 }
 /**
@@ -2249,15 +2403,15 @@ type QueryBuilderContextProvider<ExtraProps extends object = Record<string, any>
 *
 * @group Props
 */
-type QueryBuilderProps<RG extends RuleGroupTypeAny, F extends FullField, O extends FullOperator, C extends FullCombinator> = RG extends RuleGroupType<infer R> | RuleGroupTypeIC<infer R> ? QueryBuilderContextProps<F, GetOptionIdentifierType<O>> & {
+type QueryBuilderProps<RG$1 extends RuleGroupTypeAny, F extends FullField, O extends FullOperator, C extends FullCombinator> = RG$1 extends RuleGroupType<infer R> | RuleGroupTypeIC<infer R> ? QueryBuilderContextProps<F, GetOptionIdentifierType<O>> & {
   /**
   * Initial query object for uncontrolled components.
   */
-  defaultQuery?: RG;
+  defaultQuery?: RG$1;
   /**
   * Query object for controlled components.
   */
-  query?: RG;
+  query?: RG$1;
   /**
   * List of valid {@link FullField}s.
   *
@@ -2409,7 +2563,7 @@ type QueryBuilderProps<RG extends RuleGroupTypeAny, F extends FullField, O exten
   */
   getSubQueryBuilderProps?(field: GetOptionIdentifierType<F>, misc: {
     fieldData: F;
-  }): QueryBuilderProps<GenericizeRuleGroupType<RG>, FullOption, FullOption, FullOption>;
+  }): QueryBuilderProps<GenericizeRuleGroupType<RG$1>, FullOption, FullOption, FullOption>;
   /**
   * The return value of this function will be used to apply classnames to the
   * outer `<div>` of the given {@link Rule}.
@@ -2421,56 +2575,56 @@ type QueryBuilderProps<RG extends RuleGroupTypeAny, F extends FullField, O exten
   * The return value of this function will be used to apply classnames to the
   * outer `<div>` of the given {@link RuleGroup}.
   */
-  getRuleGroupClassname?(ruleGroup: RG): Classname;
+  getRuleGroupClassname?(ruleGroup: RG$1): Classname;
   /**
   * This callback is invoked before a new rule is added. The function should either manipulate
   * the rule and return the new object, return `true` to allow the addition to proceed as normal,
   * or return `false` to cancel the addition of the rule.
   */
-  onAddRule?(rule: R, parentPath: Path, query: RG, context?: any): RuleType | boolean;
+  onAddRule?(rule: R, parentPath: Path, query: RG$1, context?: any): RuleType | boolean;
   /**
   * This callback is invoked before a new group is added. The function should either manipulate
   * the group and return the new object, return `true` to allow the addition to proceed as normal,
   * or return `false` to cancel the addition of the group.
   */
-  onAddGroup?(ruleGroup: RG, parentPath: Path, query: RG, context?: any): RG | boolean;
+  onAddGroup?(ruleGroup: RG$1, parentPath: Path, query: RG$1, context?: any): RG$1 | boolean;
   /**
   * This callback is invoked before a rule is moved or shifted. The function should return
   * `true` to allow the move/shift to proceed as normal, `false` to cancel the move/shift, or
   * a new query object (presumably based on `query` or `nextQuery`) which will become the new
   * query state.
   */
-  onMoveRule?(rule: R, fromPath: Path, toPath: Path | "up" | "down", query: RG, nextQuery: RG, options: MoveOptions, context?: any): RG | boolean;
+  onMoveRule?(rule: R, fromPath: Path, toPath: Path | "up" | "down", query: RG$1, nextQuery: RG$1, options: MoveOptions, context?: any): RG$1 | boolean;
   /**
   * This callback is invoked before a group is moved or shifted. The function should return
   * `true` to allow the move/shift to proceed as normal, `false` to cancel the move/shift, or
   * a new query object (presumably based on `query` or `nextQuery`) which will become the new
   * query state.
   */
-  onMoveGroup?(ruleGroup: RG, fromPath: Path, toPath: Path | "up" | "down", query: RG, nextQuery: RG, options: MoveOptions, context?: any): RG | boolean;
+  onMoveGroup?(ruleGroup: RG$1, fromPath: Path, toPath: Path | "up" | "down", query: RG$1, nextQuery: RG$1, options: MoveOptions, context?: any): RG$1 | boolean;
   /**
   * This callback is invoked before a rule is grouped with another object. The function should
   * return `true` to allow the grouping to proceed as normal, `false` to cancel the grouping,
   * or a new query object (presumably based on `query` or `nextQuery`) which will become the new
   * query state.
   */
-  onGroupRule?(rule: R, fromPath: Path, toPath: Path, query: RG, nextQuery: RG, options: GroupOptions, context?: any): RG | boolean;
+  onGroupRule?(rule: R, fromPath: Path, toPath: Path, query: RG$1, nextQuery: RG$1, options: GroupOptions, context?: any): RG$1 | boolean;
   /**
   * This callback is invoked before a group is grouped with another object. The function should
   * return `true` to allow the grouping to proceed as normal, `false` to cancel the grouping,
   * or a new query object (presumably based on `query` or `nextQuery`) which will become the new
   * query state.
   */
-  onGroupGroup?(ruleGroup: RG, fromPath: Path, toPath: Path, query: RG, nextQuery: RG, options: GroupOptions, context?: any): RG | boolean;
+  onGroupGroup?(ruleGroup: RG$1, fromPath: Path, toPath: Path, query: RG$1, nextQuery: RG$1, options: GroupOptions, context?: any): RG$1 | boolean;
   /**
   * This callback is invoked before a rule or group is removed. The function should return
   * `true` if the rule or group should be removed or `false` if it should not be removed.
   */
-  onRemove?(ruleOrGroup: R | RG, path: Path, query: RG, context?: any): boolean;
+  onRemove?(ruleOrGroup: R | RG$1, path: Path, query: RG$1, context?: any): boolean;
   /**
   * This callback is invoked anytime the query state is updated.
   */
-  onQueryChange?(query: RG): void;
+  onQueryChange?(query: RG$1): void;
   /**
   * Each log object will be passed to this function when `debugMode` is `true`.
   *
@@ -2478,84 +2632,20 @@ type QueryBuilderProps<RG extends RuleGroupTypeAny, F extends FullField, O exten
   */
   onLog?(obj: any): void;
   /**
-  * Show group combinator selectors in the body of the group, between each child rule/group,
-  * instead of in the group header.
-  *
-  * @default false
-  */
-  showCombinatorsBetweenRules?: boolean;
-  /**
   * @deprecated As of v7, this prop is ignored. To enable independent combinators, use
   * {@link RuleGroupTypeIC} for the `query` or `defaultQuery` prop. The query builder
   * will detect the query type and behave accordingly.
   */
   independentCombinators?: boolean;
   /**
-  * Show the "not" (aka inversion) toggle for rule groups.
-  *
-  * @default false
-  */
-  showNotToggle?: boolean;
-  /**
-  * Show the "Shift up"/"Shift down" actions.
-  *
-  * @default false
-  */
-  showShiftActions?: boolean;
-  /**
-  * Show the "Clone rule" and "Clone group" buttons.
-  *
-  * @default false
-  */
-  showCloneButtons?: boolean;
-  /**
-  * Show the "Lock rule" and "Lock group" buttons.
-  *
-  * @default false
-  */
-  showLockButtons?: boolean;
-  /**
-  * Reset the `operator` and `value` when the `field` changes.
-  *
-  * @default true
-  */
-  resetOnFieldChange?: boolean;
-  /**
-  * Reset the `value` when the `operator` changes.
-  *
-  * @default false
-  */
-  resetOnOperatorChange?: boolean;
-  /**
-  * Select the first field in the array automatically.
-  *
-  * @default true
-  */
-  autoSelectField?: boolean;
-  /**
-  * Select the first operator in the array automatically.
-  *
-  * @default true
-  */
-  autoSelectOperator?: boolean;
-  /**
-  * Select the first value in the array automatically. Only applicable when the value editor renders a select list.
-  *
-  * @default false
-  */
-  autoSelectValue?: boolean;
-  /**
-  * Adds a new default rule automatically to each new group.
-  *
-  * @default false
-  */
-  addRuleToNewGroups?: boolean;
-  /**
-  * Store list-type values as native arrays instead of comma-separated strings.
+  * Disables the entire query builder if true, or the rules and groups at
+  * the specified paths (as well as all child rules/groups and subcomponents)
+  * if an array of paths is provided. If the root path is specified (`disabled={[[]]}`),
+  * no changes to the query are allowed.
   *
   * @default false
   */
-  listsAsArrays?: boolean;
+  disabled?: boolean | Path[];
   /**
   * Store values as numbers whenever possible.
   *
@@ -2581,15 +2671,6 @@ type QueryBuilderProps<RG extends RuleGroupTypeAny, F extends FullField, O exten
   */
   parseNumbers?: ParseNumbersPropConfig;
   /**
-  * Disables the entire query builder if true, or the rules and groups at
-  * the specified paths (as well as all child rules/groups and subcomponents)
-  * if an array of paths is provided. If the root path is specified (`disabled={[[]]}`),
-  * no changes to the query are allowed.
-  *
-  * @default false
-  */
-  disabled?: boolean | Path[];
-  /**
   * Query validation function.
   */
   validator?: QueryValidator;
@@ -2606,11 +2687,6 @@ type QueryBuilderProps<RG extends RuleGroupTypeAny, F extends FullField, O exten
   */
   accessibleDescriptionGenerator?: AccessibleDescriptionGenerator;
   /**
-  * Prevent _any_ assignment of standard classes to elements. This includes conditional
-  * and event-based classes for validation, drag-and-drop, etc.
-  */
-  suppressStandardClassnames?: boolean;
-  /**
   * Maximum number of levels deep the query is allowed to go. The minimum is 1; values
   * less than 1 will be ignored.
   */