/**
 * Flatten the given object.
 * Given an object with nested elements, it returns an object that has been flattened,
 * that is, where the keys are string that represent the nested route to follow
 * in the original object to access the leaves.
 *
 * @example
```
flatten({
    a: {
        a1: 1,
        a2: 2
    },
    b: {
        b1: {
            b1i: 'hello',
            b1ii: 'world'
        }
    }
});
// this will yield:
{
    'a.a1': 1,
    'a.a2': 2,
    'b.b1.b1i': 'hello',
    'b.b1.b1ii': 'world'
}
```
 * Additional options may be passed, such as which character is used as a delimiter,
 * or the maximum depth level.
 *
 * For an inverse operation see {@link unflatten}.
 *
 * @param target - The element to flatten.
 * @param options - The option to flatten.
 *
 * @returns The flattened object
 */
export declare const flatten: <TTarget extends Record<string, unknown>, TResult extends Record<string, unknown>>(target: TTarget, options?: Partial<FlattenOptions>) => TResult;
/**
 * Un-Flatten the given object.
 * Given an object without nested elements, but whose keys represent paths in
 * a nested elements object, return an object that has nested objects in it.
 * This the reverse of {@link flatten}, in such a way that this complies.
 *
 * @example
```
unflatten({
    'a.a1': 1,
    'a.a2': 2,
    'b.b1.b1i': 'hello',
    'b.b1.b1ii': 'world'
});
// this will yield:
{
    a: {
        a1: 1,
        a2: 2
    },
    b: {
        b1: {
            b1i: 'hello',
            b1ii: 'world'
        }
    }
}
```
 * Additional options may be passed, such as which character is used as a delimiter,
 * or the maximum depth level.
 *
 * @param target - The element to unflatten.
 * @param options - The option to unflatten.
 *
 * @returns The unflattened object
 */
export declare const unflatten: <TTarget extends Record<string, any>, TResult extends Record<string, any>>(target: TTarget, options?: Partial<UnflattenOptions>) => TResult;
//# sourceMappingURL=flatten.d.ts.map