// Generated by dts-bundle-generator v9.5.1 type SimplifyObject = { [K in keyof T]: T[K]; } & {}; type Is = [ T1 ] extends [ T2 ] ? true : false; type IsNever = Is; type IsUnion = T extends unknown ? ([ U ] extends [ T ] ? false : true) : never; type And = T1 extends false ? false : T2; type Not = T extends true ? false : true; type KeyIsOptional>> = O extends Record ? false : true; type IsRecord = And>, T extends Readonly> ? true : false>; type IsArray = And>, T extends ReadonlyArray ? true : false>; type IsSet = And>, T extends Readonly> ? true : false>; type IsMap = And>, T extends Readonly> ? true : false>; type UnionSetValues> = UnionSetValuesHelper; type UnionSetValuesHelper, Acc> = Ts extends readonly [ infer Head, ...infer Rest ] ? Head extends Readonly> ? Rest extends ReadonlyArray ? UnionSetValuesHelper : Acc | V1 : never : Acc; type UnionMapKeys> = UnionMapKeysHelper; type UnionMapKeysHelper, Acc> = Ts extends readonly [ infer Head, ...infer Rest ] ? Head extends Readonly> ? Rest extends readonly [ ] ? Acc | K1 : UnionMapKeysHelper : never : Acc; type UnionMapValues> = UnionMapValuesHelper; type UnionMapValuesHelper, Acc> = Ts extends readonly [ infer Head, ...infer Rest ] ? Head extends Readonly> ? Rest extends readonly [ ] ? Acc | V1 : UnionMapValuesHelper : never : Acc; type PreciseOrUnion = A extends B ? A : B extends A ? B : A | B; /** * Filter out U from a tuple. */ export type FilterOut, U> = FilterOutHelper; type FilterOutHelper, U, Acc extends ReadonlyArray> = T extends readonly [ ] ? Acc : T extends readonly [ infer Head, ...infer Rest ] ? Is extends true ? FilterOutHelper : FilterOutHelper : T; type IsTuple> = T extends readonly [ ] ? true : T extends readonly [ unknown, ...ReadonlyArray ] ? true : false; type UnionToTuple = [ ], L = LastOf> = IsNever extends true ? Acc : UnionToTuple, [ L, ...Acc ]>; type UnionToIntersection = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never; type LastOf = UnionToIntersection T : never> extends () => infer R ? R : never; type TupleTupleToTupleUnion>> = { [I in keyof T]: TupleToUnion; }; type TupleToUnion> = T extends readonly [ ] ? never : T extends readonly [ infer Head, ...infer Rest ] ? Head | TupleToUnion : never; type AssertType = T extends Expected ? T : never; /** * Mapping of merge function URIs to the merge function type. */ export interface DeepMergeFunctionURItoKind, Fs extends DeepMergeFunctionsURIs, in out M> { readonly DeepMergeLeafURI: DeepMergeLeaf; readonly DeepMergeRecordsDefaultURI: DeepMergeRecordsDefaultHKT; readonly DeepMergeArraysDefaultURI: DeepMergeArraysDefaultHKT; readonly DeepMergeSetsDefaultURI: DeepMergeSetsDefaultHKT; readonly DeepMergeMapsDefaultURI: DeepMergeMapsDefaultHKT; readonly DeepMergeCircularReferencesURI: DeepMergeCircularReferencesDefaultHKT; readonly DeepMergeFilterValuesDefaultURI: DeepMergeFilterValuesDefaultHKT; readonly DeepMergeNoFilteringURI: Ts; } type DeepMergeFunctionKind, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionURItoKind[URI]; type DeepMergeFunctionURIs = keyof DeepMergeFunctionURItoKind, 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, Fs extends DeepMergeFunctionsURIs, M> = IsTuple extends true ? Ts extends readonly [ ] ? undefined : DeepMergeSameTypeShortcut extends true ? DeepMergeSameTypeElement : DeepMergeHKTHelper, Fs, M> : unknown; type DeepMergeHKTHelper = Ts extends ReadonlyArray ? IsTuple extends true ? Ts extends readonly [ ] ? unknown : Ts extends readonly [ infer T1 ] ? T1 : DeepMergeDispatch> : unknown : never; type DeepMergeSameTypeShortcut, Fs extends DeepMergeFunctionsURIs> = Is extends true ? AllSameTypes extends true ? Ts extends readonly [ infer T1, ...ReadonlyArray ] ? DeepMergeSameTypeShortcutElement extends true ? true : false : false : false : false; type DeepMergeSameTypeShortcutElement = DeepMergeSameTypeValueSound extends true ? true : false; type DeepMergeSameTypeValueSound> = [ V ] extends [ Seen[number] ] ? false : IsUnion extends true ? false : undefined extends V ? false : V extends ReadonlyArray ? V extends unknown[] ? Not> : false : V extends ReadonlySet ? V extends Set ? true : false : V extends ReadonlyMap ? V extends Map ? true : false : V extends Readonly> ? DeepMergeSameTypeRecordSound : true; type DeepMergeSameTypeRecordSound> = { [K in keyof T]-?: IsReadonlyProperty extends true ? K : DeepMergeSameTypeValueSound[K], Seen> extends true ? never : K; }[keyof T] extends never ? true : false; type IsReadonlyProperty = (

() => P extends { [PK in K]: T[K]; } ? 1 : 2) extends

() => P extends { readonly [PK in K]: T[K]; } ? 1 : 2 ? true : false; type DeepMergeSameTypeElement> = Ts extends readonly [ infer T1, ...ReadonlyArray ] ? T1 : never; type AllSameTypes> = Ts extends readonly [ infer Head, ...infer Rest ] ? Rest extends ReadonlyArray ? RestIsSameAs : true : true; type RestIsSameAs, T> = Ts extends readonly [ infer Head, ...infer Rest ] ? And, Is> extends true ? Rest extends ReadonlyArray ? RestIsSameAs : true : false : true; type DeepMergeDispatch, Fs extends DeepMergeFunctionsURIs, M, Kind> = Kind extends "array" ? DeepMergeArraysHKT : Kind extends "map" ? DeepMergeMapsHKT : Kind extends "set" ? DeepMergeSetsHKT : Kind extends "record" ? DeepMergeRecordsHKT : DeepMergeOthersHKT; type DeepMergeElementKind = IsArray extends true ? "array" : IsMap extends true ? "map" : IsSet extends true ? "set" : IsRecord extends true ? "record" : "other"; type DeepMergeTupleKind> = DeepMergeKinds extends "array" ? "array" : DeepMergeKinds extends "map" ? "map" : DeepMergeKinds extends "set" ? "set" : DeepMergeKinds extends "record" ? "record" : "other"; type DeepMergeKinds> = { [I in keyof Ts]: DeepMergeElementKind; }[number]; type DeepMergeRecordsHKT, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind; type DeepMergeArraysHKT, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind; type DeepMergeSetsHKT, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind; type DeepMergeMapsHKT, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind; type DeepMergeOthersHKT, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind; type FilterValuesHKT, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind; /** * 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, Fs extends DeepMergeFunctionsURIs, M> = Ts extends readonly [ ] ? never : Ts extends readonly [ infer T ] ? T : Ts extends readonly [ ...infer Rest, infer Tail ] ? IsNever extends true ? Rest extends ReadonlyArray ? DeepMergeLeaf : never : DeepMergeLeafApplyFilter, TupleTupleToTupleUnion>, { [I in keyof Ts]: DeepMergeLeafElement; }>>>> : never; type DeepMergeLeafElement = Fs["DeepMergeFilterValuesURI"] extends DeepMergeFilterValuesDefaultURI ? [ E extends undefined ? never : E ] : FilterValuesHKT, Fs, M>; type DeepMergeLeafApplyFilter, Filtered extends ReadonlyArray> = Original extends readonly [ ...infer OriginalRest, infer OriginalTail ] ? Filtered extends readonly [ ...infer FilteredRest, infer FilteredTail ] ? OriginalTail extends FilteredTail ? FilteredTail : FilteredTail | DeepMergeLeafApplyFilter : never : never; type HierarchyValue = Readonly<{ key: unknown; parents: ReadonlyArray; values: ReadonlyArray; result: unknown; }>; type DeepMergeRootMetaData = undefined; /** * The built-in metadata type used by deepmerge. */ export type DeepMergeBuiltInMetaData = DeepMergeRootMetaData | (Partial & Readonly<{ hierarchy?: ReadonlyArray; }>); /** * 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; values: ReadonlyArray; 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 = keyof { [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: unknown; }; type RecordPropertyMeta = { key: Key; value: Value; optional: Optional; }; /** * Deep merge records. */ export type DeepMergeRecordsDefaultHKT, Fs extends DeepMergeFunctionsURIs, M> = Ts extends ReadonlyArray> ? IsNever> extends true ? never : SimplifyObject> : never; type DeepMergeRecordProps, Fs extends DeepMergeFunctionsURIs, M> = { [K in RequiredKeysOf]: DeepMergeHKT, Fs, M>; } & { [K in OptionalKeysOf]?: DeepMergeHKT, Fs, M>; }; type RequiredKeysOf> = { [K in RecordKeysOf]: OptionalForKey extends true ? never : K; }[RecordKeysOf]; type OptionalKeysOf> = { [K in RecordKeysOf]: OptionalForKey extends true ? K : never; }[RecordKeysOf]; type RecordKeysOf> = { [I in keyof Ts]: RecordKeys; }[number]; type RecordKeys = IsNever> extends true ? keyof T : KnownKeys; type ValuesForKey> = DeepMergeRecordPropertyMetaDefaultHKTHasOptionalOfKey extends true ? DeepMergeRecordPropertyMetaDefaultHKTGetPossible>["values"] : DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptionalOfKey; type OptionalForKey> = DeepMergeRecordPropertyMetaDefaultHKTGetOptionalOfKey; type DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptionalOfKey> = Ts extends readonly [ infer Head, ...infer Rest ] ? K extends keyof Head ? Rest extends ReadonlyArray ? [ Required[K], ...DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptionalOfKey ] : [ Required[K] ] : Rest extends ReadonlyArray ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptionalOfKey : [ ] : [ ]; type DeepMergeRecordPropertyMetaDefaultHKTHasOptionalOfKey> = Ts extends readonly [ infer Head, ...infer Rest ] ? K extends keyof Head ? KeyIsOptional extends true ? true : Rest extends ReadonlyArray ? DeepMergeRecordPropertyMetaDefaultHKTHasOptionalOfKey : false : Rest extends ReadonlyArray ? DeepMergeRecordPropertyMetaDefaultHKTHasOptionalOfKey : false : false; type DeepMergeRecordPropertyMetaDefaultHKTGetOptionalOfKey> = Ts extends readonly [ infer Head, ...infer Rest ] ? K extends keyof Head ? KeyIsOptional : Rest extends ReadonlyArray ? DeepMergeRecordPropertyMetaDefaultHKTGetOptionalOfKey : never : never; type MetaOfKey = K extends keyof R ? { key: K; value: Required[K]; optional: KeyIsOptional; } : never; type PresentMetasOfKey> = Ts extends readonly [ infer Head, ...infer Rest ] ? K extends keyof Head ? Rest extends ReadonlyArray ? [ MetaOfKey, ...PresentMetasOfKey ] : [ MetaOfKey ] : Rest extends ReadonlyArray ? PresentMetasOfKey : [ ] : [ ]; type DeepMergeRecordPropertyMetaDefaultHKTGetPossible = Ts extends readonly [ RecordPropertyMeta, ...ReadonlyArray ] ? { key: Key; values: DeepMergeRecordPropertyMetaDefaultHKTGetValues; optional: DeepMergeRecordPropertyMetaDefaultHKTGetOptional; } : never; type DeepMergeRecordPropertyMetaDefaultHKTGetValues ]> = DeepMergeRecordPropertyMetaDefaultHKTHasOptional extends true ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper : DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptional; type DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptional ]> = Ts extends readonly [ infer Head, ...infer Rest ] ? Rest extends readonly [ RecordPropertyMeta, ...ReadonlyArray ] ? [ Head extends { value: infer V; } ? V : never, ...DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptional ] : [ Head extends { value: infer V; } ? V : never ] : never; type DeepMergeRecordPropertyMetaDefaultHKTHasOptional ]> = { [I in keyof Ts]: Ts[I] extends { optional: true; } ? true : false; }[number] extends false ? false : true; type DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper ], Acc extends ReadonlyArray, 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 ] ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper, ...AccRest ], O> : [ PreciseOrUnion, ...AccRest ] : Rest extends readonly [ RecordPropertyMeta, ...ReadonlyArray ] ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper : [ V, ...Acc ] : Rest extends readonly [ RecordPropertyMeta, ...ReadonlyArray ] ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper : [ V, ...Acc ] : never; type DeepMergeRecordPropertyMetaDefaultHKTGetOptional ]> = Ts extends readonly [ infer First, ...ReadonlyArray ] ? First extends { optional: infer O extends boolean; } ? O : never : never; /** * Deep merge arrays. */ export type DeepMergeArraysDefaultHKT, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeArraysDefaultHKTHelper; type DeepMergeArraysDefaultHKTHelper, Fs extends DeepMergeFunctionsURIs, M, Acc extends ReadonlyArray> = Ts extends readonly [ infer Head extends ReadonlyArray, ...infer Rest ] ? Rest extends readonly [ ReadonlyArray, ...ReadonlyArray> ] ? DeepMergeArraysDefaultHKTHelper : [ ...Acc, ...Head ] : never; /** * Deep merge sets. */ export type DeepMergeSetsDefaultHKT> = Set>; /** * Deep merge maps. */ export type DeepMergeMapsDefaultHKT> = Map, UnionMapValues>; /** * Filter out undefined values. */ export type DeepMergeFilterValuesDefaultHKT> = DeepMergeFilterValuesShortcut extends true ? Ts : FilterOut; type DeepMergeFilterValuesShortcut> = Ts extends readonly [ infer Head, ...infer Rest ] ? Is extends true ? false : Rest extends ReadonlyArray ? DeepMergeFilterValuesShortcut : true : true; /** * Get the merge functions with defaults apply from the given subset. */ export type GetDeepMergeFunctionsURIs> = Readonly<{ DeepMergeRecordsURI: PMF["DeepMergeRecordsURI"] extends keyof DeepMergeFunctionURItoKind, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeRecordsURI"] : DeepMergeRecordsDefaultURI; DeepMergeArraysURI: PMF["DeepMergeArraysURI"] extends keyof DeepMergeFunctionURItoKind, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeArraysURI"] : DeepMergeArraysDefaultURI; DeepMergeSetsURI: PMF["DeepMergeSetsURI"] extends keyof DeepMergeFunctionURItoKind, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeSetsURI"] : DeepMergeSetsDefaultURI; DeepMergeMapsURI: PMF["DeepMergeMapsURI"] extends keyof DeepMergeFunctionURItoKind, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeMapsURI"] : DeepMergeMapsDefaultURI; DeepMergeOthersURI: PMF["DeepMergeOthersURI"] extends keyof DeepMergeFunctionURItoKind, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeOthersURI"] : DeepMergeLeafURI; DeepMergeFilterValuesURI: PMF["DeepMergeFilterValuesURI"] extends keyof DeepMergeFunctionURItoKind, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeFilterValuesURI"] : DeepMergeFilterValuesDefaultURI; }>; /** * Deep merge circular references. */ export type DeepMergeCircularReferencesDefaultHKT, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeLeaf; declare function mergeArrays>, U extends DeepMergeUtils, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils?: U, meta?: M): DeepMergeArraysDefaultHKT; declare function mergeSets>>, U extends DeepMergeUtils, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils?: U, meta?: M): DeepMergeSetsDefaultHKT; declare function mergeOthers, U extends DeepMergeUtils, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils?: U, meta?: M): unknown; declare function mergeArraysInto>>(mut_target: DeepMergeValueReference, values: Ts): void; declare function mergeSetsInto>>>(mut_target: DeepMergeValueReference>, values: Ts): void; declare function mergeOthersInto>(mut_target: DeepMergeValueReference, values: Ts): void; /** * The default merge functions. */ type MergeFunctions = { mergeRecords: >, U extends DeepMergeIntoUtils>(mut_target: DeepMergeValueReference>, values: Ts, utils: U, meta: M | undefined) => void; mergeArrays: typeof mergeArraysInto; mergeSets: typeof mergeSetsInto; mergeMaps: >>, U extends DeepMergeIntoUtils>(mut_target: DeepMergeValueReference>, values: Ts, utils: U, meta: M | undefined) => void; mergeCircularReferences: , U extends DeepMergeIntoUtils>(mut_target: DeepMergeValueReference, values: Ts, utils: U, meta: M | undefined) => void; mergeOthers: typeof mergeOthersInto; }; /** * The default merge functions. */ type MergeFunctions$1 = { mergeRecords: >, U extends DeepMergeUtils, Fs extends DeepMergeFunctionsURIs>(values: Ts, utils: U, meta: M) => DeepMergeRecordsDefaultHKT; mergeArrays: typeof mergeArrays; mergeSets: typeof mergeSets; mergeMaps: >, U extends DeepMergeUtils, Fs extends DeepMergeFunctionsURIs>(values: Ts, utils: U, meta: M) => DeepMergeMapsDefaultHKT; mergeCircularReferences: , U extends DeepMergeUtils, Fs extends DeepMergeFunctionsURIs>(values: Ts, cyclicDepths: ReadonlyArray, utils: U, meta: M) => DeepMergeCircularReferencesDefaultHKT; mergeOthers: typeof mergeOthers; }; /** * The options the user can pass to customize deepmerge. */ export type DeepMergeOptions> = {}> = Partial>; /** * The options the user can pass to customize deepmergeFastUnsafe. */ export type DeepMergeFastUnsafeOptions = Partial, "metaDataUpdater" | "maxDepth" | "mergeCircularReferences">>; /** * The options the user can pass to customize deepmergeInto. */ export type DeepMergeIntoOptions> = {}> = Partial>; /** * The options the user can pass to customize deepmergeIntoFastUnsafe. */ export type DeepMergeIntoFastUnsafeOptions = Partial, "metaDataUpdater" | "maxDepth" | "mergeCircularReferences">>; type MetaDataUpdater = (previousMeta: M | undefined, mergeInfo: Readonly>) => M; type DeepMergeOptionsFull = Readonly<{ mergeRecords: DeepMergeFunctions["mergeRecords"] | false; mergeArrays: DeepMergeFunctions["mergeArrays"] | false; mergeMaps: DeepMergeFunctions["mergeMaps"] | false; mergeSets: DeepMergeFunctions["mergeSets"] | false; mergeCircularReferences: DeepMergeFunctions["mergeCircularReferences"] | false; mergeOthers: DeepMergeFunctions["mergeOthers"]; metaDataUpdater: MetaDataUpdater; enableImplicitDefaultMerging: boolean; filterValues: DeepMergeUtilityFunctions["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 = Readonly<{ mergeRecords: DeepMergeIntoFunctions["mergeRecords"] | false; mergeArrays: DeepMergeIntoFunctions["mergeArrays"] | false; mergeMaps: DeepMergeIntoFunctions["mergeMaps"] | false; mergeSets: DeepMergeIntoFunctions["mergeSets"] | false; mergeCircularReferences: DeepMergeIntoFunctions["mergeCircularReferences"] | false; mergeOthers: DeepMergeIntoFunctions["mergeOthers"]; metaDataUpdater: MetaDataUpdater; filterValues: DeepMergeUtilityFunctions["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 = { value: T; }; type DeepMergeUtilityFunctions = Readonly<{ filterValues: >(values: Ts, meta: M | undefined) => ReadonlyArray; }>; type DeepMergeFunctions = Readonly<{ mergeRecords: >>, U extends DeepMergeUtils>(values: Ts, utils: U, meta: M | undefined) => unknown; mergeArrays: >, U extends DeepMergeUtils>(values: Ts, utils: U, meta: M | undefined) => unknown; mergeMaps: >>, U extends DeepMergeUtils>(values: Ts, utils: U, meta: M | undefined) => unknown; mergeSets: >>, U extends DeepMergeUtils>(values: Ts, utils: U, meta: M | undefined) => unknown; mergeCircularReferences: , U extends DeepMergeUtils>(values: Ts, cyclicDepths: ReadonlyArray, utils: U, meta: M | undefined) => unknown; mergeOthers: , U extends DeepMergeUtils>(values: Ts, utils: U, meta: M | undefined) => unknown; }>; type DeepMergeIntoFunctionsReturnType = void | symbol; type DeepMergeIntoFunctions = Readonly<{ mergeRecords: >>, U extends DeepMergeIntoUtils>(mut_target: DeepMergeValueReference>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType; mergeArrays: >, U extends DeepMergeIntoUtils>(mut_target: DeepMergeValueReference, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType; mergeMaps: >>, U extends DeepMergeIntoUtils>(mut_target: DeepMergeValueReference>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType; mergeSets: >>, U extends DeepMergeIntoUtils>(mut_target: DeepMergeValueReference>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType; mergeCircularReferences: , U extends DeepMergeIntoUtils>(mut_target: DeepMergeValueReference, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType; mergeOthers: , U extends DeepMergeIntoUtils>(mut_target: DeepMergeValueReference, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType; }>; /** * The utils provided to the merge functions. */ export type DeepMergeUtils = Readonly<{ mergeFunctions: DeepMergeFunctions; defaultMergeFunctions: MergeFunctions$1; metaDataUpdater: MetaDataUpdater; deepmerge: >(...values: Ts) => unknown; useImplicitDefaultMerging: boolean; filterValues: DeepMergeUtilityFunctions["filterValues"] | undefined; maxDepth: number | undefined; actions: Readonly<{ defaultMerge: symbol; skip: symbol; }>; }>; /** * The utils provided to the merge functions. */ export type DeepMergeIntoUtils = Readonly<{ mergeFunctions: DeepMergeIntoFunctions; defaultMergeFunctions: MergeFunctions; metaDataUpdater: MetaDataUpdater; deepmergeInto: >(target: Target, ...values: Ts) => void; filterValues: DeepMergeUtilityFunctions["filterValues"] | undefined; maxDepth: number | undefined; actions: Readonly<{ defaultMerge: symbol; }>; }>; /** * The utils provided to the merge functions in fast mode. */ export type DeepMergeFastUnsafeUtils = DeepMergeUtils; /** * The utils provided to the into merge functions in fast mode. */ export type DeepMergeIntoFastUnsafeUtils = DeepMergeIntoUtils; /** * Deeply merge objects. * * @param objects - The objects to merge. * @returns The merged result. */ export declare function deepmerge>>(...objects: readonly [ ...Ts ]): DeepMergeHKT; /** * Used by the default `deepmerge` function. * * @internal * @returns A customized deepmerge function. */ export declare function deepmergeCustom(): >(...objects: Ts) => DeepMergeHKT; /** * 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 = {}>(options: DeepMergeOptions): >(...objects: Ts) => DeepMergeHKT, 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 = {}, MetaData extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MetaMetaData extends DeepMergeMergeInfo = DeepMergeMergeInfo>(options: DeepMergeOptions, rootMetaData?: MetaData): >(...objects: Ts) => DeepMergeHKT, 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>>(...objects: readonly [ ...Ts ]): DeepMergeHKT; /** * Used by the default `deepmergeFastUnsafe` function. * * @internal * @returns A customized deepmergeFastUnsafe function. */ export declare function deepmergeFastUnsafeCustom(): >(...objects: Ts) => DeepMergeHKT; /** * 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 = {}>(options: DeepMergeFastUnsafeOptions): >(...objects: Ts) => DeepMergeHKT, 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(target: T, ...objects: ReadonlyArray): 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: Target, ...objects: Ts): asserts target is SimplifyObject>; /** * Used by the default `deepmergeInto` function. * * @internal * @returns A customized deepmergeInto function. */ export declare function deepmergeIntoCustom(): >(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(options: DeepMergeIntoOptions): >(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(options: DeepMergeIntoOptions, rootMetaData?: MetaData): >(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(target: T, ...objects: ReadonlyArray): 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: Target, ...objects: Ts): asserts target is SimplifyObject>; /** * Used by the default `deepmergeIntoFastUnsafe` function. * * @internal * @returns A customized deepmergeIntoFastUnsafe function. */ export declare function deepmergeIntoFastUnsafeCustom(): >(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(options: DeepMergeIntoFastUnsafeOptions): >(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): Set; /** * 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>, U extends DeepMergeIntoUtils, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(mut_target: DeepMergeValueReference>, values: Ts, utils: U): void; declare function mergeMapsIntoFast>>, U extends DeepMergeIntoUtils, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(mut_target: DeepMergeValueReference>, 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>, U extends DeepMergeUtils, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils: U): DeepMergeRecordsDefaultHKT; declare function mergeMapsFast>, U extends DeepMergeUtils, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils: U): DeepMergeMapsDefaultHKT; export { MergeFunctions as DeepMergeIntoFunctionsDefaults, MergeFunctions$1 as DeepMergeFunctionsDefaults, MergeFunctionsFast as DeepMergeIntoFunctionsDefaultsFastUnsafe, MergeFunctionsFast$1 as DeepMergeFunctionsDefaultsFastUnsafe, }; export {};