export type DeepReadonly<T> = {
    readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};
export type ExactOptional<T> = {
    [K in keyof T]?: T[K];
};
export type SafeAccess<T, K extends keyof T> = T[K] extends undefined ? T[K] | undefined : T[K];
export declare class TypeSafeObjectMerger {
    static merge<T extends Record<string, unknown>, S extends Record<string, unknown>>(target: T, source: S, options?: {
        overwriteUndefined?: boolean;
        validateTypes?: boolean;
        deep?: boolean;
    }): T & S;
    private static validateTypeCompatibility;
    private static isPlainObject;
}
export declare class SafePropertyAccess {
    static get<T extends Record<string, unknown>, K extends keyof T>(obj: T, key: K, defaultValue?: T[K]): T[K] | typeof defaultValue;
    static getString<T extends Record<string, unknown>>(obj: T, key: keyof T, defaultValue?: string): string;
    static getNumber<T extends Record<string, unknown>>(obj: T, key: keyof T, defaultValue?: number): number;
    static getBoolean<T extends Record<string, unknown>>(obj: T, key: keyof T, defaultValue?: boolean): boolean;
    static getArray<T extends Record<string, unknown>, U = unknown>(obj: T, key: keyof T, defaultValue?: U[]): U[];
    static getObject<T extends Record<string, unknown>, U extends Record<string, unknown> = Record<string, unknown>>(obj: T, key: keyof T, defaultValue?: U): U;
    private static isValidObject;
}
export declare class TypeSafeConfigManager<T extends Record<string, unknown>> {
    private readonly schema;
    private readonly config;
    constructor(schema: ConfigSchema<T>, initialConfig?: ExactOptional<T>);
    get<K extends keyof T>(key: K): T[K];
    set<K extends keyof T>(key: K, value: T[K]): void;
    update(updates: ExactOptional<T>): void;
    getAll(): DeepReadonly<T>;
    private validateAndApplyDefaults;
    private validateConfigValue;
    private validateType;
}
export type ConfigType = 'string' | 'number' | 'boolean' | 'object' | 'array';
export interface ConfigSchemaEntry<T = unknown> {
    type: ConfigType;
    required?: boolean;
    default?: T;
    validator?: (value: T) => boolean;
    description?: string;
}
export type ConfigSchema<T extends Record<string, unknown>> = {
    [K in keyof T]: ConfigSchemaEntry<T[K]>;
};
export declare class ExactOptionalUtils {
    static filterUndefined<T extends Record<string, unknown>>(obj: ExactOptional<T>): Partial<T>;
    static mergeExactOptional<T extends Record<string, unknown>>(...objects: ExactOptional<T>[]): ExactOptional<T>;
    static validateExactOptional<T extends Record<string, unknown>>(obj: unknown, allowedKeys: (keyof T)[]): obj is ExactOptional<T>;
}
export declare function deepClone<T>(obj: T): T;
export declare function partial<T extends (...args: any[]) => any>(fn: T, ...partialArgs: Partial<Parameters<T>>): (...remainingArgs: any[]) => ReturnType<T>;
export declare function createFrozen<T extends Record<string, unknown>>(obj: T): DeepReadonly<T>;
//# sourceMappingURL=type-helpers.d.ts.map