import type { Expand, UnionToIntersection } from "..";
export declare type Flatten<T, Z extends string = ""> = T extends object ? Expand<UnionToIntersection<{
    [P in keyof T]: P extends string | number ? T[P] extends object ? Flatten<T[P], `${Z}${P}.`> : {
        [Q in `${Z}${P}`]: T[P];
    } : never;
}[keyof T & (T extends ReadonlyArray<unknown> ? number : unknown)]>> : T;
export declare type Unflatten<T extends {
    [key: string]: unknown;
}> = Expand<UnionToIntersection<UnflattenDirect<T> | UnflattenIndirect<T, PrefixKeyof<T>>>>;
declare type PrefixKeyof<T extends {
    [key: string]: unknown;
}> = {
    [P in keyof T]: P extends `${infer Q}.${string}` ? Q : never;
}[keyof T];
declare type UnflattenDirect<T extends {
    [key: string]: unknown;
}> = {
    [P in keyof T]: P extends `${string}.${string}` ? never : {
        [Q in P]: T[P];
    };
}[keyof T];
declare type UnflattenIndirect<T extends {
    [key: string]: unknown;
}, Z extends string> = Z extends Z ? {
    [P in Z]: Expand<UnionToIntersection<{
        [P in keyof T]: P extends `${Z}.${infer Affix}` ? Unflatten<{
            [Q in Affix]: T[P];
        }> : never;
    }[keyof T]>>;
} : never;
/**
 * Turn an object into a single depth object.
 * @param object The original object.
 */
export declare function flatten<T>(object: T): Flatten<T>;
/**
 * Revert a flattened object to a nested object.
 * @todo This currently doesn't deal with arrays.
 * @param object The flattened object.
 */
export declare function unflatten<T extends {
    [key: string]: unknown;
}>(object: T): Unflatten<T>;
export {};