import { PatchableArray } from '../structs/PatchableArray.js';
import { Cloneable } from './Cloneable.js';
import { Data } from './Data.js';
import { Decoder } from './Decoder.js';
import { Encodeable, PlainObject } from './Encodeable.js';
import { EncodeContext } from './EncodeContext.js';
import { Field } from './Field.js';
import { AutoEncoderPatchType, PartialWithoutMethods, Patchable } from './Patchable.js';
export type PatchableDecoder<T> = Decoder<T> & (T extends AutoEncoder ? {} : (T extends Patchable<infer P> ? {
    patchType: () => PatchableDecoder<P>;
    patchIdentifier: () => Decoder<string | number>;
} : {}));
export declare function coalesceUndefined<T>(...values: (T)[]): T | undefined;
type AutoEncoderConstructorNames<T> = {
    [K in keyof T]: T[K] extends Function | PatchableArray<any, any, any> ? never : K;
}[Exclude<keyof T, 'latestVersion'>];
export type AutoEncoderConstructor<T> = Pick<T, AutoEncoderConstructorNames<T>>;
/**
 * Create patchable auto encoder.
 * We are not able to add types here, gets too complex. But we'll add a convenience method with typings
 */
export declare class AutoEncoder implements Encodeable, Cloneable {
    readonly _isAutoEncoder = true;
    static fields: Field<any>[];
    private static cachedPatchType?;
    static isPatch: boolean;
    static putType?: typeof AutoEncoder;
    static skipDefaultValuesVersion: number;
    static patchType<T extends typeof AutoEncoder>(this: T): typeof AutoEncoder & (new () => AutoEncoderPatchType<InstanceType<T>>);
    /**
     * Try to build a default value for this object, if possible. If this is not possible it will return undefined.
     *
     * Override if you want to set custom default values or disable this behavior.
     */
    static getDefaultValue<T extends typeof AutoEncoder>(this: T): InstanceType<T> | undefined;
    static isDefaultValue<T extends typeof AutoEncoder>(this: T, value: AutoEncoder): boolean;
    equals(other: AutoEncoder): boolean;
    isPatch<T extends AutoEncoder>(this: T | AutoEncoderPatchType<T>): this is AutoEncoderPatchType<T>;
    isPut<T extends AutoEncoder>(this: T | AutoEncoderPatchType<T>): this is T;
    static patch<T extends typeof AutoEncoder>(this: T, object: PartialWithoutMethods<AutoEncoderPatchType<InstanceType<T>>>): AutoEncoderPatchType<InstanceType<T>>;
    patchOrPut<T extends AutoEncoder>(this: T, patch: AutoEncoderPatchType<T> | T): void;
    /**
     * Make a deep clone of this object
     */
    clone<T extends AutoEncoder>(this: T): this;
    patch<T extends AutoEncoder>(this: T, patch: PartialWithoutMethods<AutoEncoderPatchType<T>> | AutoEncoderPatchType<T> | T | PartialWithoutMethods<T>): this;
    private static compareField;
    static sortFields(): void;
    /**
     * WeakMap is overkill on static classes.
     * This is drammatically faster than using Object.prototype.hasOwnProperty
     */
    static __fieldsForVersion: Map<number, Field<any>[]>;
    static __latestVersion: number;
    static __latestFields: Field<any>[];
    static __isConstructorDefaults: Map<string, (val: unknown) => boolean>;
    protected static getIsConstructorDefaults(): Map<string, (val: unknown) => boolean>;
    protected static isConstructorDefault(property: string, val: unknown): boolean | null;
    static get latestVersion(): number;
    static setCachedLatestVersion(): number;
    static get latestFields(): Field<any>[];
    static fieldsForVersion(version: number): Field<any>[];
    static doesPropertyExist(property: string): boolean;
    /**
     * Create a new one by providing the properties of the object
     */
    static create<T extends typeof AutoEncoder>(this: T, object: PartialWithoutMethods<InstanceType<T>>): InstanceType<T>;
    /**
     * Create a new one by providing the properties of the object
     */
    set<T extends AutoEncoder>(this: T, object: PartialWithoutMethods<T> | T): void;
    /**
     * Create a new one by providing the properties of the object.
     * Maintaining references to objects
     */
    deepSet<T extends AutoEncoder>(this: T, object: PartialWithoutMethods<T> | T): unknown;
    get static(): typeof AutoEncoder;
    /**
     * When returning true, the value won't be encoded in the encoded version of the object
     */
    static isPropertyDefaultValue(field: Field<unknown>, value: unknown, longTermStorage: boolean): boolean;
    encode(context: EncodeContext): PlainObject;
    static decodeField<T extends typeof AutoEncoder>(this: T, v: unknown, context: EncodeContext, currentField?: string): InstanceType<T>;
    static decode<T extends typeof AutoEncoder>(this: T, data: Data): InstanceType<T>;
    /**
     * Upgrade property values coming from an older version
     * @param from
     * @param object
     */
    static upgrade<T extends typeof AutoEncoder>(from: number, object: InstanceType<T>, defaultValues: Map<string, unknown>): void;
    /**
     * Downgrade property values to a new object
     */
    static downgrade(to: number, object: any): object;
}
export {};
//# sourceMappingURL=AutoEncoder.d.ts.map