import { PatchableArray } from '../structs/PatchableArray.js';
import { AutoEncoder } from './AutoEncoder.js';
import { Encodeable } from './Encodeable.js';
import { EncodeContext } from './EncodeContext.js';
import { NonScalarIdentifiable } from './Identifiable.js';
import { Cloneable } from './Cloneable.js';
export interface Patchable<P> {
    patch(patch: P): this;
}
export type PatchType<T> = T extends Patchable<infer P> ? P : (T | undefined);
export declare function isPatchable<T>(object: T): object is T & Patchable<any>;
export declare function patchContainsChanges<B extends Encodeable & Patchable<B>, A extends PatchType<B>>(patch: A, model: B, context: EncodeContext): boolean;
export type ConvertArrayToPatchableArray<T> = T extends AutoEncoder ? T | AutoEncoderPatchType<T> | undefined : T extends PatchableArray<any, any, any> ? T : (T extends Array<infer P> ? (P extends string ? PatchableArray<string, string, string> : P extends number ? PatchableArray<number, number, number> : P extends AutoEncoder ? PatchableArrayAutoEncoder<P> : T | undefined) : (T extends Map<infer T, infer P> ? (PatchMap<T, P | ConvertArrayToPatchableArray<P> | null>) : PatchType<T> | undefined));
type NonMethodKeys<T> = {
    [K in keyof T]: T[K] extends Function ? never : K;
}[keyof T];
export type PartialWithoutMethods<Base> = Partial<Pick<Base, NonMethodKeys<Base>>>;
/**
 * Automatically determine the patchtype of an autoencoder object
 */
/**
 * Automatically determine the patchtype of an autoencoder object
 */
export type AutoEncoderPatchType<T extends AutoEncoder> = AutoEncoder & ({
    [P in Exclude<Exclude<keyof T, 'id'>, keyof AutoEncoder>]: T[P] extends Function ? never : ConvertArrayToPatchableArray<T[P]>;
} & (T extends NonScalarIdentifiable<infer Id> ? NonScalarIdentifiable<Id> : {}));
/**
 * Helper type to fix TypeScript circular dependency by making a synonym for a patchable array for an autoencoder
 */
export type PatchableArrayAutoEncoder<P extends AutoEncoder> = P extends AutoEncoder & NonScalarIdentifiable<infer Id> ? (PatchableArray<Id, P, AutoEncoderPatchType<P> & NonScalarIdentifiable<Id>>) : P[];
export declare class PatchMap<K, V> extends Map<K, V> implements Cloneable {
    _isPatch: boolean;
    _isPatchMap: boolean;
    applyTo(obj: Map<any, any>): Map<any, any>;
    clone<T extends this>(this: T): this;
}
export declare function isPatchMap(obj: unknown): obj is PatchMap<any, any>;
export declare function isPatchableArray(obj: unknown): obj is PatchableArray<any, any, any>;
export declare function isPatch(obj: unknown): boolean;
export declare function isEmptyPatch(patch: unknown): boolean;
/**
 * Use this method to encode an object (might be an encodeable implementation) into a decodable structure
 */
export declare function patchObject(obj: unknown, patch: unknown, options?: {
    getDefaultValue?: () => any | null;
    allowAutoDefaultValue?: boolean;
}): any;
export {};
//# sourceMappingURL=Patchable.d.ts.map