declare type DeepPartial<T> = T extends object ? {
    [P in keyof T]?: DeepPartial<T[P]>;
} : T;

declare type NestedPaths<T> = T extends object ? {
    [K in keyof T]-?: K extends string ? T[K] extends unknown[] ? `${K}` : T[K] extends object ? `${K}` | `${K}.${NestedPaths<NonNullable<T[K]>>}` : `${K}` : never;
}[keyof T] : never;

declare type PartialPathValue<T, P> = P extends NestedPaths<T> ? DeepPartial<Path<T, P>> : DeepPartial<T>;

declare type Path<T, K extends string> = K extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? Path<T[Key], Rest> : never : K extends keyof T ? T[K] : never;

declare type PathValue<T, P> = P extends NestedPaths<T> ? Path<T, P> : T;

declare type StateType = Record<string, unknown> | undefined | null;

declare type StateValue<T, P, M extends boolean> = M extends true ? PartialPathValue<T, P> : PathValue<T, P>;

/**
 * A custom hook for managing deeply nested state objects with type safety.
 * @param initialState - The initial state object
 * @returns [state, setState] tuple with strongly typed path-based setter
 */
export declare function useDeepState<T extends StateType>(initialState?: T): readonly [T, <P extends "" | NestedPaths<T> | undefined, M extends boolean>(value: StateValue<T, P, M>, path?: P, merge?: M) => void];

export { }