// Generated by dts-bundle-generator v9.5.1 /** * Simplify a complex type such as a union or intersection of objects into a * single object. */ export type SimplifyObject = { [K in keyof T]: T[K]; } & {}; /** * Flatten a collection of tuples of tuples into a collection of tuples. */ export type FlattenTuples = { [I in keyof T]: FlattenTuple; }; /** * Flatten a tuple of tuples into a single tuple. */ export type FlattenTuple = T extends readonly [ ] ? [ ] : T extends readonly [ infer T0 ] ? [ ...FlattenTuple ] : T extends readonly [ infer T0, ...infer Ts ] ? [ ...FlattenTuple, ...FlattenTuple ] : [ T ]; /** * Safely test whether or not the first given types extends the second. * * Needed in particular for testing if a type is "never". */ export type Is = [ T1 ] extends [ T2 ] ? true : false; /** * Safely test whether or not the given type is "never". */ export type IsNever = Is; /** * And operator for types. */ export type And = T1 extends false ? false : T2; /** * Not operator for types. */ export type Not = T extends true ? false : true; /** * Check if a key is optional in the given object. */ export type KeyIsOptional = O extends { [Key in K]: unknown; } ? false : true; /** * Returns whether or not the given type a record. * * Note: Does not pass for interfaces. */ export type IsRecord = And>, T extends Readonly> ? true : false>; /** * Returns whether or not all the given types are records. */ export type EveryIsRecord> = Ts extends readonly [ infer Head, ...infer Rest ] ? IsRecord extends true ? Rest extends ReadonlyArray ? EveryIsRecord : true : false : true; /** * Returns whether or not the given type is an array. */ export type IsArray = And>, T extends ReadonlyArray ? true : false>; /** * Returns whether or not all the given types are arrays. */ export type EveryIsArray> = Ts extends readonly [ infer T1 ] ? IsArray : Ts extends readonly [ infer Head, ...infer Rest ] ? IsArray extends true ? Rest extends readonly [ unknown, ...ReadonlyArray ] ? EveryIsArray : false : false : false; /** * Returns whether or not the given type is an set. * * Note: This may also return true for Maps. */ export type IsSet = And>, T extends Readonly> ? true : false>; /** * Returns whether or not all the given types are sets. * * Note: This may also return true if all are maps. */ export type EveryIsSet> = Ts extends Readonly ? IsSet : Ts extends readonly [ infer Head, ...infer Rest ] ? IsSet extends true ? Rest extends readonly [ unknown, ...ReadonlyArray ] ? EveryIsSet : false : false : false; /** * Returns whether or not the given type is an map. */ export type IsMap = And>, T extends Readonly> ? true : false>; /** * Returns whether or not all the given types are maps. */ export type EveryIsMap> = Ts extends Readonly ? IsMap : Ts extends readonly [ infer Head, ...infer Rest ] ? IsMap extends true ? Rest extends readonly [ unknown, ...ReadonlyArray ] ? EveryIsMap : false : false : false; /** * Union of the sets' values' types */ export type UnionSetValues> = UnionSetValuesHelper; /** * Tail-recursive helper type for UnionSetValues. */ export type UnionSetValuesHelper, Acc> = Ts extends readonly [ infer Head, ...infer Rest ] ? Head extends Readonly> ? Rest extends ReadonlyArray ? UnionSetValuesHelper : Acc | V1 : never : Acc; /** * Union of the maps' values' types */ export type UnionMapKeys> = UnionMapKeysHelper; /** * Tail-recursive helper type for UnionMapKeys. */ export type UnionMapKeysHelper, Acc> = Ts extends readonly [ infer Head, ...infer Rest ] ? Head extends Readonly> ? Rest extends readonly [ ] ? Acc | K1 : UnionMapKeysHelper : never : Acc; /** * Union of the maps' keys' types */ export type UnionMapValues> = UnionMapValuesHelper; /** * Tail-recursive helper type for UnionMapValues. */ export type UnionMapValuesHelper, Acc> = Ts extends readonly [ infer Head, ...infer Rest ] ? Head extends Readonly> ? Rest extends readonly [ ] ? Acc | V1 : UnionMapValuesHelper : never : Acc; /** * Use the more precise type if the types are compatible. * Otherwise, union them. */ export type PreciseOrUnion = A extends B ? A : B extends A ? B : A | B; /** * Filter out U from a tuple. */ export type FilterOut, U> = FilterOutHelper; /** * Tail-recursive helper type for FilterOut. */ export type FilterOutHelper, U, Acc extends ReadonlyArray> = T extends readonly [ ] ? Acc : T extends readonly [ infer Head, ...infer Rest ] ? Is extends true ? FilterOutHelper : FilterOutHelper : T; /** * Filter out nevers from a tuple. */ export type FilterOutNever = T extends ReadonlyArray ? FilterOut : never; /** * Is the type a tuple? */ export type IsTuple> = T extends readonly [ ] ? true : T extends readonly [ unknown, ...ReadonlyArray ] ? true : false; /** * Perfrom a transpose operation on a 2D tuple. */ export type TransposeTuple = T extends readonly [ ...(readonly [ ...unknown[] ]) ] ? T extends readonly [ ] ? [ ] : T extends readonly [ infer X extends ReadonlyArray ] ? TransposeTupleSimpleCase : T extends readonly [ infer X extends ReadonlyArray, ...infer XS extends ReadonlyArray> ] ? PrependCol> : T : never; export type PrependCol, S extends ReadonlyArray>> = T extends readonly [ ] ? S extends readonly [ ] ? [ ] : never : T extends readonly [ infer X, ...infer XS ] ? S extends readonly [ readonly [ ...infer Y ], ...infer YS extends ReadonlyArray> ] ? [ [ X, ...Y ], ...PrependCol ] : never : never; export type TransposeTupleSimpleCase = T extends readonly [ ] ? [ ] : T extends readonly [ infer X, ...infer XS ] ? [ [ X ], ...TransposeTupleSimpleCase ] : never; /** * Convert a tuple to an intersection of each of its types. */ export type TupleToIntersection> = { [K in keyof T]: (x: T[K]) => void; } extends Record void> ? I : never; /** * Convert a union to a tuple. * * Warning: The order of the elements is non-deterministic. * Warning 2: The union maybe me modified by the TypeScript engine before convertion. * Warning 3: This implementation relies on a hack/limitation in TypeScript. */ export type UnionToTuple> = IsNever extends true ? [ ] : [ ...UnionToTuple>, L ]; export type UnionToIntersection = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never; export type LastOf = UnionToIntersection T : never> extends () => infer R ? R : never; /** * Convert a tuple of tuples to a tuple of unions. */ export type TupleTupleToTupleUnion>> = { [I in keyof T]: TupleToUnion; }; /** * Convert a tuple to a union. */ export type TupleToUnion> = T extends readonly [ ] ? never : T extends readonly [ infer Head, ...infer Rest ] ? Head | TupleToUnion : never; /** * Assert that a type is of a given type. */ export 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 DeepMergeFilterValuesDefaultURI: DeepMergeFilterValuesDefaultHKT; readonly DeepMergeNoFilteringURI: Ts; } /** * Get the type of the given merge function via its URI. */ export type DeepMergeFunctionKind, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionURItoKind[URI]; /** * A union of all valid merge function URIs. */ export 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 : DeepMergeHKTHelper, Fs, M> : unknown; export type DeepMergeHKTHelper = Ts extends ReadonlyArray ? IsTuple extends true ? Ts extends readonly [ ] ? unknown : Ts extends readonly [ infer T1 ] ? T1 : EveryIsArray extends true ? DeepMergeArraysHKT : EveryIsMap extends true ? DeepMergeMapsHKT : EveryIsSet extends true ? DeepMergeSetsHKT : EveryIsRecord extends true ? DeepMergeRecordsHKT : DeepMergeOthersHKT : unknown : never; /** * Deep merge records. */ export type DeepMergeRecordsHKT, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind; /** * Deep merge arrays. */ export type DeepMergeArraysHKT, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind; /** * Deep merge sets. */ export type DeepMergeSetsHKT, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind; /** * Deep merge maps. */ export type DeepMergeMapsHKT, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind; /** * Deep merge other things. */ export type DeepMergeOthersHKT, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind; /** * Filter values. */ export 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]: FilterValuesHKT, Fs, M>; }>>>> : never; export 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; /** * The meta data deepmerge is able to provide. */ export type DeepMergeBuiltInMetaData = Readonly<{ key: PropertyKey; parents: ReadonlyArray>>; }>; /** * The default merge function to merge records with. */ export type DeepMergeRecordsDefaultURI = "DeepMergeRecordsDefaultURI"; /** * The default merge function to merge arrays with. */ export type DeepMergeArraysDefaultURI = "DeepMergeArraysDefaultURI"; /** * The default merge function to merge sets with. */ export type DeepMergeSetsDefaultURI = "DeepMergeSetsDefaultURI"; /** * The default merge function to merge maps with. */ export type DeepMergeMapsDefaultURI = "DeepMergeMapsDefaultURI"; /** * The default filter values function. */ export 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; }>; export type RecordEntries> = FilterOut, undefined>; export type RecordMeta = Record; export type RecordPropertyMeta = { key: Key; value: Value; optional: Optional; }; export type RecordsToRecordMeta>> = FilterOutNever<{ [I in keyof Ts]: RecordToRecordMeta; }>; export type RecordToRecordMeta> = { [K in keyof T]-?: { key: K; value: Required[K]; optional: KeyIsOptional; }; }; /** * Deep merge records. */ export type DeepMergeRecordsDefaultHKT, Fs extends DeepMergeFunctionsURIs, M> = Ts extends ReadonlyArray> ? SimplifyObject, Fs, M>> : never; /** * Deep merge record props. */ export type DeepMergeRecordMetaDefaultHKTProps = RecordMetas extends ReadonlyArray ? CreateRecordFromMeta, Fs, M> : never; export type MergeRecordMeta> = GroupValuesByKey>; }, readonly [ ]>>>>; export type GroupValuesByKey = Ts extends readonly [ infer Keys extends ReadonlyArray, infer Values ] ? { [I in keyof Keys]: DeepMergeRecordPropertyMetaDefaultHKTGetPossible>; } : never; export type CreateRecordFromMeta = Ts extends ReadonlyArray ? TupleToIntersection<{ [I in keyof Ts]: Ts[I] extends { key: infer Key extends PropertyKey; values: infer Values extends ReadonlyArray; optional: infer O extends boolean; } ? CreateRecordForKeyFromMeta : never; }> : never; export type CreateRecordForKeyFromMeta, Optional extends boolean, Fs extends DeepMergeFunctionsURIs, M> = Optional extends true ? { [k in Key]+?: DeepMergeHKT; } : { [k in Key]-?: DeepMergeHKT; }; /** * Get the possible types of a property. */ export type DeepMergeRecordPropertyMetaDefaultHKTGetPossible = Ts extends readonly [ RecordPropertyMeta, ...ReadonlyArray ] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper : never; /** * Tail-recursive helper type for DeepMergeRecordPropertyMetaDefaultHKTGetPossible. */ export type DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper ], Acc extends { key: PropertyKey; values: ReadonlyArray; optional: boolean; }> = Ts extends [ ...infer Rest, { key: infer K extends PropertyKey; value: infer V; optional: infer O extends boolean; } ] ? Acc["optional"] extends true ? Acc extends { values: [ infer Head, ...infer AccRest ]; } ? Rest extends readonly [ RecordPropertyMeta, ...ReadonlyArray ] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper, ...AccRest ]; optional: O; }> : { key: K; values: [ PreciseOrUnion, ...AccRest ]; optional: O; } : Rest extends readonly [ RecordPropertyMeta, ...ReadonlyArray ] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper : { key: K; values: [ V, ...Acc["values"] ]; optional: O; } : Rest extends readonly [ RecordPropertyMeta, ...ReadonlyArray ] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper : { key: K; values: [ V, ...Acc["values"] ]; optional: O; } : never; /** * Deep merge arrays. */ export type DeepMergeArraysDefaultHKT, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeArraysDefaultHKTHelper; /** * Tail-recursive helper type for DeepMergeArraysDefaultHKT. */ export 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> = FilterOut; /** * Get the merge functions with defaults apply from the given subset. */ export type GetDeepMergeFunctionsURIs> = Readonly<{ DeepMergeRecordsURI: PMF["DeepMergeRecordsURI"] extends keyof DeepMergeFunctionURItoKind ? PMF["DeepMergeRecordsURI"] : DeepMergeRecordsDefaultURI; DeepMergeArraysURI: PMF["DeepMergeArraysURI"] extends keyof DeepMergeFunctionURItoKind ? PMF["DeepMergeArraysURI"] : DeepMergeArraysDefaultURI; DeepMergeSetsURI: PMF["DeepMergeSetsURI"] extends keyof DeepMergeFunctionURItoKind ? PMF["DeepMergeSetsURI"] : DeepMergeSetsDefaultURI; DeepMergeMapsURI: PMF["DeepMergeMapsURI"] extends keyof DeepMergeFunctionURItoKind ? PMF["DeepMergeMapsURI"] : DeepMergeMapsDefaultURI; DeepMergeOthersURI: PMF["DeepMergeOthersURI"] extends keyof DeepMergeFunctionURItoKind ? PMF["DeepMergeOthersURI"] : DeepMergeLeafURI; DeepMergeFilterValuesURI: PMF["DeepMergeFilterValuesURI"] extends keyof DeepMergeFunctionURItoKind ? PMF["DeepMergeFilterValuesURI"] : DeepMergeFilterValuesDefaultURI; }>; /** * The default merge functions. */ type MergeFunctions = { mergeRecords: typeof mergeRecordsInto; mergeArrays: typeof mergeArraysInto; mergeSets: typeof mergeSetsInto; mergeMaps: typeof mergeMapsInto; mergeOthers: typeof mergeOthersInto; }; declare function mergeRecordsInto>, U extends DeepMergeIntoFunctionUtils, M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(mut_target: Reference>, values: Ts, utils: U, meta: M | undefined): void; declare function mergeArraysInto>>(mut_target: Reference, values: Ts): void; declare function mergeSetsInto>>>(mut_target: Reference>, values: Ts): void; declare function mergeMapsInto>>>(mut_target: Reference>, values: Ts): void; declare function mergeOthersInto>(mut_target: Reference, values: Ts): void; /** * The default merge functions. */ type MergeFunctions$1 = { mergeRecords: typeof mergeRecords; mergeArrays: typeof mergeArrays; mergeSets: typeof mergeSets; mergeMaps: typeof mergeMaps; mergeOthers: typeof mergeOthers; }; declare function mergeRecords>, U extends DeepMergeUtils, Fs extends DeepMergeFunctionsURIs, M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(values: Ts, utils: U, meta: M | undefined): DeepMergeRecordsDefaultHKT; declare function mergeArrays>, Fs extends DeepMergeFunctionsURIs, M>(values: Ts): DeepMergeArraysDefaultHKT; declare function mergeSets>>>(values: Ts): DeepMergeSetsDefaultHKT; declare function mergeMaps>>>(values: Ts): DeepMergeMapsDefaultHKT; declare function mergeOthers>(values: Ts): unknown; /** * The options the user can pass to customize deepmerge. */ export type DeepMergeOptions> = {}> = Partial>; /** * The options the user can pass to customize deepmergeInto. */ export type DeepMergeIntoOptions> = {}> = Partial>; export type MetaDataUpdater = (previousMeta: M | undefined, metaMeta: Readonly>) => M; /** * All the options the user can pass to customize deepmerge. */ export type DeepMergeOptionsFull = Readonly<{ mergeRecords: DeepMergeFunctions["mergeRecords"] | false; mergeArrays: DeepMergeFunctions["mergeArrays"] | false; mergeMaps: DeepMergeFunctions["mergeMaps"] | false; mergeSets: DeepMergeFunctions["mergeSets"] | false; mergeOthers: DeepMergeFunctions["mergeOthers"]; metaDataUpdater: MetaDataUpdater; enableImplicitDefaultMerging: boolean; filterValues: DeepMergeUtilityFunctions["filterValues"] | false; }>; /** * All the options the user can pass to customize deepmergeInto. */ export type DeepMergeIntoOptionsFull = Readonly<{ mergeRecords: DeepMergeIntoFunctions["mergeRecords"] | false; mergeArrays: DeepMergeIntoFunctions["mergeArrays"] | false; mergeMaps: DeepMergeIntoFunctions["mergeMaps"] | false; mergeSets: DeepMergeIntoFunctions["mergeSets"] | false; mergeOthers: DeepMergeIntoFunctions["mergeOthers"]; metaDataUpdater: MetaDataUpdater; filterValues: DeepMergeUtilityFunctions["filterValues"] | false; }>; /** * An object that has a reference to a value. */ type Reference = { value: T; }; /** * All the utility functions that can be overridden. */ export type DeepMergeUtilityFunctions = Readonly<{ filterValues: >(values: Ts, meta: M | undefined) => unknown[]; }>; /** * All the merge functions that deepmerge uses. */ export 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; mergeOthers: , U extends DeepMergeUtils>(values: Ts, utils: U, meta: M | undefined) => unknown; }>; export type DeepMergeIntoFunctionsReturnType = void | symbol; /** * All the merge functions that deepmerge uses. */ export type DeepMergeIntoFunctions = Readonly<{ mergeRecords: >>, U extends DeepMergeIntoFunctionUtils>(mut_target: Reference>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType; mergeArrays: >, U extends DeepMergeIntoFunctionUtils>(mut_target: Reference, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType; mergeMaps: >>, U extends DeepMergeIntoFunctionUtils>(mut_target: Reference>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType; mergeSets: >>, U extends DeepMergeIntoFunctionUtils>(mut_target: Reference>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType; mergeOthers: , U extends DeepMergeIntoFunctionUtils>(mut_target: Reference, 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; actions: Readonly<{ defaultMerge: symbol; skip: symbol; }>; }>; /** * The utils provided to the merge functions. */ export type DeepMergeIntoFunctionUtils = Readonly<{ mergeFunctions: DeepMergeIntoFunctions; defaultMergeFunctions: MergeFunctions; metaDataUpdater: MetaDataUpdater; deepmergeInto: >(target: Target, ...values: Ts) => void; filterValues: DeepMergeUtilityFunctions["filterValues"] | undefined; actions: Readonly<{ defaultMerge: symbol; }>; }>; /** * Deeply merge objects. * * @param objects - The objects to merge. */ export declare function deepmerge>>(...objects: readonly [ ...Ts ]): DeepMergeHKT; /** * Deeply merge two or more objects using the given options. * * @param options - The options on how to customize the merge 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. */ export declare function deepmergeCustom = {}, MetaData = DeepMergeBuiltInMetaData, MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(options: DeepMergeOptions, rootMetaData?: MetaData): >(...objects: Ts) => DeepMergeHKT, MetaData>; /** * 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>; /** * Deeply merge two or more objects using the given options. * * @param options - The options on how to customize the merge function. */ export declare function deepmergeIntoCustom(options: DeepMergeIntoOptions): >(target: Target, ...objects: Ts) => void; /** * 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. */ export declare function deepmergeIntoCustom(options: DeepMergeIntoOptions, rootMetaData?: MetaData): >(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 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 getKeys(objects: ReadonlyArray