// package: akkaserverless.component.replicatedentity
// file: akkaserverless/component/replicatedentity/replicated_entity.proto

/* tslint:disable */
/* eslint-disable */

import * as jspb from "google-protobuf";
import * as akkaserverless_component_component_pb from "../../../akkaserverless/component/component_pb";
import * as akkaserverless_component_entity_entity_pb from "../../../akkaserverless/component/entity/entity_pb";
import * as google_protobuf_any_pb from "google-protobuf/google/protobuf/any_pb";

export class ReplicatedEntityStreamIn extends jspb.Message { 

    hasInit(): boolean;
    clearInit(): void;
    getInit(): ReplicatedEntityInit | undefined;
    setInit(value?: ReplicatedEntityInit): ReplicatedEntityStreamIn;

    hasDelta(): boolean;
    clearDelta(): void;
    getDelta(): ReplicatedEntityDelta | undefined;
    setDelta(value?: ReplicatedEntityDelta): ReplicatedEntityStreamIn;

    hasDelete(): boolean;
    clearDelete(): void;
    getDelete(): ReplicatedEntityDelete | undefined;
    setDelete(value?: ReplicatedEntityDelete): ReplicatedEntityStreamIn;

    hasCommand(): boolean;
    clearCommand(): void;
    getCommand(): akkaserverless_component_entity_entity_pb.Command | undefined;
    setCommand(value?: akkaserverless_component_entity_entity_pb.Command): ReplicatedEntityStreamIn;

    getMessageCase(): ReplicatedEntityStreamIn.MessageCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedEntityStreamIn.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedEntityStreamIn): ReplicatedEntityStreamIn.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedEntityStreamIn, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedEntityStreamIn;
    static deserializeBinaryFromReader(message: ReplicatedEntityStreamIn, reader: jspb.BinaryReader): ReplicatedEntityStreamIn;
}

export namespace ReplicatedEntityStreamIn {
    export type AsObject = {
        init?: ReplicatedEntityInit.AsObject,
        delta?: ReplicatedEntityDelta.AsObject,
        pb_delete?: ReplicatedEntityDelete.AsObject,
        command?: akkaserverless_component_entity_entity_pb.Command.AsObject,
    }

    export enum MessageCase {
        MESSAGE_NOT_SET = 0,
        INIT = 1,
        DELTA = 2,
        DELETE = 3,
        COMMAND = 4,
    }

}

export class ReplicatedEntityStreamOut extends jspb.Message { 

    hasReply(): boolean;
    clearReply(): void;
    getReply(): ReplicatedEntityReply | undefined;
    setReply(value?: ReplicatedEntityReply): ReplicatedEntityStreamOut;

    hasFailure(): boolean;
    clearFailure(): void;
    getFailure(): akkaserverless_component_component_pb.Failure | undefined;
    setFailure(value?: akkaserverless_component_component_pb.Failure): ReplicatedEntityStreamOut;

    getMessageCase(): ReplicatedEntityStreamOut.MessageCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedEntityStreamOut.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedEntityStreamOut): ReplicatedEntityStreamOut.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedEntityStreamOut, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedEntityStreamOut;
    static deserializeBinaryFromReader(message: ReplicatedEntityStreamOut, reader: jspb.BinaryReader): ReplicatedEntityStreamOut;
}

export namespace ReplicatedEntityStreamOut {
    export type AsObject = {
        reply?: ReplicatedEntityReply.AsObject,
        failure?: akkaserverless_component_component_pb.Failure.AsObject,
    }

    export enum MessageCase {
        MESSAGE_NOT_SET = 0,
        REPLY = 1,
        FAILURE = 2,
    }

}

export class ReplicatedEntityDelta extends jspb.Message { 

    hasCounter(): boolean;
    clearCounter(): void;
    getCounter(): ReplicatedCounterDelta | undefined;
    setCounter(value?: ReplicatedCounterDelta): ReplicatedEntityDelta;

    hasReplicatedSet(): boolean;
    clearReplicatedSet(): void;
    getReplicatedSet(): ReplicatedSetDelta | undefined;
    setReplicatedSet(value?: ReplicatedSetDelta): ReplicatedEntityDelta;

    hasRegister(): boolean;
    clearRegister(): void;
    getRegister(): ReplicatedRegisterDelta | undefined;
    setRegister(value?: ReplicatedRegisterDelta): ReplicatedEntityDelta;

    hasReplicatedMap(): boolean;
    clearReplicatedMap(): void;
    getReplicatedMap(): ReplicatedMapDelta | undefined;
    setReplicatedMap(value?: ReplicatedMapDelta): ReplicatedEntityDelta;

    hasReplicatedCounterMap(): boolean;
    clearReplicatedCounterMap(): void;
    getReplicatedCounterMap(): ReplicatedCounterMapDelta | undefined;
    setReplicatedCounterMap(value?: ReplicatedCounterMapDelta): ReplicatedEntityDelta;

    hasReplicatedRegisterMap(): boolean;
    clearReplicatedRegisterMap(): void;
    getReplicatedRegisterMap(): ReplicatedRegisterMapDelta | undefined;
    setReplicatedRegisterMap(value?: ReplicatedRegisterMapDelta): ReplicatedEntityDelta;

    hasReplicatedMultiMap(): boolean;
    clearReplicatedMultiMap(): void;
    getReplicatedMultiMap(): ReplicatedMultiMapDelta | undefined;
    setReplicatedMultiMap(value?: ReplicatedMultiMapDelta): ReplicatedEntityDelta;

    hasVote(): boolean;
    clearVote(): void;
    getVote(): VoteDelta | undefined;
    setVote(value?: VoteDelta): ReplicatedEntityDelta;

    getDeltaCase(): ReplicatedEntityDelta.DeltaCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedEntityDelta.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedEntityDelta): ReplicatedEntityDelta.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedEntityDelta, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedEntityDelta;
    static deserializeBinaryFromReader(message: ReplicatedEntityDelta, reader: jspb.BinaryReader): ReplicatedEntityDelta;
}

export namespace ReplicatedEntityDelta {
    export type AsObject = {
        counter?: ReplicatedCounterDelta.AsObject,
        replicatedSet?: ReplicatedSetDelta.AsObject,
        register?: ReplicatedRegisterDelta.AsObject,
        replicatedMap?: ReplicatedMapDelta.AsObject,
        replicatedCounterMap?: ReplicatedCounterMapDelta.AsObject,
        replicatedRegisterMap?: ReplicatedRegisterMapDelta.AsObject,
        replicatedMultiMap?: ReplicatedMultiMapDelta.AsObject,
        vote?: VoteDelta.AsObject,
    }

    export enum DeltaCase {
        DELTA_NOT_SET = 0,
        COUNTER = 1,
        REPLICATED_SET = 2,
        REGISTER = 3,
        REPLICATED_MAP = 4,
        REPLICATED_COUNTER_MAP = 5,
        REPLICATED_REGISTER_MAP = 6,
        REPLICATED_MULTI_MAP = 7,
        VOTE = 8,
    }

}

export class ReplicatedCounterDelta extends jspb.Message { 
    getChange(): number;
    setChange(value: number): ReplicatedCounterDelta;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedCounterDelta.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedCounterDelta): ReplicatedCounterDelta.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedCounterDelta, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedCounterDelta;
    static deserializeBinaryFromReader(message: ReplicatedCounterDelta, reader: jspb.BinaryReader): ReplicatedCounterDelta;
}

export namespace ReplicatedCounterDelta {
    export type AsObject = {
        change: number,
    }
}

export class ReplicatedSetDelta extends jspb.Message { 
    getCleared(): boolean;
    setCleared(value: boolean): ReplicatedSetDelta;
    clearRemovedList(): void;
    getRemovedList(): Array<google_protobuf_any_pb.Any>;
    setRemovedList(value: Array<google_protobuf_any_pb.Any>): ReplicatedSetDelta;
    addRemoved(value?: google_protobuf_any_pb.Any, index?: number): google_protobuf_any_pb.Any;
    clearAddedList(): void;
    getAddedList(): Array<google_protobuf_any_pb.Any>;
    setAddedList(value: Array<google_protobuf_any_pb.Any>): ReplicatedSetDelta;
    addAdded(value?: google_protobuf_any_pb.Any, index?: number): google_protobuf_any_pb.Any;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedSetDelta.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedSetDelta): ReplicatedSetDelta.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedSetDelta, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedSetDelta;
    static deserializeBinaryFromReader(message: ReplicatedSetDelta, reader: jspb.BinaryReader): ReplicatedSetDelta;
}

export namespace ReplicatedSetDelta {
    export type AsObject = {
        cleared: boolean,
        removedList: Array<google_protobuf_any_pb.Any.AsObject>,
        addedList: Array<google_protobuf_any_pb.Any.AsObject>,
    }
}

export class ReplicatedRegisterDelta extends jspb.Message { 

    hasValue(): boolean;
    clearValue(): void;
    getValue(): google_protobuf_any_pb.Any | undefined;
    setValue(value?: google_protobuf_any_pb.Any): ReplicatedRegisterDelta;
    getClock(): ReplicatedEntityClock;
    setClock(value: ReplicatedEntityClock): ReplicatedRegisterDelta;
    getCustomClockValue(): number;
    setCustomClockValue(value: number): ReplicatedRegisterDelta;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedRegisterDelta.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedRegisterDelta): ReplicatedRegisterDelta.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedRegisterDelta, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedRegisterDelta;
    static deserializeBinaryFromReader(message: ReplicatedRegisterDelta, reader: jspb.BinaryReader): ReplicatedRegisterDelta;
}

export namespace ReplicatedRegisterDelta {
    export type AsObject = {
        value?: google_protobuf_any_pb.Any.AsObject,
        clock: ReplicatedEntityClock,
        customClockValue: number,
    }
}

export class ReplicatedMapDelta extends jspb.Message { 
    getCleared(): boolean;
    setCleared(value: boolean): ReplicatedMapDelta;
    clearRemovedList(): void;
    getRemovedList(): Array<google_protobuf_any_pb.Any>;
    setRemovedList(value: Array<google_protobuf_any_pb.Any>): ReplicatedMapDelta;
    addRemoved(value?: google_protobuf_any_pb.Any, index?: number): google_protobuf_any_pb.Any;
    clearUpdatedList(): void;
    getUpdatedList(): Array<ReplicatedMapEntryDelta>;
    setUpdatedList(value: Array<ReplicatedMapEntryDelta>): ReplicatedMapDelta;
    addUpdated(value?: ReplicatedMapEntryDelta, index?: number): ReplicatedMapEntryDelta;
    clearAddedList(): void;
    getAddedList(): Array<ReplicatedMapEntryDelta>;
    setAddedList(value: Array<ReplicatedMapEntryDelta>): ReplicatedMapDelta;
    addAdded(value?: ReplicatedMapEntryDelta, index?: number): ReplicatedMapEntryDelta;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedMapDelta.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedMapDelta): ReplicatedMapDelta.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedMapDelta, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedMapDelta;
    static deserializeBinaryFromReader(message: ReplicatedMapDelta, reader: jspb.BinaryReader): ReplicatedMapDelta;
}

export namespace ReplicatedMapDelta {
    export type AsObject = {
        cleared: boolean,
        removedList: Array<google_protobuf_any_pb.Any.AsObject>,
        updatedList: Array<ReplicatedMapEntryDelta.AsObject>,
        addedList: Array<ReplicatedMapEntryDelta.AsObject>,
    }
}

export class ReplicatedMapEntryDelta extends jspb.Message { 

    hasKey(): boolean;
    clearKey(): void;
    getKey(): google_protobuf_any_pb.Any | undefined;
    setKey(value?: google_protobuf_any_pb.Any): ReplicatedMapEntryDelta;

    hasDelta(): boolean;
    clearDelta(): void;
    getDelta(): ReplicatedEntityDelta | undefined;
    setDelta(value?: ReplicatedEntityDelta): ReplicatedMapEntryDelta;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedMapEntryDelta.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedMapEntryDelta): ReplicatedMapEntryDelta.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedMapEntryDelta, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedMapEntryDelta;
    static deserializeBinaryFromReader(message: ReplicatedMapEntryDelta, reader: jspb.BinaryReader): ReplicatedMapEntryDelta;
}

export namespace ReplicatedMapEntryDelta {
    export type AsObject = {
        key?: google_protobuf_any_pb.Any.AsObject,
        delta?: ReplicatedEntityDelta.AsObject,
    }
}

export class ReplicatedCounterMapDelta extends jspb.Message { 
    getCleared(): boolean;
    setCleared(value: boolean): ReplicatedCounterMapDelta;
    clearRemovedList(): void;
    getRemovedList(): Array<google_protobuf_any_pb.Any>;
    setRemovedList(value: Array<google_protobuf_any_pb.Any>): ReplicatedCounterMapDelta;
    addRemoved(value?: google_protobuf_any_pb.Any, index?: number): google_protobuf_any_pb.Any;
    clearUpdatedList(): void;
    getUpdatedList(): Array<ReplicatedCounterMapEntryDelta>;
    setUpdatedList(value: Array<ReplicatedCounterMapEntryDelta>): ReplicatedCounterMapDelta;
    addUpdated(value?: ReplicatedCounterMapEntryDelta, index?: number): ReplicatedCounterMapEntryDelta;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedCounterMapDelta.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedCounterMapDelta): ReplicatedCounterMapDelta.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedCounterMapDelta, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedCounterMapDelta;
    static deserializeBinaryFromReader(message: ReplicatedCounterMapDelta, reader: jspb.BinaryReader): ReplicatedCounterMapDelta;
}

export namespace ReplicatedCounterMapDelta {
    export type AsObject = {
        cleared: boolean,
        removedList: Array<google_protobuf_any_pb.Any.AsObject>,
        updatedList: Array<ReplicatedCounterMapEntryDelta.AsObject>,
    }
}

export class ReplicatedCounterMapEntryDelta extends jspb.Message { 

    hasKey(): boolean;
    clearKey(): void;
    getKey(): google_protobuf_any_pb.Any | undefined;
    setKey(value?: google_protobuf_any_pb.Any): ReplicatedCounterMapEntryDelta;

    hasDelta(): boolean;
    clearDelta(): void;
    getDelta(): ReplicatedCounterDelta | undefined;
    setDelta(value?: ReplicatedCounterDelta): ReplicatedCounterMapEntryDelta;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedCounterMapEntryDelta.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedCounterMapEntryDelta): ReplicatedCounterMapEntryDelta.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedCounterMapEntryDelta, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedCounterMapEntryDelta;
    static deserializeBinaryFromReader(message: ReplicatedCounterMapEntryDelta, reader: jspb.BinaryReader): ReplicatedCounterMapEntryDelta;
}

export namespace ReplicatedCounterMapEntryDelta {
    export type AsObject = {
        key?: google_protobuf_any_pb.Any.AsObject,
        delta?: ReplicatedCounterDelta.AsObject,
    }
}

export class ReplicatedRegisterMapDelta extends jspb.Message { 
    getCleared(): boolean;
    setCleared(value: boolean): ReplicatedRegisterMapDelta;
    clearRemovedList(): void;
    getRemovedList(): Array<google_protobuf_any_pb.Any>;
    setRemovedList(value: Array<google_protobuf_any_pb.Any>): ReplicatedRegisterMapDelta;
    addRemoved(value?: google_protobuf_any_pb.Any, index?: number): google_protobuf_any_pb.Any;
    clearUpdatedList(): void;
    getUpdatedList(): Array<ReplicatedRegisterMapEntryDelta>;
    setUpdatedList(value: Array<ReplicatedRegisterMapEntryDelta>): ReplicatedRegisterMapDelta;
    addUpdated(value?: ReplicatedRegisterMapEntryDelta, index?: number): ReplicatedRegisterMapEntryDelta;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedRegisterMapDelta.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedRegisterMapDelta): ReplicatedRegisterMapDelta.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedRegisterMapDelta, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedRegisterMapDelta;
    static deserializeBinaryFromReader(message: ReplicatedRegisterMapDelta, reader: jspb.BinaryReader): ReplicatedRegisterMapDelta;
}

export namespace ReplicatedRegisterMapDelta {
    export type AsObject = {
        cleared: boolean,
        removedList: Array<google_protobuf_any_pb.Any.AsObject>,
        updatedList: Array<ReplicatedRegisterMapEntryDelta.AsObject>,
    }
}

export class ReplicatedRegisterMapEntryDelta extends jspb.Message { 

    hasKey(): boolean;
    clearKey(): void;
    getKey(): google_protobuf_any_pb.Any | undefined;
    setKey(value?: google_protobuf_any_pb.Any): ReplicatedRegisterMapEntryDelta;

    hasDelta(): boolean;
    clearDelta(): void;
    getDelta(): ReplicatedRegisterDelta | undefined;
    setDelta(value?: ReplicatedRegisterDelta): ReplicatedRegisterMapEntryDelta;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedRegisterMapEntryDelta.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedRegisterMapEntryDelta): ReplicatedRegisterMapEntryDelta.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedRegisterMapEntryDelta, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedRegisterMapEntryDelta;
    static deserializeBinaryFromReader(message: ReplicatedRegisterMapEntryDelta, reader: jspb.BinaryReader): ReplicatedRegisterMapEntryDelta;
}

export namespace ReplicatedRegisterMapEntryDelta {
    export type AsObject = {
        key?: google_protobuf_any_pb.Any.AsObject,
        delta?: ReplicatedRegisterDelta.AsObject,
    }
}

export class ReplicatedMultiMapDelta extends jspb.Message { 
    getCleared(): boolean;
    setCleared(value: boolean): ReplicatedMultiMapDelta;
    clearRemovedList(): void;
    getRemovedList(): Array<google_protobuf_any_pb.Any>;
    setRemovedList(value: Array<google_protobuf_any_pb.Any>): ReplicatedMultiMapDelta;
    addRemoved(value?: google_protobuf_any_pb.Any, index?: number): google_protobuf_any_pb.Any;
    clearUpdatedList(): void;
    getUpdatedList(): Array<ReplicatedMultiMapEntryDelta>;
    setUpdatedList(value: Array<ReplicatedMultiMapEntryDelta>): ReplicatedMultiMapDelta;
    addUpdated(value?: ReplicatedMultiMapEntryDelta, index?: number): ReplicatedMultiMapEntryDelta;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedMultiMapDelta.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedMultiMapDelta): ReplicatedMultiMapDelta.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedMultiMapDelta, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedMultiMapDelta;
    static deserializeBinaryFromReader(message: ReplicatedMultiMapDelta, reader: jspb.BinaryReader): ReplicatedMultiMapDelta;
}

export namespace ReplicatedMultiMapDelta {
    export type AsObject = {
        cleared: boolean,
        removedList: Array<google_protobuf_any_pb.Any.AsObject>,
        updatedList: Array<ReplicatedMultiMapEntryDelta.AsObject>,
    }
}

export class ReplicatedMultiMapEntryDelta extends jspb.Message { 

    hasKey(): boolean;
    clearKey(): void;
    getKey(): google_protobuf_any_pb.Any | undefined;
    setKey(value?: google_protobuf_any_pb.Any): ReplicatedMultiMapEntryDelta;

    hasDelta(): boolean;
    clearDelta(): void;
    getDelta(): ReplicatedSetDelta | undefined;
    setDelta(value?: ReplicatedSetDelta): ReplicatedMultiMapEntryDelta;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedMultiMapEntryDelta.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedMultiMapEntryDelta): ReplicatedMultiMapEntryDelta.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedMultiMapEntryDelta, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedMultiMapEntryDelta;
    static deserializeBinaryFromReader(message: ReplicatedMultiMapEntryDelta, reader: jspb.BinaryReader): ReplicatedMultiMapEntryDelta;
}

export namespace ReplicatedMultiMapEntryDelta {
    export type AsObject = {
        key?: google_protobuf_any_pb.Any.AsObject,
        delta?: ReplicatedSetDelta.AsObject,
    }
}

export class VoteDelta extends jspb.Message { 
    getSelfVote(): boolean;
    setSelfVote(value: boolean): VoteDelta;
    getVotesFor(): number;
    setVotesFor(value: number): VoteDelta;
    getTotalVoters(): number;
    setTotalVoters(value: number): VoteDelta;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): VoteDelta.AsObject;
    static toObject(includeInstance: boolean, msg: VoteDelta): VoteDelta.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: VoteDelta, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): VoteDelta;
    static deserializeBinaryFromReader(message: VoteDelta, reader: jspb.BinaryReader): VoteDelta;
}

export namespace VoteDelta {
    export type AsObject = {
        selfVote: boolean,
        votesFor: number,
        totalVoters: number,
    }
}

export class ReplicatedEntityInit extends jspb.Message { 
    getServiceName(): string;
    setServiceName(value: string): ReplicatedEntityInit;
    getEntityId(): string;
    setEntityId(value: string): ReplicatedEntityInit;

    hasDelta(): boolean;
    clearDelta(): void;
    getDelta(): ReplicatedEntityDelta | undefined;
    setDelta(value?: ReplicatedEntityDelta): ReplicatedEntityInit;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedEntityInit.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedEntityInit): ReplicatedEntityInit.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedEntityInit, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedEntityInit;
    static deserializeBinaryFromReader(message: ReplicatedEntityInit, reader: jspb.BinaryReader): ReplicatedEntityInit;
}

export namespace ReplicatedEntityInit {
    export type AsObject = {
        serviceName: string,
        entityId: string,
        delta?: ReplicatedEntityDelta.AsObject,
    }
}

export class ReplicatedEntityDelete extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedEntityDelete.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedEntityDelete): ReplicatedEntityDelete.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedEntityDelete, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedEntityDelete;
    static deserializeBinaryFromReader(message: ReplicatedEntityDelete, reader: jspb.BinaryReader): ReplicatedEntityDelete;
}

export namespace ReplicatedEntityDelete {
    export type AsObject = {
    }
}

export class ReplicatedEntityReply extends jspb.Message { 
    getCommandId(): number;
    setCommandId(value: number): ReplicatedEntityReply;

    hasClientAction(): boolean;
    clearClientAction(): void;
    getClientAction(): akkaserverless_component_component_pb.ClientAction | undefined;
    setClientAction(value?: akkaserverless_component_component_pb.ClientAction): ReplicatedEntityReply;
    clearSideEffectsList(): void;
    getSideEffectsList(): Array<akkaserverless_component_component_pb.SideEffect>;
    setSideEffectsList(value: Array<akkaserverless_component_component_pb.SideEffect>): ReplicatedEntityReply;
    addSideEffects(value?: akkaserverless_component_component_pb.SideEffect, index?: number): akkaserverless_component_component_pb.SideEffect;

    hasStateAction(): boolean;
    clearStateAction(): void;
    getStateAction(): ReplicatedEntityStateAction | undefined;
    setStateAction(value?: ReplicatedEntityStateAction): ReplicatedEntityReply;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedEntityReply.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedEntityReply): ReplicatedEntityReply.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedEntityReply, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedEntityReply;
    static deserializeBinaryFromReader(message: ReplicatedEntityReply, reader: jspb.BinaryReader): ReplicatedEntityReply;
}

export namespace ReplicatedEntityReply {
    export type AsObject = {
        commandId: number,
        clientAction?: akkaserverless_component_component_pb.ClientAction.AsObject,
        sideEffectsList: Array<akkaserverless_component_component_pb.SideEffect.AsObject>,
        stateAction?: ReplicatedEntityStateAction.AsObject,
    }
}

export class ReplicatedEntityStateAction extends jspb.Message { 

    hasUpdate(): boolean;
    clearUpdate(): void;
    getUpdate(): ReplicatedEntityDelta | undefined;
    setUpdate(value?: ReplicatedEntityDelta): ReplicatedEntityStateAction;

    hasDelete(): boolean;
    clearDelete(): void;
    getDelete(): ReplicatedEntityDelete | undefined;
    setDelete(value?: ReplicatedEntityDelete): ReplicatedEntityStateAction;

    getActionCase(): ReplicatedEntityStateAction.ActionCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReplicatedEntityStateAction.AsObject;
    static toObject(includeInstance: boolean, msg: ReplicatedEntityStateAction): ReplicatedEntityStateAction.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReplicatedEntityStateAction, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReplicatedEntityStateAction;
    static deserializeBinaryFromReader(message: ReplicatedEntityStateAction, reader: jspb.BinaryReader): ReplicatedEntityStateAction;
}

export namespace ReplicatedEntityStateAction {
    export type AsObject = {
        update?: ReplicatedEntityDelta.AsObject,
        pb_delete?: ReplicatedEntityDelete.AsObject,
    }

    export enum ActionCase {
        ACTION_NOT_SET = 0,
        UPDATE = 1,
        DELETE = 2,
    }

}

export enum ReplicatedEntityClock {
    REPLICATED_ENTITY_CLOCK_DEFAULT_UNSPECIFIED = 0,
    REPLICATED_ENTITY_CLOCK_REVERSE = 1,
    REPLICATED_ENTITY_CLOCK_CUSTOM = 2,
    REPLICATED_ENTITY_CLOCK_CUSTOM_AUTO_INCREMENT = 3,
}