@react-querybuilder/datetime 8.8.4 → 8.9.1

package/dist/types-EgfSemtR.d.ts

@@ -0,0 +1,1694 @@
+import { RulesLogic } from "json-logic-js";
+
+//#region ../core/src/types/type-fest/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;
+```
+
+@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;
+//#endregion
+//#region ../core/src/types/type-fest/is-never.d.ts
+/**
+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 {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
+>;
+
+type EndIfEqual<I extends string, O extends string> =
+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);
+}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@group type-fest
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+//#endregion
+//#region ../core/src/types/type-fest/if-never.d.ts
+/**
+An if-else-like type that resolves depending on whether the given type is `never`.
+
+@see {@link IsNever}
+
+@example
+```
+import type {IfNever} from 'type-fest';
+
+type ShouldBeTrue = IfNever<never>;
+//=> true
+
+type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@group type-fest
+*/
+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
+/**
+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 {UnknownArray} from 'type-fest';
+
+type IsArray<T> = T extends UnknownArray ? true : false;
+
+type A = IsArray<['foo']>;
+//=> true
+
+type B = IsArray<readonly number[]>;
+//=> true
+
+type C = IsArray<string>;
+//=> false
+```
+
+@group type-fest
+*/
+type UnknownArray = readonly unknown[];
+//#endregion
+//#region ../core/src/types/type-fest/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>;
+/**
+An if-else-like type that resolves depending on whether the given array is readonly.
+
+@see {@link IsArrayReadonly}
+
+@example
+```
+import type {ArrayTail} from 'type-fest';
+
+type ReadonlyPreservingArrayTail<TArray extends readonly unknown[]> =
+ArrayTail<TArray> extends infer Tail
+? IfArrayReadonly<TArray, Readonly<Tail>, Tail>
+: never;
+
+type ReadonlyTail = ReadonlyPreservingArrayTail<readonly [string, number, boolean]>;
+//=> readonly [number, boolean]
+
+type NonReadonlyTail = ReadonlyPreservingArrayTail<[string, number, boolean]>;
+//=> [number, boolean]
+
+type ShouldBeTrue = IfArrayReadonly<readonly unknown[]>;
+//=> true
+
+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
+type NoInfer<T> = T extends infer U ? U : never;
+/**
+Returns a boolean for whether the given type is `any`.
+
+@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 {IsAny} from 'type-fest';
+
+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];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@group type-fest
+*/
+type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+//#endregion
+//#region ../core/src/types/type-fest/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 {Simplify} from 'type-fest';
+
+type PositionProps = {
+top: number;
+left: number;
+};
+
+type SizeProps = {
+width: number;
+height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+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.
+
+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 {Simplify} from 'type-fest';
+
+interface SomeInterface {
+foo: number;
+bar?: string;
+baz: number | undefined;
+}
+
+type SomeType = {
+foo: number;
+bar?: string;
+baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+function fn(object: Record<string, unknown>): void {}
+
+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`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see SimplifyDeep
+
+@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).
+
+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
+/**
+Omit any index signatures from the given object type, leaving only explicitly defined properties.
+
+This is the counterpart of `PickIndexSignature`.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+const keyed: Record<'foo', unknown> = {}; // Error
+// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+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>`'
+
+type Keyed = {} extends 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>`"
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+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`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+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];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+@example
+```
+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';
+}
+
+type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
+// => { foo: 'bar'; qux?: 'baz' | undefined; }
+```
+
+@see PickIndexSignature
+
+@group type-fest
+*/
+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
+/**
+Pick only index signatures from the given object type, leaving out all explicitly defined properties.
+
+This is the counterpart of `OmitIndexSignature`.
+
+@example
+```
+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';
+};
+
+type ExampleIndexSignature = PickIndexSignature<Example>;
+// {
+// 	[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;
+// }
+```
+
+@see OmitIndexSignature
+
+@group type-fest
+*/
+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
+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.
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+interface Foo {
+[x: string]: unknown;
+[x: number]: unknown;
+foo: string;
+bar: symbol;
+}
+
+type Bar = {
+[x: number]: number;
+[x: symbol]: unknown;
+bar: Date;
+baz: boolean;
+};
+
+export type FooBar = Merge<Foo, Bar>;
+// => {
+// 	[x: string]: unknown;
+// 	[x: number]: number;
+// 	[x: symbol]: unknown;
+// 	foo: string;
+// 	bar: Date;
+// 	baz: boolean;
+// }
+```
+
+@group type-fest
+*/
+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
+/**
+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.
+- Primitives types are returned as-is.
+- Picks all keys if `Keys` is `any`.
+- Doesn't pick `number` from a `string` index signature.
+
+@example
+```
+type ImageUpload = {
+url: string;
+size: number;
+thumbnailUrl: string;
+};
+
+type VideoUpload = {
+url: string;
+duration: number;
+encodingFormat: string;
+};
+
+// Distributes over union types and allows picking keys from any member of the union type
+type MediaDisplay = HomomorphicPick<ImageUpload | VideoUpload, "url" | "size" | "duration">;
+//=> {url: string; size: number} | {url: string; duration: number}
+
+// Primitive types are returned as-is
+type Primitive = HomomorphicPick<string | number, 'toUpperCase' | 'toString'>;
+//=> string | number
+
+// Picks all keys if `Keys` is `any`
+type Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;
+//=> {a: 1; b: 2} | {c: 3}
+
+// 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] };
+/**
+Merges user specified options with default options.
+
+@example
+```
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: true};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//=> {maxRecursionDepth: 10; leavesOnly: true}
+```
+
+@example
+```
+// Complains if default values are not provided for optional options
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+```
+
+@example
+```
+// Complains if an option's default type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+
+@example
+```
+// Complains if an option's specified type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: 'yes'};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                                                   ~~~~~~~~~~~~~~~~
+// 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>>>>;
+//#endregion
+//#region ../core/src/types/type-fest/except.d.ts
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+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
+  */
+  requireExactProps?: boolean;
+};
+type DefaultExceptOptions = {
+  requireExactProps: false;
+};
+/**
+Create a type from an object type without certain keys.
+
+We recommend setting the `requireExactProps` option to `true`.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+a: number;
+b: string;
+};
+
+type FooWithoutA = Except<Foo, 'a'>;
+//=> {b: string}
+
+const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
+//=> errors: 'a' does not exist in type '{ b: string; }'
+
+type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
+//=> {a: number} & Partial<Record<"b", never>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+
+// The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.
+
+// Consider the following example:
+
+type UserData = {
+[metadata: string]: string;
+email: string;
+name: string;
+role: 'admin' | 'user';
+};
+
+// `Omit` clearly doesn't behave as expected in this case:
+type PostPayload = Omit<UserData, 'email'>;
+//=> type PostPayload = { [x: string]: string; [x: number]: string; }
+
+// In situations like this, `Except` works better.
+// It simply removes the `email` key while preserving all the other keys.
+type PostPayload = Except<UserData, 'email'>;
+//=> type PostPayload = { [x: string]: string; name: string; role: 'admin' | 'user'; }
+```
+
+@group type-fest
+*/
+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>> : {});
+//#endregion
+//#region ../core/src/types/type-fest/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.
+
+@example
+```
+import type {RequireAtLeastOne} from 'type-fest';
+
+type Responder = {
+text?: () => string;
+json?: () => string;
+secure?: boolean;
+};
+
+const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
+json: () => '{"message": "ok"}',
+secure: true
+};
+```
+
+@group type-fest
+*/
+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>;
+//#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
+/**
+* Adds an `unknown` index property to an interface.
+*/
+type WithUnknownIndex<T> = T & {
+  [key: string]: unknown;
+};
+/**
+* Do not use this type directly; use {@link Option}, {@link ValueOption},
+* or {@link FullOption} instead. For specific option types, you can use
+* {@link FullField}, {@link FullOperator}, or {@link FullCombinator},
+* all of which extend {@link FullOption}.
+*
+* @group Option Lists
+*/
+interface BaseOption<N extends string = string> {
+  name?: N;
+  value?: N;
+  label: string;
+  disabled?: boolean;
+}
+/**
+* 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
+* to {@link FullOption} first.
+*
+* @group Option Lists
+*/
+type FlexibleOption<N extends string = string> = Simplify<WithUnknownIndex<RequireAtLeastOne<BaseOption<N>, "name" | "value">>>;
+/**
+* Utility type to turn an {@link Option}, {@link ValueOption}, or {@link BaseOption}
+* into a {@link FlexibleOption}.
+*
+* @group Option Lists
+*/
+type ToFlexibleOption<Opt extends BaseOption | string> = WithUnknownIndex<RequireAtLeastOne<Opt extends string ? FlexibleOption<Opt> : Opt, "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
+* type first to ensure both `name` and `value` are available.
+*
+* NOTE: Do not extend from this type directly. Use {@link BaseFullOption}
+* (optionally wrapped in {@link WithUnknownIndex}) instead, otherwise
+* the `unknown` index property will cause issues. See {@link Option} and
+* {@link ValueOption} for examples.
+*
+* @group Option Lists
+*/
+type FullOption<N extends string = string> = Simplify<WithUnknownIndex<SetRequired<BaseOption<N>, "name" | "value">>>;
+/**
+* This type is identical to {@link FullOption} but without the `unknown` index
+* property. Extend from this type instead of {@link FullOption} directly.
+*
+* @group Option Lists
+*/
+type BaseFullOption<N extends string = string> = Simplify<SetRequired<BaseOption<N>, "name" | "value">>;
+/**
+* Utility type to turn an {@link Option}, {@link ValueOption} or
+* {@link BaseOption} into a {@link FullOption}.
+*
+* @group Option Lists
+*/
+type ToFullOption<Opt extends BaseOption> = Opt extends BaseFullOption ? Opt : Opt extends BaseOption<infer IdentifierType> ? WithUnknownIndex<Opt & FullOption<IdentifierType>> : never;
+/**
+* A group of {@link Option}s, usually within an {@link OptionList}.
+*
+* @group Option Lists
+*/
+interface OptionGroup<Opt extends BaseOption = FlexibleOption> {
+  label: string;
+  options: WithUnknownIndex<Opt>[];
+}
+/**
+* A group of {@link BaseOption}s, usually within a {@link FlexibleOptionList}.
+*
+* @group Option Lists
+*/
+type FlexibleOptionGroup<Opt extends BaseOption | string = BaseOption> = {
+  label: string;
+  options: (Opt extends BaseFullOption ? Opt : ToFlexibleOption<Opt>)[];
+};
+/**
+* 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>>[];
+/**
+* An array of options or option groups, like {@link OptionList}, but using
+* {@link FullOption} instead of {@link Option}. This means that every member is
+* guaranteed to have both `name` and `value`.
+*
+* @group Option Lists
+*/
+type FullOptionList<Opt extends BaseOption> = Opt extends BaseFullOption ? Opt[] | OptionGroup<Opt>[] : ToFullOption<Opt>[] | OptionGroup<ToFullOption<Opt>>[];
+//#endregion
+//#region ../core/src/types/ruleGroups.d.ts
+/**
+* Properties common to both rules and groups.
+*/
+interface CommonRuleAndGroupProperties {
+  path?: Path;
+  id?: string;
+  disabled?: 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 {
+  field: F;
+  operator: O;
+  value: V;
+  valueSource?: ValueSource;
+  match?: MatchConfig;
+  /**
+  * Only used when adding a rule to a query that uses independent combinators.
+  */
+  combinatorPreceding?: C;
+}
+/**
+* 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 {
+  combinator: C;
+  rules: RuleGroupArray<RuleGroupType<R, C>, R>;
+  not?: boolean;
+}
+/**
+* The type of the `rules` array in a {@link RuleGroupType}.
+*/
+type RuleGroupArray<RG extends RuleGroupType = RuleGroupType, R extends RuleType = RuleType> = (R | RG)[];
+/**
+* Default values for the `operator` property.
+*
+* @group Option Lists
+*/
+type DefaultOperatorName = "=" | "!=" | "<" | ">" | "<=" | ">=" | "contains" | "beginsWith" | "endsWith" | "doesNotContain" | "doesNotBeginWith" | "doesNotEndWith" | "null" | "notNull" | "in" | "notIn" | "between" | "notBetween";
+//#endregion
+//#region ../core/src/types/ruleGroupsIC.utils.d.ts
+type MAXIMUM_ALLOWED_BOUNDARY = 80;
+type MappedTuple<Tuple extends Array<unknown>, Result extends Array<unknown> = [], Count extends ReadonlyArray<number> = []> = Count["length"] extends MAXIMUM_ALLOWED_BOUNDARY ? Result : Tuple extends [] ? [] : Result extends [] ? MappedTuple<Tuple, Tuple, [...Count, 1]> : MappedTuple<Tuple, Result | [...Result, ...Tuple], [...Count, 1]>;
+//#endregion
+//#region ../core/src/types/ruleGroupsIC.d.ts
+/**
+* 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"> {
+  combinator?: undefined;
+  rules: RuleGroupICArray<RuleGroupTypeIC<R, C>, R, C>;
+  /**
+  * Only used when adding a rule to a query that uses independent combinators
+  */
+  combinatorPreceding?: C;
+}
+/**
+* Shorthand for "either {@link RuleGroupType} or {@link RuleGroupTypeIC}".
+*/
+type RuleGroupTypeAny<R extends RuleType = RuleType, C extends string = string> = RuleGroupType<R, C> | RuleGroupTypeIC<R, 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)[] & {
+  length: 0;
+});
+//#endregion
+//#region ../core/src/types/validation.d.ts
+/**
+* Object with a `valid` boolean value and optional `reasons`.
+*/
+interface ValidationResult {
+  valid: boolean;
+  reasons?: any[];
+}
+/**
+* Map of rule/group `id` to its respective {@link ValidationResult}.
+*/
+type ValidationMap = Record<string, boolean | ValidationResult>;
+/**
+* Function that validates a query.
+*/
+type QueryValidator = (query: RuleGroupTypeAny) => boolean | ValidationMap;
+/**
+* Function that validates a rule.
+*/
+type RuleValidator = (rule: RuleType) => boolean | ValidationResult;
+//#endregion
+//#region ../core/src/types/basic.d.ts
+/**
+* @see https://react-querybuilder.js.org/docs/tips/path
+*/
+type Path = number[];
+/**
+* String of classnames, array of classname strings, or object where the
+* keys are classnames and those with truthy values will be included.
+* Suitable for passing to the `clsx` package.
+*/
+type Classname = string | string[] | Record<string, any>;
+/**
+* A source for the `value` property of a rule.
+*/
+type ValueSource = "value" | "field";
+/**
+* Type of {@link ValueEditor} that will be displayed.
+*/
+type ValueEditorType = "text" | "select" | "checkbox" | "radio" | "textarea" | "switch" | "multiselect" | null;
+/**
+* A valid array of potential value sources.
+*
+* @see {@link ValueSource}
+*/
+type ValueSources = ["value"] | ["value", "field"] | ["field", "value"] | ["field"];
+type ValueSourceFlexibleOptions = ToFlexibleOptionArrays<ValueSources>;
+type ToFlexibleOptionArrays<Sources extends readonly string[]> = Sources extends unknown ? { [K in keyof Sources]: FlexibleOption<Sources[K]> } : never;
+type WithOptionalClassName<T> = T & {
+  className?: Classname;
+};
+/**
+* HTML5 input types
+*/
+type InputType = "button" | "checkbox" | "color" | "date" | "datetime-local" | "email" | "file" | "hidden" | "image" | "month" | "number" | "password" | "radio" | "range" | "reset" | "search" | "submit" | "tel" | "text" | "time" | "url" | "week" | "bigint" | (string & {});
+/**
+* Quantification mode describing how many elements of the value array must pass
+* the filter for the rule itself to pass.
+*
+* For "atLeast", "atMost", and "exactly", the threshold value will be converted to
+* a percentage if the number is less than 1. Non-numeric values and numbers less
+* than 0 will be ignored.
+*/
+interface MatchConfig {
+  mode: MatchMode;
+  threshold?: number | null | undefined;
+}
+type MatchMode = "all" | "some" | "none" | "atLeast" | "atMost" | "exactly";
+/**
+* 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>> {
+  id?: string;
+  operators?: FlexibleOptionList<OperatorObj> | OperatorName[] | FlexibleOption<OperatorName>[] | (OperatorName | FlexibleOption<OperatorName>)[];
+  valueEditorType?: ValueEditorType | ((operator: OperatorName) => ValueEditorType);
+  valueSources?: ValueSources | ValueSourceFlexibleOptions | ((operator: OperatorName) => ValueSources | ValueSourceFlexibleOptions);
+  inputType?: InputType | null;
+  values?: FlexibleOptionList<ValueObj>;
+  matchModes?: boolean | MatchMode[] | FlexibleOption<MatchMode>[];
+  /** Properties of items in the value. */
+  subproperties?: FlexibleOptionList<FullField>;
+  defaultOperator?: OperatorName;
+  defaultValue?: any;
+  placeholder?: string;
+  validator?: RuleValidator;
+  comparator?: string | ((f: FullField, operator: string) => boolean);
+}
+/**
+* Full field definition used in the `fields` prop of {@link 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
+* `label` are required.
+*
+* The `name`/`value`, `operators`, and `values` properties of this interface
+* can be narrowed with generics.
+*
+* @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>>;
+/**
+* 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`.
+*/
+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
+* `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.
+*
+* The `name`/`value` properties of this interface can be narrowed with generics.
+*
+* @group Option Lists
+*/
+interface FullOperator<N extends string = string> extends WithOptionalClassName<FullOption<N>> {
+  arity?: Arity;
+}
+type ParseNumberMethodName = "enhanced" | "native" | "strict";
+/**
+* Parsing algorithms used by {@link parseNumber}.
+*/
+
+type ParseNumbersModerationLevel = "-limited" | "";
+/**
+* Options for the `parseNumbers` prop of {@link QueryBuilder}.
+*/
+type ParseNumbersPropConfig = boolean | `${ParseNumberMethodName}${ParseNumbersModerationLevel}`;
+//#endregion
+//#region ../core/src/types/export.d.ts
+/**
+* Available export formats for {@link formatQuery}.
+*
+* @group Export
+*/
+type ExportFormat = "json" | "sql" | "json_without_ids" | "parameterized" | "parameterized_named" | "mongodb" | "mongodb_query" | "cel" | "jsonlogic" | "spel" | "elasticsearch" | "jsonata" | "natural_language" | "ldap" | "drizzle" | "prisma" | "sequelize";
+/**
+* Available presets for the "sql" export format.
+*
+* @group Export
+*/
+type SQLPreset = "ansi" | "sqlite" | "postgresql" | "mysql" | "mssql" | "oracle";
+/**
+* A map of operators to strings to be used in the output of {@link formatQuery}. If the
+* result can differ based on the `valueSource`, the key should map to an array where the
+* second element represents the string to be used when `valueSource` is "field". The first
+* element will be used in all other cases.
+*
+* @group Export
+*/
+type ExportOperatorMap = Partial<Record<Lowercase<DefaultOperatorName> | DefaultOperatorName, string | [string, string]>>;
+/**
+* Options object shape for {@link formatQuery}.
+*
+* @group Export
+*/
+interface FormatQueryOptions {
+  /**
+  * The {@link ExportFormat}.
+  */
+  format?: ExportFormat;
+  /**
+  * This function will be used to process the `operator` from each rule
+  * for query language formats. If not defined, the appropriate
+  * `defaultOperatorProcessor*` for the format will be used.
+  */
+  operatorProcessor?: RuleProcessor;
+  /**
+  * This function will be used to process the `value` from each rule
+  * for query language formats. If not defined, the appropriate
+  * `defaultValueProcessor*` for the format will be used.
+  */
+  valueProcessor?: ValueProcessorLegacy | ValueProcessorByRule;
+  /**
+  * This function will be used to process each rule. If not defined, the appropriate
+  * `defaultRuleProcessor*` for the given format will be used.
+  */
+  ruleProcessor?: RuleProcessor;
+  /**
+  * This function will be used to process each rule group. If not defined, the appropriate
+  * `defaultRuleGroupProcessor*` for the format will be used.
+  *
+  * If this function is defined, it will override the `format` option. This also allows
+  * `formatQuery` to produce completely custom output formats.
+  */
+  ruleGroupProcessor?: RuleGroupProcessor;
+  /**
+  * In the "sql", "parameterized", "parameterized_named", and "jsonata" export
+  * formats, field names will be bracketed by this string. If an array of strings
+  * is passed, field names will be preceded by the first element and
+  * succeeded by the second element.
+  *
+  * Tip: Use `fieldIdentifierSeparator` to bracket identifiers individually within field names.
+  *
+  * @default '' // the empty string
+  *
+  * @example
+  * formatQuery(query, { format: 'sql', quoteFieldNamesWith: '"' })
+  * // `"First name" = 'Steve'`
+  *
+  * @example
+  * formatQuery(query, { format: 'sql', quoteFieldNamesWith: ['[', ']'] })
+  * // "[First name] = 'Steve'"
+  */
+  quoteFieldNamesWith?: string | [string, string];
+  /**
+  * When used in conjunction with the `quoteFieldNamesWith` option, field names will
+  * be split by this string, each part being individually processed as per the rules
+  * of the `quoteFieldNamesWith` configuration. The parts will then be re-joined
+  * by the same string.
+  *
+  * A common value for this option is `'.'`.
+  *
+  * A value of `''` (the empty string) will disable splitting/rejoining.
+  *
+  * @default ''
+  *
+  * @example
+  * formatQuery(query, {
+  *   format: 'sql',
+  *   quoteFieldNamesWith: ['[', ']'],
+  *   fieldIdentifierSeparator: '.',
+  * })
+  * // "[dbo].[Musicians].[First name] = 'Steve'"
+  */
+  fieldIdentifierSeparator?: string;
+  /**
+  * Character to use for quoting string values in the SQL format.
+  * @default `'`
+  */
+  quoteValuesWith?: string;
+  /**
+  * Validator function for the entire query. Can be the same function passed
+  * as `validator` prop to {@link QueryBuilder}.
+  */
+  validator?: QueryValidator;
+  /**
+  * This can be the same {@link FullField} array passed to {@link QueryBuilder}, but
+  * really all you need to provide is the `name` and `validator` for each field.
+  *
+  * The full field object from this array, where the field's identifying property
+  * matches the rule's `field`, will be passed to the rule processor.
+  */
+  fields?: FlexibleOptionList<FullField>;
+  /**
+  * This can be the same `getOperators` function passed to {@link QueryBuilder}.
+  *
+  * The full operator object from this array, where the operator's identifying property
+  * matches the rule's `operator`, will be passed to the rule processor.
+  */
+  getOperators?(field: string, misc: {
+    fieldData: FullField;
+  }): FlexibleOptionList<FullOperator> | null;
+  /**
+  * This string will be inserted in place of invalid groups for non-JSON formats.
+  * Defaults to `'(1 = 1)'` for "sql"/"parameterized"/"parameterized_named" and
+  * `'$and:[{$expr:true}]'` for "mongodb".
+  */
+  fallbackExpression?: string;
+  /**
+  * This string will be placed in front of named parameters (aka bind variables)
+  * when using the "parameterized_named" export format.
+  *
+  * @default ":"
+  */
+  paramPrefix?: string;
+  /**
+  * Maintains the parameter prefix in the `params` object keys when using the
+  * "parameterized_named" export format. Recommended when using SQLite.
+  *
+  * @default false
+  *
+  * @example
+  * console.log(formatQuery(query, {
+  *   format: "parameterized_named",
+  *   paramPrefix: "$",
+  *   paramsKeepPrefix: true
+  * }).params)
+  * // { $firstName: "Stev" }
+  * // Default (`paramsKeepPrefix` is `false`):
+  * // { firstName: "Stev" }
+  */
+  paramsKeepPrefix?: boolean;
+  /**
+  * Renders parameter placeholders as a series of sequential numbers
+  * instead of '?' like the default. This option will respect the
+  * `paramPrefix` option like the 'parameterized_named' format.
+  *
+  * @default false
+  */
+  numberedParams?: boolean;
+  /**
+  * Preserves the order of values for "between" and "notBetween" rules, even if a larger
+  * value comes before a smaller value (which will always evaluate to false).
+  */
+  preserveValueOrder?: boolean;
+  /**
+  * Renders values as either `number`-types or unquoted strings, as
+  * appropriate and when possible. Each `string`-type value is evaluated
+  * against {@link numericRegex} to determine if it can be represented as a
+  * plain numeric value. If so, `parseFloat` is used to convert it to a number.
+  */
+  parseNumbers?: ParseNumbersPropConfig;
+  /**
+  * Any rules where the field is equal to this value will be ignored.
+  *
+  * @default '~'
+  */
+  placeholderFieldName?: string;
+  /**
+  * Any rules where the operator is equal to this value will be ignored.
+  *
+  * @default '~'
+  */
+  placeholderOperatorName?: string;
+  /**
+  * Any rules where the value is equal to this value will be ignored.
+  *
+  * @default '~'
+  */
+  placeholderValueName?: string;
+  /**
+  * Operator to use when concatenating wildcard characters and field names in "sql" format.
+  * The ANSI standard is `||`, while SQL Server uses `+`. MySQL does not implement a concatenation
+  * operator by default, and therefore requires use of the `CONCAT` function.
+  *
+  * If `concatOperator` is set to `"CONCAT"` (case-insensitive), the `CONCAT` function will be
+  * used. Note that Oracle SQL does not support more than two values in the `CONCAT` function,
+  * so this option should not be used in that context. The default setting (`"||"`) is already
+  * compatible with Oracle SQL.
+  *
+  * @default '||'
+  */
+  concatOperator?: "||" | "+" | "CONCAT" | (string & {});
+  /**
+  * Option presets to maximize compatibility with various SQL dialects.
+  */
+  preset?: SQLPreset;
+  /**
+  * Map of operators to their translations for the "natural_language" format. If the
+  * result can differ based on the `valueSource`, the key should map to an array where the
+  * second element represents the string to be used when `valueSource` is "field". The first
+  * element will be used in all other cases.
+  */
+  operatorMap?: ExportOperatorMap;
+  /**
+  * [Constituent word order](https://en.wikipedia.org/wiki/Word_order#Constituent_word_orders)
+  * for the "natural_language" format. Can be abbreviated like "SVO" or spelled out like
+  * "subject-verb-object".
+  *
+  * - Subject = field
+  * - Verb = operator
+  * - Object = value
+  */
+  wordOrder?: ConstituentWordOrderString | Lowercase<ConstituentWordOrderString> | ({} & string);
+  /**
+  * Translatable strings used by the "natural_language" format.
+  */
+  translations?: Partial<Record<NLTranslationKey, string>>;
+  context?: Record<string, any>;
+}
+/**
+* Options object for {@link ValueProcessorByRule} functions.
+*
+* @group Export
+*/
+interface ValueProcessorOptions extends FormatQueryOptions {
+  valueProcessor?: ValueProcessorByRule;
+  escapeQuotes?: boolean;
+  /**
+  * The full field object, if `fields` was provided in the
+  * {@link formatQuery} options parameter.
+  */
+  fieldData?: FullField;
+  /**
+  * Included for the "parameterized_named" format only. Keys of this object represent
+  * field names and values represent the current list of parameter names for that
+  * field based on the query rules processed up to that point. Use this list to
+  * ensure that parameter names generated by the custom rule processor are unique.
+  */
+  fieldParamNames?: Record<string, string[]>;
+  /**
+  * Included for the "parameterized_named" format only. Call this function with a
+  * field name to get a unique parameter name, as yet unused during query processing.
+  */
+  getNextNamedParam?: (field: string) => string;
+  /**
+  * Additional prefix and suffix characters to wrap the value in. Useful for augmenting
+  * the default value processor results with special syntax (e.g., for dates or function
+  * calls).
+  */
+  wrapValueWith?: [string, string];
+  /**
+  * Parse numbers in the rule value.
+  *
+  * @default false
+  */
+  parseNumbers?: boolean;
+}
+/**
+* Options object curated by {@link formatQuery} and passed to a {@link RuleGroupProcessor}.
+*
+* @group Export
+*/
+interface FormatQueryFinalOptions extends Required<Except<FormatQueryOptions, "context" | "valueProcessor" | "validator" | "placeholderValueName" | "ruleGroupProcessor" | "parseNumbers">> {
+  fields: FullOptionList<FullField>;
+  getParseNumberBoolean: (inputType?: InputType | null) => boolean | undefined;
+  parseNumbers?: ParseNumbersPropConfig | undefined;
+  placeholderValueName?: string | undefined;
+  valueProcessor: ValueProcessorByRule;
+  validator?: QueryValidator;
+  validateRule: FormatQueryValidateRule;
+  validationMap: ValidationMap;
+  context?: Record<string, unknown>;
+}
+/**
+* Function that produces a processed value for a given {@link RuleType}.
+*
+* @group Export
+*/
+type ValueProcessorByRule = (rule: RuleType, options?: ValueProcessorOptions) => string;
+/**
+* Function that produces a processed value for a given `field`, `operator`, `value`,
+* and `valueSource`.
+*
+* @group Export
+*/
+type ValueProcessorLegacy = (field: string, operator: string, value: any, valueSource?: ValueSource) => string;
+/**
+* Function to produce a result that {@link formatQuery} uses when processing a
+* {@link RuleType} object.
+*
+* See the default rule processor for each format to know what type to return.
+* | Format                   | Default rule processor                    |
+* | ------------------------ | ----------------------------------------- |
+* | `sql`                    | {@link defaultRuleProcessorSQL}           |
+* | `parameterized`          | {@link defaultRuleProcessorParameterized} |
+* | `parameterized_named`    | {@link defaultRuleProcessorParameterized} |
+* | `mongodb` _(deprecated)_ | {@link defaultRuleProcessorMongoDB}       |
+* | `mongodb_query`          | {@link defaultRuleProcessorMongoDBQuery}  |
+* | `cel`                    | {@link defaultRuleProcessorCEL}           |
+* | `spel`                   | {@link defaultRuleProcessorSpEL}          |
+* | `jsonlogic`              | {@link defaultRuleProcessorJsonLogic}     |
+* | `elasticsearch`          | {@link defaultRuleProcessorElasticSearch} |
+* | `jsonata`                | {@link defaultRuleProcessorJSONata}       |
+*
+* @group Export
+*/
+type RuleProcessor = (rule: RuleType, options?: ValueProcessorOptions, meta?: {
+  processedParams?: Record<string, any> | any[];
+  context?: Record<string, any>;
+}) => any;
+/**
+* Function to produce a result that {@link formatQuery} uses when processing a
+* {@link RuleGroupType} or {@link RuleGroupTypeIC} object.
+*
+* See the default rule group processor for each format to know what type to return.
+* | Format                   | Default rule group processor                   |
+* | ------------------------ | ---------------------------------------------- |
+* | `sql`                    | {@link defaultRuleGroupProcessorSQL}           |
+* | `parameterized`          | {@link defaultRuleGroupProcessorParameterized} |
+* | `parameterized_named`    | {@link defaultRuleGroupProcessorParameterized} |
+* | `mongodb` _(deprecated)_ | {@link defaultRuleGroupProcessorMongoDB}       |
+* | `mongodb_query`          | {@link defaultRuleGroupProcessorMongoDBQuery}  |
+* | `cel`                    | {@link defaultRuleGroupProcessorCEL}           |
+* | `spel`                   | {@link defaultRuleGroupProcessorSpEL}          |
+* | `jsonlogic`              | {@link defaultRuleGroupProcessorJsonLogic}     |
+* | `elasticsearch`          | {@link defaultRuleGroupProcessorElasticSearch} |
+* | `jsonata`                | {@link defaultRuleGroupProcessorJSONata}       |
+*
+* @group Export
+*/
+type RuleGroupProcessor<TResult = unknown> = (ruleGroup: RuleGroupTypeAny, options: FormatQueryFinalOptions, meta?: {
+  processedParams?: Record<string, any> | any[];
+  context?: Record<string, any>;
+}) => TResult;
+/**
+* Rule validator for {@link formatQuery}.
+*
+* @group Export
+*/
+type FormatQueryValidateRule = (rule: RuleType) => readonly [boolean | ValidationResult | undefined, RuleValidator | undefined];
+/**
+* @group Export
+*/
+interface RQBJsonLogicStartsWith {
+  startsWith: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+/**
+* @group Export
+*/
+interface RQBJsonLogicEndsWith {
+  endsWith: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+/**
+* JsonLogic rule object with additional operators generated by {@link formatQuery}
+* and accepted by {@link parseJsonLogic!parseJsonLogic}.
+*
+* @group Export
+*/
+type RQBJsonLogic = RulesLogic<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith>;
+/**
+* Constituent word order (as string) for the "natural_language" format.
+*
+* - S (subject) = field
+* - V (verb) = operator
+* - O (object) = value
+*
+* @group Export
+*/
+type ConstituentWordOrderString = "SVO" | "SOV" | "OSV" | "OVS" | "VSO" | "VOS";
+type RepeatStrings<S extends string[], Depth extends number[] = []> = Depth["length"] extends 2 ? "" : "" | `_${S[number]}${RepeatStrings<S, [...Depth, 1]>}`;
+type ZeroOrMoreGroupVariants = RepeatStrings<["xor", "not"]>;
+/**
+* Rule group condition identifier for the "natural_language" format.
+*
+* @group Export
+*/
+
+/**
+* Keys for the `translations` config object used by the "natural_language" format.
+*
+* @group Export
+*/
+type NLTranslationKey = "and" | "or" | "true" | "false" | `groupPrefix${ZeroOrMoreGroupVariants}` | `groupSuffix${ZeroOrMoreGroupVariants}`;
+//#endregion
+//#region src/types.d.ts
+interface RQBJsonLogicDateBetween {
+  dateBetween: [RQBJsonLogic, RQBJsonLogic, RQBJsonLogic];
+}
+interface RQBJsonLogicDateNotBetween {
+  dateNotBetween: [RQBJsonLogic, RQBJsonLogic, RQBJsonLogic];
+}
+interface RQBJsonLogicDateIn {
+  dateIn: [RQBJsonLogic, RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateNotIn {
+  dateNotIn: [RQBJsonLogic, RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateBefore {
+  dateBefore: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateOnOrBefore {
+  dateOnOrBefore: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateOn {
+  dateOn: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateNotOn {
+  dateNotOn: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateAfter {
+  dateAfter: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateOnOrAfter {
+  dateOnOrAfter: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+/**
+* JsonLogic rule object with additional operators generated by
+* {@link @react-querybuilder/core!formatQuery formatQuery} and accepted by
+* {@link @react-querybuilder/core!parseJsonLogic parseJsonLogic}.
+*/
+type RQBDateTimeJsonLogic = RQBJsonLogic | RulesLogic<RQBJsonLogicDateAfter | RQBJsonLogicDateBefore | RQBJsonLogicDateBetween | RQBJsonLogicDateIn | RQBJsonLogicDateNotBetween | RQBJsonLogicDateNotIn | RQBJsonLogicDateNotOn | RQBJsonLogicDateOn | RQBJsonLogicDateOnOrAfter | RQBJsonLogicDateOnOrBefore>;
+type DateOrString = string | Date;
+interface RQBDateTimeLibraryAPI {
+  /**
+  * Formats a date as a string.
+  */
+  format: (d: DateOrString, fmt: string) => string;
+  /**
+  * Formats a date as an ISO 8601 string, only including
+  * the year, month, and day ('YYYY-MM-DD').
+  */
+  toISOStringDateOnly: (d: DateOrString) => string;
+  /**
+  * Determines whether the first date is after the second date.
+  */
+  isAfter: (a: DateOrString, b: DateOrString) => boolean;
+  /**
+  * Determines whether the first date is before the second date.
+  */
+  isBefore: (a: DateOrString, b: DateOrString) => boolean;
+  /**
+  * Determines whether the first date is the same as the second date.
+  *
+  * If either the first date or the second date is a string in the
+  * format 'YYYY-MM-DD', then the dates will only be compared at
+  * the date level (no time component). Otherwise, they will be
+  * compared to the millisecond.
+  */
+  isSame: (a: DateOrString, b: DateOrString) => boolean;
+  /**
+  * Determines whether the date is either a valid `Date` object or an
+  * ISO 8601-formatted string representing a valid date.
+  */
+  isValid: (d: DateOrString) => boolean;
+  /**
+  * Converts a string to a `Date` object or returns a valid `Date` as is.
+  */
+  toDate: (d: DateOrString) => Date;
+  /**
+  * Converts a `Date` or ISO 8601-formatted string into a full ISO 8601 UTC
+  * string, in the format 'YYYY-MM-DDTHH:mm:ss.SSSZ' (the "T" and "Z" are
+  * static; other parts represent standard time units, increasing in precision
+  * from left to right).
+  */
+  toISOString: (d: DateOrString) => string;
+}
+type FnDateDate = (a: DateOrString, b: DateOrString) => boolean;
+type FnDateArrayOfDates = (a: DateOrString, b: DateOrString[]) => boolean;
+type FnDateDateDate = (a: DateOrString, b: DateOrString, c: DateOrString) => boolean;
+type RQBJsonLogicDateTimeOperations = {
+  /** Determines if the first date is after the second date. */
+  dateAfter: FnDateDate;
+  /** Determines if the first date is before the second date. */
+  dateBefore: FnDateDate;
+  /** Determines if the second date is between the first and third dates (inclusive). */
+  dateBetween: FnDateDateDate;
+  /** Determines if the first date is one of the values in the array of dates. */
+  dateIn: FnDateArrayOfDates;
+  /** Determines if the second date is not between the first and third dates. */
+  dateNotBetween: FnDateDateDate;
+  /** Determines if the first date is not one of the values in the array of dates. */
+  dateNotIn: FnDateArrayOfDates;
+  /** Determines if the first date is not the same as the second date. */
+  dateNotOn: FnDateDate;
+  /** Determines if the first date is the same as the second date (at the level of least precision between the two). */
+  dateOn: FnDateDate;
+  /** Determines if the first date is either the same as the second date or after it. */
+  dateOnOrAfter: FnDateDate;
+  /** Determines if the first date is either the same as the second date or before it. */
+  dateOnOrBefore: FnDateDate;
+};
+type IsDateFieldFunction = (...[rule, opts]: Parameters<RuleProcessor>) => boolean;
+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