// Generated by dts-bundle-generator v9.5.1

type SimplifyObject<T extends {}> = {
	[K in keyof T]: T[K];
} & {};
type Is<T1, T2> = [
	T1
] extends [
	T2
] ? true : false;
type IsNever<T> = Is<T, never>;
type IsUnion<T, U = T> = T extends unknown ? ([
	U
] extends [
	T
] ? false : true) : never;
type And<T1 extends boolean, T2 extends boolean> = T1 extends false ? false : T2;
type Not<T extends boolean> = T extends true ? false : true;
type KeyIsOptional<K extends PropertyKey, O extends Partial<Record<K, unknown>>> = O extends Record<K, unknown> ? false : true;
type IsRecord<T> = And<Not<IsNever<T>>, T extends Readonly<Record<PropertyKey, unknown>> ? true : false>;
type IsArray<T> = And<Not<IsNever<T>>, T extends ReadonlyArray<unknown> ? true : false>;
type IsSet<T> = And<Not<IsNever<T>>, T extends Readonly<ReadonlySet<unknown>> ? true : false>;
type IsMap<T> = And<Not<IsNever<T>>, T extends Readonly<ReadonlyMap<unknown, unknown>> ? true : false>;
type UnionSetValues<Ts extends ReadonlyArray<unknown>> = UnionSetValuesHelper<Ts, never>;
type UnionSetValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
	infer Head,
	...infer Rest
] ? Head extends Readonly<ReadonlySet<infer V1>> ? Rest extends ReadonlyArray<unknown> ? UnionSetValuesHelper<Rest, Acc | V1> : Acc | V1 : never : Acc;
type UnionMapKeys<Ts extends ReadonlyArray<unknown>> = UnionMapKeysHelper<Ts, never>;
type UnionMapKeysHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
	infer Head,
	...infer Rest
] ? Head extends Readonly<ReadonlyMap<infer K1, unknown>> ? Rest extends readonly [
] ? Acc | K1 : UnionMapKeysHelper<Rest, Acc | K1> : never : Acc;
type UnionMapValues<Ts extends ReadonlyArray<unknown>> = UnionMapValuesHelper<Ts, never>;
type UnionMapValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
	infer Head,
	...infer Rest
] ? Head extends Readonly<ReadonlyMap<unknown, infer V1>> ? Rest extends readonly [
] ? Acc | V1 : UnionMapValuesHelper<Rest, Acc | V1> : never : Acc;
type PreciseOrUnion<A, B> = A extends B ? A : B extends A ? B : A | B;
/**
 * Filter out U from a tuple.
 */
export type FilterOut<T extends ReadonlyArray<unknown>, U> = FilterOutHelper<T, U, [
]>;
type FilterOutHelper<T extends ReadonlyArray<unknown>, U, Acc extends ReadonlyArray<unknown>> = T extends readonly [
] ? Acc : T extends readonly [
	infer Head,
	...infer Rest
] ? Is<Head, U> extends true ? FilterOutHelper<Rest, U, Acc> : FilterOutHelper<Rest, U, [
	...Acc,
	Head
]> : T;
type IsTuple<T extends ReadonlyArray<unknown>> = T extends readonly [
] ? true : T extends readonly [
	unknown,
	...ReadonlyArray<unknown>
] ? true : false;
type UnionToTuple<T, Acc extends ReadonlyArray<unknown> = [
], L = LastOf<T>> = IsNever<T> extends true ? Acc : UnionToTuple<Exclude<T, L>, [
	L,
	...Acc
]>;
type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
type LastOf<T> = UnionToIntersection<T extends unknown ? () => T : never> extends () => infer R ? R : never;
type TupleTupleToTupleUnion<T extends ReadonlyArray<ReadonlyArray<unknown>>> = {
	[I in keyof T]: TupleToUnion<T[I]>;
};
type TupleToUnion<T extends ReadonlyArray<unknown>> = T extends readonly [
] ? never : T extends readonly [
	infer Head,
	...infer Rest
] ? Head | TupleToUnion<Rest> : never;
type AssertType<Expected, T> = T extends Expected ? T : never;
/**
 * Mapping of merge function URIs to the merge function type.
 */
export interface DeepMergeFunctionURItoKind<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, in out M> {
	readonly DeepMergeLeafURI: DeepMergeLeaf<Ts, Fs, M>;
	readonly DeepMergeRecordsDefaultURI: DeepMergeRecordsDefaultHKT<Ts, Fs, M>;
	readonly DeepMergeArraysDefaultURI: DeepMergeArraysDefaultHKT<Ts, Fs, M>;
	readonly DeepMergeSetsDefaultURI: DeepMergeSetsDefaultHKT<Ts>;
	readonly DeepMergeMapsDefaultURI: DeepMergeMapsDefaultHKT<Ts>;
	readonly DeepMergeCircularReferencesURI: DeepMergeCircularReferencesDefaultHKT<Ts, Fs, M>;
	readonly DeepMergeFilterValuesDefaultURI: DeepMergeFilterValuesDefaultHKT<Ts>;
	readonly DeepMergeNoFilteringURI: Ts;
}
type DeepMergeFunctionKind<URI extends DeepMergeFunctionURIs, Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionURItoKind<Ts, Fs, M>[URI];
type DeepMergeFunctionURIs = keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown>;
/**
 * The merge functions to use when deep merging.
 */
export type DeepMergeFunctionsURIs = Readonly<{
	/**
	 * The merge function to merge records with.
	 */
	DeepMergeRecordsURI: DeepMergeFunctionURIs;
	/**
	 * The merge function to merge arrays with.
	 */
	DeepMergeArraysURI: DeepMergeFunctionURIs;
	/**
	 * The merge function to merge sets with.
	 */
	DeepMergeSetsURI: DeepMergeFunctionURIs;
	/**
	 * The merge function to merge maps with.
	 */
	DeepMergeMapsURI: DeepMergeFunctionURIs;
	/**
	 * The merge function to merge other things with.
	 */
	DeepMergeOthersURI: DeepMergeFunctionURIs;
	/**
	 * The function to filter values.
	 */
	DeepMergeFilterValuesURI: DeepMergeFunctionURIs;
}>;
/**
 * Deep merge types.
 */
export type DeepMergeHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = IsTuple<Ts> extends true ? Ts extends readonly [
] ? undefined : DeepMergeSameTypeShortcut<Ts, Fs> extends true ? DeepMergeSameTypeElement<Ts> : DeepMergeHKTHelper<FilterValuesHKT<Ts, Fs, M>, Fs, M> : unknown;
type DeepMergeHKTHelper<Ts, Fs extends DeepMergeFunctionsURIs, M> = Ts extends ReadonlyArray<unknown> ? IsTuple<Ts> extends true ? Ts extends readonly [
] ? unknown : Ts extends readonly [
	infer T1
] ? T1 : DeepMergeDispatch<Ts, Fs, M, DeepMergeTupleKind<Ts>> : unknown : never;
type DeepMergeSameTypeShortcut<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs> = Is<Fs, DeepMergeFunctionsDefaultURIs> extends true ? AllSameTypes<Ts> extends true ? Ts extends readonly [
	infer T1,
	...ReadonlyArray<unknown>
] ? DeepMergeSameTypeShortcutElement<T1> extends true ? true : false : false : false : false;
type DeepMergeSameTypeShortcutElement<T1> = DeepMergeSameTypeValueSound<T1, [
]> extends true ? true : false;
type DeepMergeSameTypeValueSound<V, Seen extends ReadonlyArray<unknown>> = [
	V
] extends [
	Seen[number]
] ? false : IsUnion<V> extends true ? false : undefined extends V ? false : V extends ReadonlyArray<unknown> ? V extends unknown[] ? Not<IsTuple<V>> : false : V extends ReadonlySet<unknown> ? V extends Set<unknown> ? true : false : V extends ReadonlyMap<unknown, unknown> ? V extends Map<unknown, unknown> ? true : false : V extends Readonly<Record<PropertyKey, unknown>> ? DeepMergeSameTypeRecordSound<V, [
	V,
	...Seen
]> : true;
type DeepMergeSameTypeRecordSound<T, Seen extends ReadonlyArray<unknown>> = {
	[K in keyof T]-?: IsReadonlyProperty<T, K> extends true ? K : DeepMergeSameTypeValueSound<Required<T>[K], Seen> extends true ? never : K;
}[keyof T] extends never ? true : false;
type IsReadonlyProperty<T, K extends keyof T> = (<P>() => P extends {
	[PK in K]: T[K];
} ? 1 : 2) extends <P>() => P extends {
	readonly [PK in K]: T[K];
} ? 1 : 2 ? true : false;
type DeepMergeSameTypeElement<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
	infer T1,
	...ReadonlyArray<unknown>
] ? T1 : never;
type AllSameTypes<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
	infer Head,
	...infer Rest
] ? Rest extends ReadonlyArray<unknown> ? RestIsSameAs<Rest, Head> : true : true;
type RestIsSameAs<Ts extends ReadonlyArray<unknown>, T> = Ts extends readonly [
	infer Head,
	...infer Rest
] ? And<Is<Head, T>, Is<T, Head>> extends true ? Rest extends ReadonlyArray<unknown> ? RestIsSameAs<Rest, T> : true : false : true;
type DeepMergeDispatch<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M, Kind> = Kind extends "array" ? DeepMergeArraysHKT<Ts, Fs, M> : Kind extends "map" ? DeepMergeMapsHKT<Ts, Fs, M> : Kind extends "set" ? DeepMergeSetsHKT<Ts, Fs, M> : Kind extends "record" ? DeepMergeRecordsHKT<Ts, Fs, M> : DeepMergeOthersHKT<Ts, Fs, M>;
type DeepMergeElementKind<T> = IsArray<T> extends true ? "array" : IsMap<T> extends true ? "map" : IsSet<T> extends true ? "set" : IsRecord<T> extends true ? "record" : "other";
type DeepMergeTupleKind<Ts extends ReadonlyArray<unknown>> = DeepMergeKinds<Ts> extends "array" ? "array" : DeepMergeKinds<Ts> extends "map" ? "map" : DeepMergeKinds<Ts> extends "set" ? "set" : DeepMergeKinds<Ts> extends "record" ? "record" : "other";
type DeepMergeKinds<Ts extends ReadonlyArray<unknown>> = {
	[I in keyof Ts]: DeepMergeElementKind<Ts[I]>;
}[number];
type DeepMergeRecordsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeRecordsURI"], Ts, Fs, M>;
type DeepMergeArraysHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeArraysURI"], Ts, Fs, M>;
type DeepMergeSetsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeSetsURI"], Ts, Fs, M>;
type DeepMergeMapsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeMapsURI"], Ts, Fs, M>;
type DeepMergeOthersHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeOthersURI"], Ts, Fs, M>;
type FilterValuesHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeFilterValuesURI"], Ts, Fs, M>;
/**
 * The merge function that returns a leaf.
 */
export type DeepMergeLeafURI = "DeepMergeLeafURI";
/**
 * Don't filter values.
 */
export type DeepMergeNoFilteringURI = "DeepMergeNoFilteringURI";
/**
 * Get the leaf type from many types that can't be merged.
 */
export type DeepMergeLeaf<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = Ts extends readonly [
] ? never : Ts extends readonly [
	infer T
] ? T : Ts extends readonly [
	...infer Rest,
	infer Tail
] ? IsNever<Tail> extends true ? Rest extends ReadonlyArray<unknown> ? DeepMergeLeaf<Rest, Fs, M> : never : DeepMergeLeafApplyFilter<Ts, AssertType<ReadonlyArray<unknown>, TupleTupleToTupleUnion<AssertType<ReadonlyArray<ReadonlyArray<unknown>>, {
	[I in keyof Ts]: DeepMergeLeafElement<Ts[I], Fs, M>;
}>>>> : never;
type DeepMergeLeafElement<E, Fs extends DeepMergeFunctionsURIs, M> = Fs["DeepMergeFilterValuesURI"] extends DeepMergeFilterValuesDefaultURI ? [
	E extends undefined ? never : E
] : FilterValuesHKT<UnionToTuple<E>, Fs, M>;
type DeepMergeLeafApplyFilter<Original extends ReadonlyArray<unknown>, Filtered extends ReadonlyArray<unknown>> = Original extends readonly [
	...infer OriginalRest,
	infer OriginalTail
] ? Filtered extends readonly [
	...infer FilteredRest,
	infer FilteredTail
] ? OriginalTail extends FilteredTail ? FilteredTail : FilteredTail | DeepMergeLeafApplyFilter<OriginalRest, FilteredRest> : never : never;
type HierarchyValue = Readonly<{
	key: unknown;
	parents: ReadonlyArray<unknown>;
	values: ReadonlyArray<unknown>;
	result: unknown;
}>;
type DeepMergeRootMetaData = undefined;
/**
 * The built-in metadata type used by deepmerge.
 */
export type DeepMergeBuiltInMetaData = DeepMergeRootMetaData | (Partial<DeepMergeMergeInfo> & Readonly<{
	hierarchy?: ReadonlyArray<HierarchyValue>;
}>);
/**
 * The metadata type used by deepmerge.
 */
export type DeepMergeMetaData = unknown;
/**
 * Information about a single merge step, passed to {@link MetaDataUpdater}.
 *
 * - `key` — the property key being merged (e.g. a `Record` property name,
 * an array index for arrays, or `undefined` for the top-level merge).
 * - `parents` — the input values (in their original positions) that are
 * being merged at this step. For `deepmergeInto` these include the
 * target's value at index 0.
 * - `values` — the candidate values for `key` extracted from `parents`.
 * - `result` — the partial merge result computed so far for this step.
 */
export type DeepMergeMergeInfo = Readonly<{
	key: unknown;
	parents: ReadonlyArray<unknown>;
	values: ReadonlyArray<unknown>;
	result: unknown;
}>;
type DeepMergeRecordsDefaultURI = "DeepMergeRecordsDefaultURI";
type DeepMergeArraysDefaultURI = "DeepMergeArraysDefaultURI";
type DeepMergeSetsDefaultURI = "DeepMergeSetsDefaultURI";
type DeepMergeMapsDefaultURI = "DeepMergeMapsDefaultURI";
type DeepMergeFilterValuesDefaultURI = "DeepMergeFilterValuesDefaultURI";
/**
 * The default merge functions to use when deep merging.
 */
export type DeepMergeFunctionsDefaultURIs = Readonly<{
	DeepMergeRecordsURI: DeepMergeRecordsDefaultURI;
	DeepMergeArraysURI: DeepMergeArraysDefaultURI;
	DeepMergeSetsURI: DeepMergeSetsDefaultURI;
	DeepMergeMapsURI: DeepMergeMapsDefaultURI;
	DeepMergeOthersURI: DeepMergeLeafURI;
	DeepMergeFilterValuesURI: DeepMergeFilterValuesDefaultURI;
}>;
type KnownKeys<T> = keyof {
	[K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: unknown;
};
type RecordPropertyMeta<Key extends PropertyKey = PropertyKey, Value = unknown, Optional extends boolean = boolean> = {
	key: Key;
	value: Value;
	optional: Optional;
};
/**
 * Deep merge records.
 */
export type DeepMergeRecordsDefaultHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = Ts extends ReadonlyArray<Record<PropertyKey, unknown>> ? IsNever<RecordKeysOf<Ts>> extends true ? never : SimplifyObject<DeepMergeRecordProps<Ts, Fs, M>> : never;
type DeepMergeRecordProps<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = {
	[K in RequiredKeysOf<Ts>]: DeepMergeHKT<ValuesForKey<K, Ts>, Fs, M>;
} & {
	[K in OptionalKeysOf<Ts>]?: DeepMergeHKT<ValuesForKey<K, Ts>, Fs, M>;
};
type RequiredKeysOf<Ts extends ReadonlyArray<unknown>> = {
	[K in RecordKeysOf<Ts>]: OptionalForKey<K, Ts> extends true ? never : K;
}[RecordKeysOf<Ts>];
type OptionalKeysOf<Ts extends ReadonlyArray<unknown>> = {
	[K in RecordKeysOf<Ts>]: OptionalForKey<K, Ts> extends true ? K : never;
}[RecordKeysOf<Ts>];
type RecordKeysOf<Ts extends ReadonlyArray<unknown>> = {
	[I in keyof Ts]: RecordKeys<Ts[I]>;
}[number];
type RecordKeys<T> = IsNever<KnownKeys<T>> extends true ? keyof T : KnownKeys<T>;
type ValuesForKey<K extends PropertyKey, Ts extends ReadonlyArray<unknown>> = DeepMergeRecordPropertyMetaDefaultHKTHasOptionalOfKey<K, Ts> extends true ? DeepMergeRecordPropertyMetaDefaultHKTGetPossible<K, PresentMetasOfKey<K, Ts>>["values"] : DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptionalOfKey<K, Ts>;
type OptionalForKey<K extends PropertyKey, Ts extends ReadonlyArray<unknown>> = DeepMergeRecordPropertyMetaDefaultHKTGetOptionalOfKey<K, Ts>;
type DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptionalOfKey<K extends PropertyKey, Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
	infer Head,
	...infer Rest
] ? K extends keyof Head ? Rest extends ReadonlyArray<unknown> ? [
	Required<Head>[K],
	...DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptionalOfKey<K, Rest>
] : [
	Required<Head>[K]
] : Rest extends ReadonlyArray<unknown> ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptionalOfKey<K, Rest> : [
] : [
];
type DeepMergeRecordPropertyMetaDefaultHKTHasOptionalOfKey<K extends PropertyKey, Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
	infer Head,
	...infer Rest
] ? K extends keyof Head ? KeyIsOptional<K, Head> extends true ? true : Rest extends ReadonlyArray<unknown> ? DeepMergeRecordPropertyMetaDefaultHKTHasOptionalOfKey<K, Rest> : false : Rest extends ReadonlyArray<unknown> ? DeepMergeRecordPropertyMetaDefaultHKTHasOptionalOfKey<K, Rest> : false : false;
type DeepMergeRecordPropertyMetaDefaultHKTGetOptionalOfKey<K extends PropertyKey, Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
	infer Head,
	...infer Rest
] ? K extends keyof Head ? KeyIsOptional<K, Head> : Rest extends ReadonlyArray<unknown> ? DeepMergeRecordPropertyMetaDefaultHKTGetOptionalOfKey<K, Rest> : never : never;
type MetaOfKey<R, K extends PropertyKey> = K extends keyof R ? {
	key: K;
	value: Required<R>[K];
	optional: KeyIsOptional<K, R>;
} : never;
type PresentMetasOfKey<K extends PropertyKey, Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
	infer Head,
	...infer Rest
] ? K extends keyof Head ? Rest extends ReadonlyArray<unknown> ? [
	MetaOfKey<Head, K>,
	...PresentMetasOfKey<K, Rest>
] : [
	MetaOfKey<Head, K>
] : Rest extends ReadonlyArray<unknown> ? PresentMetasOfKey<K, Rest> : [
] : [
];
type DeepMergeRecordPropertyMetaDefaultHKTGetPossible<Key extends PropertyKey, Ts> = Ts extends readonly [
	RecordPropertyMeta,
	...ReadonlyArray<RecordPropertyMeta>
] ? {
	key: Key;
	values: DeepMergeRecordPropertyMetaDefaultHKTGetValues<Ts>;
	optional: DeepMergeRecordPropertyMetaDefaultHKTGetOptional<Ts>;
} : never;
type DeepMergeRecordPropertyMetaDefaultHKTGetValues<Ts extends readonly [
	RecordPropertyMeta,
	...ReadonlyArray<RecordPropertyMeta>
]> = DeepMergeRecordPropertyMetaDefaultHKTHasOptional<Ts> extends true ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper<Ts, [
], false> : DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptional<Ts>;
type DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptional<Ts extends readonly [
	RecordPropertyMeta,
	...ReadonlyArray<RecordPropertyMeta>
]> = Ts extends readonly [
	infer Head,
	...infer Rest
] ? Rest extends readonly [
	RecordPropertyMeta,
	...ReadonlyArray<RecordPropertyMeta>
] ? [
	Head extends {
		value: infer V;
	} ? V : never,
	...DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptional<Rest>
] : [
	Head extends {
		value: infer V;
	} ? V : never
] : never;
type DeepMergeRecordPropertyMetaDefaultHKTHasOptional<Ts extends readonly [
	RecordPropertyMeta,
	...ReadonlyArray<RecordPropertyMeta>
]> = {
	[I in keyof Ts]: Ts[I] extends {
		optional: true;
	} ? true : false;
}[number] extends false ? false : true;
type DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper<Ts extends readonly [
	RecordPropertyMeta,
	...ReadonlyArray<RecordPropertyMeta>
], Acc extends ReadonlyArray<unknown>, AccOptional extends boolean> = Ts extends [
	...infer Rest,
	{
		value: infer V;
		optional: infer O extends boolean;
	}
] ? AccOptional extends true ? Acc extends readonly [
	infer Head,
	...infer AccRest
] ? Rest extends readonly [
	RecordPropertyMeta,
	...ReadonlyArray<RecordPropertyMeta>
] ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper<Rest, [
	PreciseOrUnion<V, Head>,
	...AccRest
], O> : [
	PreciseOrUnion<V, Head>,
	...AccRest
] : Rest extends readonly [
	RecordPropertyMeta,
	...ReadonlyArray<RecordPropertyMeta>
] ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper<Rest, [
	V,
	...Acc
], O> : [
	V,
	...Acc
] : Rest extends readonly [
	RecordPropertyMeta,
	...ReadonlyArray<RecordPropertyMeta>
] ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper<Rest, [
	V,
	...Acc
], O> : [
	V,
	...Acc
] : never;
type DeepMergeRecordPropertyMetaDefaultHKTGetOptional<Ts extends readonly [
	RecordPropertyMeta,
	...ReadonlyArray<RecordPropertyMeta>
]> = Ts extends readonly [
	infer First,
	...ReadonlyArray<RecordPropertyMeta>
] ? First extends {
	optional: infer O extends boolean;
} ? O : never : never;
/**
 * Deep merge arrays.
 */
export type DeepMergeArraysDefaultHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeArraysDefaultHKTHelper<Ts, Fs, M, [
]>;
type DeepMergeArraysDefaultHKTHelper<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M, Acc extends ReadonlyArray<unknown>> = Ts extends readonly [
	infer Head extends ReadonlyArray<unknown>,
	...infer Rest
] ? Rest extends readonly [
	ReadonlyArray<unknown>,
	...ReadonlyArray<ReadonlyArray<unknown>>
] ? DeepMergeArraysDefaultHKTHelper<Rest, Fs, M, [
	...Acc,
	...Head
]> : [
	...Acc,
	...Head
] : never;
/**
 * Deep merge sets.
 */
export type DeepMergeSetsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Set<UnionSetValues<Ts>>;
/**
 * Deep merge maps.
 */
export type DeepMergeMapsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Map<UnionMapKeys<Ts>, UnionMapValues<Ts>>;
/**
 * Filter out undefined values.
 */
export type DeepMergeFilterValuesDefaultHKT<Ts extends ReadonlyArray<unknown>> = DeepMergeFilterValuesShortcut<Ts> extends true ? Ts : FilterOut<Ts, undefined>;
type DeepMergeFilterValuesShortcut<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
	infer Head,
	...infer Rest
] ? Is<Head, undefined> extends true ? false : Rest extends ReadonlyArray<unknown> ? DeepMergeFilterValuesShortcut<Rest> : true : true;
/**
 * Get the merge functions with defaults apply from the given subset.
 */
export type GetDeepMergeFunctionsURIs<PMF extends Partial<DeepMergeFunctionsURIs>> = Readonly<{
	DeepMergeRecordsURI: PMF["DeepMergeRecordsURI"] extends keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeRecordsURI"] : DeepMergeRecordsDefaultURI;
	DeepMergeArraysURI: PMF["DeepMergeArraysURI"] extends keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeArraysURI"] : DeepMergeArraysDefaultURI;
	DeepMergeSetsURI: PMF["DeepMergeSetsURI"] extends keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeSetsURI"] : DeepMergeSetsDefaultURI;
	DeepMergeMapsURI: PMF["DeepMergeMapsURI"] extends keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeMapsURI"] : DeepMergeMapsDefaultURI;
	DeepMergeOthersURI: PMF["DeepMergeOthersURI"] extends keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeOthersURI"] : DeepMergeLeafURI;
	DeepMergeFilterValuesURI: PMF["DeepMergeFilterValuesURI"] extends keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeFilterValuesURI"] : DeepMergeFilterValuesDefaultURI;
}>;
/**
 * Deep merge circular references.
 */
export type DeepMergeCircularReferencesDefaultHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeLeaf<Ts, Fs, M>;
declare function mergeArrays<Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils?: U, meta?: M): DeepMergeArraysDefaultHKT<Ts, Fs, M>;
declare function mergeSets<Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils?: U, meta?: M): DeepMergeSetsDefaultHKT<Ts>;
declare function mergeOthers<Ts extends ReadonlyArray<unknown>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils?: U, meta?: M): unknown;
declare function mergeArraysInto<Ts extends ReadonlyArray<ReadonlyArray<unknown>>>(mut_target: DeepMergeValueReference<unknown[]>, values: Ts): void;
declare function mergeSetsInto<Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>>(mut_target: DeepMergeValueReference<Set<unknown>>, values: Ts): void;
declare function mergeOthersInto<Ts extends ReadonlyArray<unknown>>(mut_target: DeepMergeValueReference<unknown>, values: Ts): void;
/**
 * The default merge functions.
 */
type MergeFunctions<M extends DeepMergeMetaData = DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = {
	mergeRecords: <Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined) => void;
	mergeArrays: typeof mergeArraysInto;
	mergeSets: typeof mergeSetsInto;
	mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<Map<unknown, unknown>>, values: Ts, utils: U, meta: M | undefined) => void;
	mergeCircularReferences: <Ts extends ReadonlyArray<object>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<unknown>, values: Ts, utils: U, meta: M | undefined) => void;
	mergeOthers: typeof mergeOthersInto;
};
/**
 * The default merge functions.
 */
type MergeFunctions$1<M extends DeepMergeMetaData = DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = {
	mergeRecords: <Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs>(values: Ts, utils: U, meta: M) => DeepMergeRecordsDefaultHKT<Ts, Fs, M>;
	mergeArrays: typeof mergeArrays;
	mergeSets: typeof mergeSets;
	mergeMaps: <Ts extends ReadonlyArray<ReadonlyMap<unknown, unknown>>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs>(values: Ts, utils: U, meta: M) => DeepMergeMapsDefaultHKT<Ts>;
	mergeCircularReferences: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs>(values: Ts, cyclicDepths: ReadonlyArray<number>, utils: U, meta: M) => DeepMergeCircularReferencesDefaultHKT<Ts, Fs, M>;
	mergeOthers: typeof mergeOthers;
};
/**
 * The options the user can pass to customize deepmerge.
 */
export type DeepMergeOptions<in out M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends Readonly<Record<PropertyKey, unknown>> = {}> = Partial<DeepMergeOptionsFull<M, MI & DeepMergeMergeInfo>>;
/**
 * The options the user can pass to customize deepmergeFastUnsafe.
 */
export type DeepMergeFastUnsafeOptions = Partial<Omit<DeepMergeOptionsFull<undefined>, "metaDataUpdater" | "maxDepth" | "mergeCircularReferences">>;
/**
 * The options the user can pass to customize deepmergeInto.
 */
export type DeepMergeIntoOptions<in out M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends Readonly<Record<PropertyKey, unknown>> = {}> = Partial<DeepMergeIntoOptionsFull<M, MI & DeepMergeMergeInfo>>;
/**
 * The options the user can pass to customize deepmergeIntoFastUnsafe.
 */
export type DeepMergeIntoFastUnsafeOptions = Partial<Omit<DeepMergeIntoOptionsFull<undefined>, "metaDataUpdater" | "maxDepth" | "mergeCircularReferences">>;
type MetaDataUpdater<in out M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = (previousMeta: M | undefined, mergeInfo: Readonly<Partial<MI>>) => M;
type DeepMergeOptionsFull<in out M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = Readonly<{
	mergeRecords: DeepMergeFunctions<M, MI>["mergeRecords"] | false;
	mergeArrays: DeepMergeFunctions<M, MI>["mergeArrays"] | false;
	mergeMaps: DeepMergeFunctions<M, MI>["mergeMaps"] | false;
	mergeSets: DeepMergeFunctions<M, MI>["mergeSets"] | false;
	mergeCircularReferences: DeepMergeFunctions<M, MI>["mergeCircularReferences"] | false;
	mergeOthers: DeepMergeFunctions<M, MI>["mergeOthers"];
	metaDataUpdater: MetaDataUpdater<M, MI>;
	enableImplicitDefaultMerging: boolean;
	filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | false;
	/**
	 * The maximum depth to merge to. When reached, further nested objects will not be deeply merged.
	 * Useful for preventing stack exhaustion when merging untrusted input.
	 *
	 * @default 1000
	 */
	maxDepth: number;
}>;
type DeepMergeIntoOptionsFull<in out M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = Readonly<{
	mergeRecords: DeepMergeIntoFunctions<M, MI>["mergeRecords"] | false;
	mergeArrays: DeepMergeIntoFunctions<M, MI>["mergeArrays"] | false;
	mergeMaps: DeepMergeIntoFunctions<M, MI>["mergeMaps"] | false;
	mergeSets: DeepMergeIntoFunctions<M, MI>["mergeSets"] | false;
	mergeCircularReferences: DeepMergeIntoFunctions<M, MI>["mergeCircularReferences"] | false;
	mergeOthers: DeepMergeIntoFunctions<M, MI>["mergeOthers"];
	metaDataUpdater: MetaDataUpdater<M, MI>;
	filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | false;
	/**
	 * The maximum depth to merge to. When reached, further nested objects will not be deeply merged.
	 * Useful for preventing stack exhaustion when merging untrusted input.
	 *
	 * @default 1000
	 */
	maxDepth: number;
}>;
/**
 * An object that has a reference to a value being merged into.
 */
export type DeepMergeValueReference<T> = {
	value: T;
};
type DeepMergeUtilityFunctions<in M extends DeepMergeMetaData = DeepMergeBuiltInMetaData> = Readonly<{
	filterValues: <Ts extends ReadonlyArray<unknown>>(values: Ts, meta: M | undefined) => ReadonlyArray<unknown>;
}>;
type DeepMergeFunctions<in M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = Readonly<{
	mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U extends DeepMergeUtils<M, MI>>(values: Ts, utils: U, meta: M | undefined) => unknown;
	mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeUtils<M, MI>>(values: Ts, utils: U, meta: M | undefined) => unknown;
	mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeUtils<M, MI>>(values: Ts, utils: U, meta: M | undefined) => unknown;
	mergeSets: <Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeUtils<M, MI>>(values: Ts, utils: U, meta: M | undefined) => unknown;
	mergeCircularReferences: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeUtils<M, MI>>(values: Ts, cyclicDepths: ReadonlyArray<number>, utils: U, meta: M | undefined) => unknown;
	mergeOthers: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeUtils<M, MI>>(values: Ts, utils: U, meta: M | undefined) => unknown;
}>;
type DeepMergeIntoFunctionsReturnType = void | symbol;
type DeepMergeIntoFunctions<in M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = Readonly<{
	mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
	mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<unknown[]>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
	mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<Map<unknown, unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
	mergeSets: <Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<Set<unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
	mergeCircularReferences: <Ts extends ReadonlyArray<object>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<unknown>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
	mergeOthers: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<unknown>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
}>;
/**
 * The utils provided to the merge functions.
 */
export type DeepMergeUtils<in out M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = Readonly<{
	mergeFunctions: DeepMergeFunctions<M, MI>;
	defaultMergeFunctions: MergeFunctions$1<M, MI>;
	metaDataUpdater: MetaDataUpdater<M, MI>;
	deepmerge: <Ts extends ReadonlyArray<unknown>>(...values: Ts) => unknown;
	useImplicitDefaultMerging: boolean;
	filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | undefined;
	maxDepth: number | undefined;
	actions: Readonly<{
		defaultMerge: symbol;
		skip: symbol;
	}>;
}>;
/**
 * The utils provided to the merge functions.
 */
export type DeepMergeIntoUtils<in out M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = Readonly<{
	mergeFunctions: DeepMergeIntoFunctions<M, MI>;
	defaultMergeFunctions: MergeFunctions<M, MI>;
	metaDataUpdater: MetaDataUpdater<M, MI>;
	deepmergeInto: <Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...values: Ts) => void;
	filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | undefined;
	maxDepth: number | undefined;
	actions: Readonly<{
		defaultMerge: symbol;
	}>;
}>;
/**
 * The utils provided to the merge functions in fast mode.
 */
export type DeepMergeFastUnsafeUtils = DeepMergeUtils<undefined>;
/**
 * The utils provided to the into merge functions in fast mode.
 */
export type DeepMergeIntoFastUnsafeUtils = DeepMergeIntoUtils<undefined>;
/**
 * Deeply merge objects.
 *
 * @param objects - The objects to merge.
 * @returns The merged result.
 */
export declare function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(...objects: readonly [
	...Ts
]): DeepMergeHKT<Ts, DeepMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>;
/**
 * Used by the default `deepmerge` function.
 *
 * @internal
 * @returns A customized deepmerge function.
 */
export declare function deepmergeCustom(): <Ts extends ReadonlyArray<unknown>>(...objects: Ts) => DeepMergeHKT<Ts, DeepMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>;
/**
 * Deeply merge two or more objects using the given options.
 *
 * @param options - The options on how to customize the merge function.
 * @returns A customized deepmerge function.
 */
export declare function deepmergeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeFunctionsURIs> = {}>(options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeMergeInfo>): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, DeepMergeBuiltInMetaData>;
/**
 * Deeply merge two or more objects using the given options and meta data.
 *
 * @param options - The options on how to customize the merge function.
 * @param rootMetaData - The meta data passed to the root items being merged.
 * @returns A customized deepmerge function.
 * @example
 * ```ts
 * import { deepmergeCustom } from "deepmerge-ts";
 *
 * // Merge arrays by concatenation instead of last-wins.
 * const merge = deepmergeCustom({
 *   mergeArrays: (values) => values.flat(),
 * });
 *
 * const result = merge({ tags: ["a"] }, { tags: ["b"] });
 * // => { tags: ["a", "b"] }
 * ```
 */
export declare function deepmergeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeFunctionsURIs> = {}, MetaData extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MetaMetaData extends DeepMergeMergeInfo = DeepMergeMergeInfo>(options: DeepMergeOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, MetaData>;
/**
 * Deeply merge objects using a high-performance strategy.
 *
 * Differences from `deepmerge` (standard version):
 * - **No circular reference detection:** Does not track object hierarchies or detect cyclic references. Circular structures will result in a stack overflow.
 * - **No recursion depth limits:** Does not enforce a `maxDepth` limit (standard version defaults to 1000).
 * - **No metadata tracking:** Metadata updates and custom metadata tracking are bypassed, avoiding metadata object allocations.
 * - **No prototype pollution interception:** Assumes trusted data and directly assigns properties.
 *
 * @warning Only use this function with **trusted, non-circular data**.
 * Using this function with untrusted user data can result in serious security vulnerabilities:
 * - **Prototype pollution:** Prototype pollution safeguards are omitted for speed; malicious keys like `__proto__` can pollute object prototypes.
 * - **Denial of Service (DoS):** Circular reference detection and recursion depth limits are disabled; cyclic or deeply nested input will cause infinite recursion and crash via stack overflow.
 * @param objects - The objects to merge.
 * @returns The merged result.
 */
export declare function deepmergeFastUnsafe<Ts extends Readonly<ReadonlyArray<unknown>>>(...objects: readonly [
	...Ts
]): DeepMergeHKT<Ts, DeepMergeFunctionsDefaultURIs, undefined>;
/**
 * Used by the default `deepmergeFastUnsafe` function.
 *
 * @internal
 * @returns A customized deepmergeFastUnsafe function.
 */
export declare function deepmergeFastUnsafeCustom(): <Ts extends ReadonlyArray<unknown>>(...objects: Ts) => DeepMergeHKT<Ts, DeepMergeFunctionsDefaultURIs, undefined>;
/**
 * Deeply merge two or more objects using the given options and a high-performance strategy.
 *
 * Differences from `deepmergeCustom` (standard version):
 * - **No circular reference detection:** Does not track object hierarchies or detect cyclic references. Circular structures will result in a stack overflow.
 * - **No recursion depth limits:** Does not enforce a `maxDepth` limit (standard version defaults to 1000).
 * - **No metadata tracking:** Metadata updates and custom metadata tracking are bypassed, avoiding metadata object allocations.
 * - **No prototype pollution interception:** Assumes trusted data and directly assigns properties.
 *
 * @warning Only use this function with **trusted, non-circular data**.
 * Using this function with untrusted user data can result in serious security vulnerabilities:
 * - **Prototype pollution:** Prototype pollution safeguards are omitted for speed; malicious keys like `__proto__` can pollute object prototypes.
 * - **Denial of Service (DoS):** Circular reference detection and recursion depth limits are disabled; cyclic or deeply nested input will cause infinite recursion and crash via stack overflow.
 * @param options - The options on how to customize the merge function.
 * @returns A customized deepmergeFastUnsafe function.
 */
export declare function deepmergeFastUnsafeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeFunctionsURIs> = {}>(options: DeepMergeFastUnsafeOptions): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, undefined>;
/**
 * Deeply merge objects into a target.
 *
 * @param target - This object will be mutated with the merge result.
 * @param objects - The objects to merge into the target.
 */
export declare function deepmergeInto<T extends object>(target: T, ...objects: ReadonlyArray<T>): void;
/**
 * Deeply merge objects into a target.
 *
 * @param target - This object will be mutated with the merge result.
 * @param objects - The objects to merge into the target.
 */
export declare function deepmergeInto<Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts): asserts target is SimplifyObject<Target & DeepMergeHKT<[
	Target,
	...Ts
], DeepMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>>;
/**
 * Used by the default `deepmergeInto` function.
 *
 * @internal
 * @returns A customized deepmergeInto function.
 */
export declare function deepmergeIntoCustom(): <Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts) => void;
/**
 * Deeply merge two or more objects using the given options.
 *
 * @param options - The options on how to customize the merge function.
 * @returns A customized deepmergeInto function.
 */
export declare function deepmergeIntoCustom<BaseTs = unknown>(options: DeepMergeIntoOptions<DeepMergeBuiltInMetaData, DeepMergeMergeInfo>): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(target: Target, ...objects: Ts) => void;
/**
 * Deeply merge two or more objects into a target using the given options and meta data.
 *
 * @param options - The options on how to customize the merge function.
 * @param rootMetaData - The meta data passed to the root items being merged.
 * @returns A customized deepmergeInto function.
 * @example
 * ```ts
 * import { deepmergeIntoCustom } from "deepmerge-ts";
 *
 * // Merge arrays by union instead of by concatenation.
 * const mergeInto = deepmergeIntoCustom({
 *   mergeArrays: (target, values) => {
 *     const set = new Set(target.value);
 *     for (const arr of values.slice(1)) {
 *       for (const item of arr) {
 *         set.add(item);
 *       }
 *     }
 *     target.value = [...set];
 *   },
 * });
 *
 * const target = { tags: ["a"] };
 * mergeInto(target, { tags: ["a", "b"] });
 * // => { tags: ["a", "b"] }
 * ```
 */
export declare function deepmergeIntoCustom<BaseTs = unknown, MetaData extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MetaMetaData extends DeepMergeMergeInfo = DeepMergeMergeInfo>(options: DeepMergeIntoOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(target: Target, ...objects: Ts) => void;
/**
 * Deeply merge objects into a target using a high-performance strategy.
 *
 * Differences from `deepmergeInto` (standard version):
 * - **No circular reference detection:** Does not track object hierarchies or detect cyclic references. Circular structures will result in a stack overflow.
 * - **No recursion depth limits:** Does not enforce a `maxDepth` limit (standard version defaults to 1000).
 * - **No metadata tracking:** Metadata updates and custom metadata tracking are bypassed, avoiding metadata object allocations.
 * - **No prototype pollution interception:** Assumes trusted data and directly assigns properties.
 *
 * @warning Only use this function with **trusted, non-circular data**.
 * Using this function with untrusted user data can result in serious security vulnerabilities:
 * - **Prototype pollution:** Prototype pollution safeguards are omitted for speed; malicious keys like `__proto__` can pollute object prototypes.
 * - **Denial of Service (DoS):** Circular reference detection and recursion depth limits are disabled; cyclic or deeply nested input will cause infinite recursion and crash via stack overflow.
 * @param target - This object will be mutated with the merge result.
 * @param objects - The objects to merge into the target.
 */
export declare function deepmergeIntoFastUnsafe<T extends object>(target: T, ...objects: ReadonlyArray<T>): void;
/**
 * Deeply merge objects into a target using a high-performance strategy.
 *
 * Differences from `deepmergeInto` (standard version):
 * - **No circular reference detection:** Does not track object hierarchies or detect cyclic references. Circular structures will result in a stack overflow.
 * - **No recursion depth limits:** Does not enforce a `maxDepth` limit (standard version defaults to 1000).
 * - **No metadata tracking:** Metadata updates and custom metadata tracking are bypassed, avoiding metadata object allocations.
 * - **No prototype pollution interception:** Assumes trusted data and directly assigns properties.
 *
 * @warning Only use this function with **trusted, non-circular data**.
 * Using this function with untrusted user data can result in serious security vulnerabilities:
 * - **Prototype pollution:** Prototype pollution safeguards are omitted for speed; malicious keys like `__proto__` can pollute object prototypes.
 * - **Denial of Service (DoS):** Circular reference detection and recursion depth limits are disabled; cyclic or deeply nested input will cause infinite recursion and crash via stack overflow.
 * @param target - This object will be mutated with the merge result.
 * @param objects - The objects to merge into the target.
 */
export declare function deepmergeIntoFastUnsafe<Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts): asserts target is SimplifyObject<Target & DeepMergeHKT<[
	Target,
	...Ts
], DeepMergeFunctionsDefaultURIs, undefined>>;
/**
 * Used by the default `deepmergeIntoFastUnsafe` function.
 *
 * @internal
 * @returns A customized deepmergeIntoFastUnsafe function.
 */
export declare function deepmergeIntoFastUnsafeCustom(): <Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts) => void;
/**
 * Deeply merge two or more objects into a target using the given options and a high-performance strategy.
 *
 * Differences from `deepmergeIntoCustom` (standard version):
 * - **No circular reference detection:** Does not track object hierarchies or detect cyclic references. Circular structures will result in a stack overflow.
 * - **No recursion depth limits:** Does not enforce a `maxDepth` limit (standard version defaults to 1000).
 * - **No metadata tracking:** Metadata updates and custom metadata tracking are bypassed, avoiding metadata object allocations.
 * - **No prototype pollution interception:** Assumes trusted data and directly assigns properties.
 *
 * @warning Only use this function with **trusted, non-circular data**.
 * Using this function with untrusted user data can result in serious security vulnerabilities:
 * - **Prototype pollution:** Prototype pollution safeguards are omitted for speed; malicious keys like `__proto__` can pollute object prototypes.
 * - **Denial of Service (DoS):** Circular reference detection and recursion depth limits are disabled; cyclic or deeply nested input will cause infinite recursion and crash via stack overflow.
 * @param options - The options on how to customize the merge function.
 * @returns A customized deepmergeIntoFastUnsafe function.
 */
export declare function deepmergeIntoFastUnsafeCustom<BaseTs = unknown>(options: DeepMergeIntoFastUnsafeOptions): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(target: Target, ...objects: Ts) => void;
/**
 * The different types of objects deepmerge-ts support.
 */
export declare const enum ObjectType {
	NOT = 0,
	RECORD = 1,
	ARRAY = 2,
	SET = 3,
	MAP = 4,
	OTHER = 5
}
/**
 * Get the type of the given object.
 *
 * @param object - The object to get the type of.
 * @returns The type of the given object.
 */
export declare function getObjectType(object: unknown): ObjectType;
/**
 * Get the keys of the given object(s) including symbol keys.
 * If an array is given, the keys of all the objects within the array are returned.
 *
 * Note: Only keys to enumerable properties are returned.
 *
 * @deprecated Use `getKeysOfObjects` instead.
 * @param objects - An array of objects to get the keys of.
 * @returns A set containing all the keys of all the given objects.
 */
export declare const getKeys: typeof getKeysOfObjects;
/**
 * Get the keys of the given objects including symbol keys.
 *
 * Note: Only keys to enumerable properties are returned.
 *
 * @param objects - An array of objects to get the keys of.
 * @returns A set containing all the keys of all the given objects.
 */
export declare function getKeysOfObjects(objects: ReadonlyArray<object>): Set<PropertyKey>;
/**
 * Does the given object have the given property.
 *
 * @param object - The object to test.
 * @param property - The property to test.
 * @returns Whether the object has the property.
 */
export declare function objectHasProperty(object: object, property: PropertyKey): boolean;
/**
 * The fast default merge functions.
 */
type MergeFunctionsFast = {
	mergeRecords: typeof mergeRecordsIntoFast;
	mergeArrays: typeof mergeArraysInto;
	mergeSets: typeof mergeSetsInto;
	mergeMaps: typeof mergeMapsIntoFast;
	mergeOthers: typeof mergeOthersInto;
};
declare function mergeRecordsIntoFast<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeIntoUtils<M, MI>, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(mut_target: DeepMergeValueReference<Record<PropertyKey, unknown>>, values: Ts, utils: U): void;
declare function mergeMapsIntoFast<Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeIntoUtils<M, MI>, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(mut_target: DeepMergeValueReference<Map<unknown, unknown>>, values: Ts, utils: U): void;
/**
 * The fast default merge functions.
 */
type MergeFunctionsFast$1 = {
	mergeRecords: typeof mergeRecordsFast;
	mergeArrays: typeof mergeArrays;
	mergeSets: typeof mergeSets;
	mergeMaps: typeof mergeMapsFast;
	mergeOthers: typeof mergeOthers;
};
declare function mergeRecordsFast<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils: U): DeepMergeRecordsDefaultHKT<Ts, Fs, M>;
declare function mergeMapsFast<Ts extends ReadonlyArray<ReadonlyMap<unknown, unknown>>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils: U): DeepMergeMapsDefaultHKT<Ts>;

export {
	MergeFunctions as DeepMergeIntoFunctionsDefaults,
	MergeFunctions$1 as DeepMergeFunctionsDefaults,
	MergeFunctionsFast as DeepMergeIntoFunctionsDefaultsFastUnsafe,
	MergeFunctionsFast$1 as DeepMergeFunctionsDefaultsFastUnsafe,
};

export {};