/// <amd-module name="nova_ecs/plugins/delta_plugin" />
import { Patch } from 'immer/dist/internal';
import * as t from 'io-ts';
import { Component, UnknownComponent } from '../component';
import { Entity } from '../entity';
import { Plugin } from '../plugin';
import { Resource } from '../resource';
import { Serializer } from './serializer_plugin';
export interface OptionalComponentDelta<Data, Delta> {
    componentType: t.Type<Data, unknown, unknown>;
    deltaType?: t.Type<Delta, unknown, unknown>;
    getDelta?: (a: Data, b: Data, patches: Patch[]) => Delta | undefined;
    applyDelta?: (componentData: Data, delta: Delta) => Data | void;
}
export declare type ComponentDelta<Data, Delta> = {
    [K in keyof OptionalComponentDelta<Data, Delta>]-?: OptionalComponentDelta<Data, Delta>[K];
};
interface ComponentDeltaMap<K extends Component<any>> extends Map<K, ComponentDelta<unknown, unknown>> {
    get<Data>(key: Component<Data>): ComponentDelta<Data, unknown> | undefined;
    set<Data>(key: Component<Data>, val: ComponentDelta<Data, any>): this;
}
export declare const EntityDelta: t.PartialC<{
    componentStates: t.Type<Map<string, unknown>, [string, unknown][], unknown>;
    componentDeltas: t.Type<Map<string, unknown>, [string, unknown][], unknown>;
    removeComponents: t.Type<Set<string>, string[], unknown>;
}>;
export declare type EntityDelta = t.TypeOf<typeof EntityDelta>;
export declare class DeltaMaker {
    private serializer;
    readonly componentDeltas: ComponentDeltaMap<UnknownComponent>;
    constructor(serializer: Serializer);
    addComponent<Data, Delta>(component: Component<Data>, componentDelta: OptionalComponentDelta<Data, Delta>): void;
    /**
     * Removes the immer draftedness of an entity's components.
     */
    untrack(entity: Entity): void;
    /**
     * Gets the changes that have been made to an entity since the last
     * call to `getDelta`. Uses Immer to track changes on components.
     */
    getDelta(entity: Entity): EntityDelta | undefined;
    /**
     * Apply a delta to an entity. Returns the set of components that
     * the delta had but the entity was missing.
     */
    applyDelta(entity: Entity, delta: EntityDelta): Set<UnknownComponent>;
}
export declare const DeltaResource: Resource<DeltaMaker>;
export declare const DeltaPlugin: Plugin;
declare const Patch: t.IntersectionC<[t.TypeC<{
    op: t.UnionC<[t.LiteralC<"replace">, t.LiteralC<"remove">, t.LiteralC<"add">]>;
    path: t.ArrayC<t.UnionC<[t.StringC, t.NumberC]>>;
}>, t.PartialC<{
    value: t.UnknownC;
}>]>;
export declare const immerDeltaType: t.ArrayC<t.IntersectionC<[t.TypeC<{
    op: t.UnionC<[t.LiteralC<"replace">, t.LiteralC<"remove">, t.LiteralC<"add">]>;
    path: t.ArrayC<t.UnionC<[t.StringC, t.NumberC]>>;
}>, t.PartialC<{
    value: t.UnknownC;
}>]>>;
export declare function immerGetDelta<T>(_a: T, _b: T, patches: Patch[]): Patch[] | undefined;
export declare function immerApplyDelta<T>(componentData: T, delta: Patch[]): T;
export {};