@react-querybuilder/datetime 8.9.1 → 8.10.0

package/dist/{types-EgfSemtR.d.ts → types-Dm-PhQtt.d.ts}

@@ -1,35 +1,196 @@
 import { RulesLogic } from "json-logic-js";
 
-//#region ../core/src/types/type-fest/is-equal.d.ts
+//#region ../../node_modules/type-fest/source/observable-like.d.ts
+declare global {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
+}
 
 /**
-Returns a boolean for whether the two given types are equal.
+@remarks
+The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
+As well, some guidance on making an `Observable` to not include `closed` property.
+@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
+@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
+@see https://github.com/benlesh/symbol-observable#making-an-object-observable
 
-@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
+@category Observable
+*/
 
-Use-cases:
-- If you want to make a conditional branch based on the result of a comparison of two types.
+//#endregion
+//#region ../../node_modules/type-fest/source/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).
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
 
 @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;
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void; great(arg: string): void; escape: boolean};
 ```
 
-@group type-fest
+A more applicable example which could make its way into your library code follows.
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+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}
+```
+
+@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 allow indexing by the resulting type
+? Intersection & Union : never;
+//#endregion
+//#region ../../node_modules/type-fest/source/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.
+
+@link https://stackoverflow.com/a/49402091
+
+@example
+```
+import type {KeysOfUnion} from 'type-fest';
+
+type A = {
+	common: string;
+	a: number;
+};
+
+type B = {
+	common: string;
+	b: string;
+};
+
+type C = {
+	common: string;
+	c: boolean;
+};
+
+type Union = A | B | C;
+
+type CommonKeys = keyof Union;
+//=> 'common'
+
+type AllKeys = KeysOfUnion<Union>;
+//=> 'common' | 'a' | 'b' | 'c'
+```
+
+@category Object
 */
-type IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? 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 ../../node_modules/type-fest/source/optional-keys-of.d.ts
+/**
+Extract all optional keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+@example
+```
+import type {OptionalKeysOf, Except} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+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;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice'
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD
+};
+```
+
+@category Utilities
+*/
+type OptionalKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
+? (keyof { [Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never }) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
+: never;
+//#endregion
+//#region ../../node_modules/type-fest/source/required-keys-of.d.ts
+/**
+Extract all required keys from the given type.
+
+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 {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;
+}
+
+const validator1 = createValidation<User>('name', value => value.length < 25);
+const validator2 = createValidation<User>('surname', value => value.length < 25);
+```
+
+@category Utilities
+*/
+type RequiredKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
+? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never;
 //#endregion
-//#region ../core/src/types/type-fest/is-never.d.ts
+//#region ../../node_modules/type-fest/source/is-never.d.ts
 /**
 Returns a boolean for whether the given type is `never`.
 
@@ -45,20 +206,20 @@ import type {IsNever, And} 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
->;
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
 
 type EndIfEqual<I extends string, O extends string> =
-AreStringsEqual<I, O> extends true
-? never
-: void;
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
 
 function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-if (input === output) {
-process.exit(0);
-}
+	if (input === output) {
+		process.exit(0);
+	}
 }
 
 endIfEqual('abc', 'abc');
@@ -68,11 +229,12 @@ endIfEqual('abc', '123');
 //=> void
 ```
 
-@group type-fest
+@category Type Guard
+@category Utilities
 */
 type IsNever<T> = [T] extends [never] ? true : false;
 //#endregion
-//#region ../core/src/types/type-fest/if-never.d.ts
+//#region ../../node_modules/type-fest/source/if-never.d.ts
 /**
 An if-else-like type that resolves depending on whether the given type is `never`.
 
@@ -89,11 +251,12 @@ type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
 //=> 'bar'
 ```
 
-@group type-fest
+@category Type Guard
+@category Utilities
 */
 type IfNever$1<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
 //#endregion
-//#region ../core/src/types/type-fest/unknown-array.d.ts
+//#region ../../node_modules/type-fest/source/unknown-array.d.ts
 /**
 Represents an array with `unknown` value.
 
@@ -115,16 +278,15 @@ type C = IsArray<string>;
 //=> false
 ```
 
-@group type-fest
+@category Type
+@category Array
 */
 type UnknownArray = readonly unknown[];
 //#endregion
-//#region ../core/src/types/type-fest/internal/array.d.ts
+//#region ../../node_modules/type-fest/source/internal/array.d.ts
 
 /**
 Returns whether the given array `T` is readonly.
-
-@group type-fest
 */
 type IsArrayReadonly<T extends UnknownArray> = IfNever$1<T, false, T extends unknown[] ? false : true>;
 /**
@@ -137,9 +299,9 @@ An if-else-like type that resolves depending on whether the given array is reado
 import type {ArrayTail} from 'type-fest';
 
 type ReadonlyPreservingArrayTail<TArray extends readonly unknown[]> =
-ArrayTail<TArray> extends infer Tail
-? IfArrayReadonly<TArray, Readonly<Tail>, Tail>
-: never;
+	ArrayTail<TArray> extends infer Tail
+		? IfArrayReadonly<TArray, Readonly<Tail>, Tail>
+		: never;
 
 type ReadonlyTail = ReadonlyPreservingArrayTail<readonly [string, number, boolean]>;
 //=> readonly [number, boolean]
@@ -153,13 +315,14 @@ type ShouldBeTrue = IfArrayReadonly<readonly unknown[]>;
 type ShouldBeBar = IfArrayReadonly<unknown[], 'foo', 'bar'>;
 //=> 'bar'
 ```
-
-@group type-fest
 */
 type IfArrayReadonly<T extends UnknownArray, TypeIfArrayReadonly = true, TypeIfNotArrayReadonly = false> = IsArrayReadonly<T> extends infer Result ? Result extends true ? TypeIfArrayReadonly : TypeIfNotArrayReadonly : never;
 //#endregion
-//#region ../core/src/types/type-fest/is-any.d.ts
+//#region ../../node_modules/type-fest/source/is-any.d.ts
+// Can eventually be replaced with the built-in once this library supports
+// TS5.4+ only. Tracked in https://github.com/sindresorhus/type-fest/issues/848
 type NoInfer<T> = T extends infer U ? U : never;
+
 /**
 Returns a boolean for whether the given type is `any`.
 
@@ -175,7 +338,7 @@ const typedObject = {a: 1, b: 2} as const;
 const anyObject: any = {a: 1, b: 2};
 
 function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
-return obj[key];
+	return obj[key];
 }
 
 const typedA = get(typedObject, 'a');
@@ -185,11 +348,41 @@ const anyA = get(anyObject, 'a');
 //=> any
 ```
 
-@group type-fest
+@category Type Guard
+@category Utilities
 */
 type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
 //#endregion
-//#region ../core/src/types/type-fest/simplify.d.ts
+//#region ../../node_modules/type-fest/source/is-equal.d.ts
+/**
+Returns a boolean for whether the two given types are equal.
+
+@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 {IsEqual} 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;
+```
+
+@category Type Guard
+@category Utilities
+*/
+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 ../../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.
 
@@ -198,13 +391,13 @@ Useful to flatten the type output to improve type hints shown in editors. And al
 import type {Simplify} from 'type-fest';
 
 type PositionProps = {
-top: number;
-left: number;
+	top: number;
+	left: number;
 };
 
 type SizeProps = {
-width: number;
-height: number;
+	width: number;
+	height: number;
 };
 
 // In your editor, hovering over `Props` will show a flattened object with all the properties.
@@ -220,15 +413,15 @@ If the type definition must be an interface (perhaps it was defined in a third-p
 import type {Simplify} from 'type-fest';
 
 interface SomeInterface {
-foo: number;
-bar?: string;
-baz: number | undefined;
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
 }
 
 type SomeType = {
-foo: number;
-bar?: string;
-baz: number | undefined;
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
 };
 
 const literal = {foo: 123, bar: 'hello', baz: 456};
@@ -245,163 +438,11 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 
 @link https://github.com/microsoft/TypeScript/issues/15300
 @see SimplifyDeep
-
-@group type-fest
+@category Object
 */
 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).
-
-Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
-
-@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 {UnionToIntersection} from 'type-fest';
-
-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 UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection & Union : never;
-//#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.
-
-@link https://stackoverflow.com/a/49402091
-
-@example
-```
-import type {KeysOfUnion} from 'type-fest';
-
-type A = {
-common: string;
-a: number;
-};
-
-type B = {
-common: string;
-b: string;
-};
-
-type C = {
-common: string;
-c: boolean;
-};
-
-type Union = A | B | C;
-
-type CommonKeys = keyof Union;
-//=> 'common'
-
-type AllKeys = KeysOfUnion<Union>;
-//=> 'common' | 'a' | 'b' | 'c'
-```
-
-@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.
-
-This is useful when you want to create a new type that contains different type values for the optional keys only.
-
-@example
-```
-import type {OptionalKeysOf, Except} from 'type-fest';
-
-interface User {
-name: string;
-surname: string;
-
-luckyNumber?: number;
-}
-
-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;
-};
-
-const update1: UpdateOperation<User> = {
-name: 'Alice'
-};
-
-const update2: UpdateOperation<User> = {
-name: 'Bob',
-luckyNumber: REMOVE_FIELD
-};
-```
-
-@group type-fest
-*/
-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;
-//#endregion
-//#region ../core/src/types/type-fest/required-keys-of.d.ts
-/**
-Extract all required keys from the given type.
-
-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 {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;
-}
-
-const validator1 = createValidation<User>('name', value => value.length < 25);
-const validator2 = createValidation<User>('surname', value => value.length < 25);
-```
-
-@group type-fest
-*/
-type RequiredKeysOf<BaseType extends object> = BaseType extends unknown ? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never;
-//#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.
 
@@ -427,13 +468,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>`"
 ```
 
@@ -443,8 +484,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`.
 };
 ```
 
@@ -454,12 +495,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];
 };
 ```
 
@@ -470,19 +511,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>;
@@ -490,12 +531,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.
 
@@ -508,21 +548,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>;
@@ -539,13 +579,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.
 
@@ -554,17 +595,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>;
@@ -578,11 +619,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
+//#region ../../node_modules/type-fest/source/if-any.d.ts
 /**
 An if-else-like type that resolves depending on whether the given type is `any`.
 
@@ -599,11 +640,14 @@ type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
 //=> 'bar'
 ```
 
-@group type-fest
+@category Type Guard
+@category Utilities
 */
 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
+//#region ../../node_modules/type-fest/source/internal/type.d.ts
+// Should never happen
+
 /**
 An if-else-like type that resolves depending on whether the given type is `any` or `never`.
 
@@ -621,12 +665,10 @@ type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
 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.
@@ -637,15 +679,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
@@ -663,8 +705,6 @@ 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] };
 /**
@@ -718,12 +758,11 @@ 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> = 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>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+>>;
 //#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.
 
@@ -755,16 +794,15 @@ type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ?
 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.
 
@@ -779,8 +817,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'>;
@@ -800,10 +838,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:
@@ -816,12 +854,12 @@ 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/require-at-least-one.d.ts
 /**
 Create a type that requires at least one of the given keys. The remaining keys are kept as is.
 
@@ -830,23 +868,30 @@ Create a type that requires at least one of the given keys. The remaining keys a
 import type {RequireAtLeastOne} from 'type-fest';
 
 type Responder = {
-text?: () => string;
-json?: () => string;
-secure?: boolean;
+	text?: () => string;
+	json?: () => string;
+	secure?: boolean;
 };
 
 const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
-json: () => '{"message": "ok"}',
-secure: true
+	json: () => '{"message": "ok"}',
+	secure: true
 };
 ```
 
-@group type-fest
+@category Object
 */
 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 _RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType> = {
+  // For each `Key` in `KeysType` make a mapped type:
+[Key in KeysType]-?: Required<Pick<ObjectType, Key>> &
+// 1. Make `Key`'s type required
+// 2. Make all other keys in `KeysType` optional
+Partial<Pick<ObjectType, Exclude<KeysType, Key>>> }[KeysType] &
+// 3. Add the remaining keys not in `KeysType`
+Except<ObjectType, KeysType>;
 //#endregion
-//#region ../core/src/types/type-fest/set-required.d.ts
+//#region ../../node_modules/type-fest/source/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.
 
@@ -857,9 +902,9 @@ Use-case: You want to define a single model where the only thing that changes is
 import type {SetRequired} from 'type-fest';
 
 type Foo = {
-a?: number;
-b: string;
-c?: boolean;
+	a?: number;
+	b: string;
+	c?: boolean;
 }
 
 type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
@@ -874,13 +919,27 @@ 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 UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? IfArrayReadonly<BaseType, Readonly<ResultantArray>, ResultantArray> : never : Simplify<Except<BaseType, Keys> & Required<HomomorphicPick<BaseType, Keys>>>;
+type SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? IfArrayReadonly<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 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;
+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/options.d.ts
 /**
@@ -989,6 +1048,12 @@ 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
@@ -1691,4 +1756,4 @@ type IsDateFieldFunction = (...[rule, opts]: Parameters<RuleProcessor>) => boole
 type IsDateField = IsDateFieldFunction | Record<string, unknown> | Record<string, unknown>[] | boolean | undefined;
 //#endregion
 export { ExportOperatorMap, IsDateField, IsDateFieldFunction, RQBDateTimeJsonLogic, RQBDateTimeLibraryAPI, RQBJsonLogicDateAfter, RQBJsonLogicDateBefore, RQBJsonLogicDateBetween, RQBJsonLogicDateIn, RQBJsonLogicDateNotBetween, RQBJsonLogicDateNotIn, RQBJsonLogicDateNotOn, RQBJsonLogicDateOn, RQBJsonLogicDateOnOrAfter, RQBJsonLogicDateOnOrBefore, RQBJsonLogicDateTimeOperations, RuleProcessor, ValueProcessorByRule };
-//# sourceMappingURL=types-EgfSemtR.d.ts.map
+//# sourceMappingURL=types-Dm-PhQtt.d.ts.map