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

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

import * as jspb from "google-protobuf";

export class ActionDef extends jspb.Message { 
    getName(): string;
    setName(value: string): ActionDef;

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

export namespace ActionDef {
    export type AsObject = {
        name: string,
    }
}

export class ViewDef extends jspb.Message { 
    getName(): string;
    setName(value: string): ViewDef;

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

export namespace ViewDef {
    export type AsObject = {
        name: string,
    }
}

export class EventSourcedEntityDef extends jspb.Message { 
    getName(): string;
    setName(value: string): EventSourcedEntityDef;
    getEntityType(): string;
    setEntityType(value: string): EventSourcedEntityDef;
    getState(): string;
    setState(value: string): EventSourcedEntityDef;
    clearEventsList(): void;
    getEventsList(): Array<string>;
    setEventsList(value: Array<string>): EventSourcedEntityDef;
    addEvents(value: string, index?: number): string;

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

export namespace EventSourcedEntityDef {
    export type AsObject = {
        name: string,
        entityType: string,
        state: string,
        eventsList: Array<string>,
    }
}

export class ValueEntityDef extends jspb.Message { 
    getName(): string;
    setName(value: string): ValueEntityDef;
    getEntityType(): string;
    setEntityType(value: string): ValueEntityDef;
    getState(): string;
    setState(value: string): ValueEntityDef;

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

export namespace ValueEntityDef {
    export type AsObject = {
        name: string,
        entityType: string,
        state: string,
    }
}

export class ReplicatedEntityDef extends jspb.Message { 
    getName(): string;
    setName(value: string): ReplicatedEntityDef;
    getEntityType(): string;
    setEntityType(value: string): ReplicatedEntityDef;

    hasReplicatedCounter(): boolean;
    clearReplicatedCounter(): void;
    getReplicatedCounter(): ReplicatedCounterDef | undefined;
    setReplicatedCounter(value?: ReplicatedCounterDef): ReplicatedEntityDef;

    hasReplicatedRegister(): boolean;
    clearReplicatedRegister(): void;
    getReplicatedRegister(): ReplicatedRegisterDef | undefined;
    setReplicatedRegister(value?: ReplicatedRegisterDef): ReplicatedEntityDef;

    hasReplicatedSet(): boolean;
    clearReplicatedSet(): void;
    getReplicatedSet(): ReplicatedSetDef | undefined;
    setReplicatedSet(value?: ReplicatedSetDef): ReplicatedEntityDef;

    hasReplicatedMap(): boolean;
    clearReplicatedMap(): void;
    getReplicatedMap(): ReplicatedMapDef | undefined;
    setReplicatedMap(value?: ReplicatedMapDef): ReplicatedEntityDef;

    hasReplicatedCounterMap(): boolean;
    clearReplicatedCounterMap(): void;
    getReplicatedCounterMap(): ReplicatedCounterMapDef | undefined;
    setReplicatedCounterMap(value?: ReplicatedCounterMapDef): ReplicatedEntityDef;

    hasReplicatedRegisterMap(): boolean;
    clearReplicatedRegisterMap(): void;
    getReplicatedRegisterMap(): ReplicatedRegisterMapDef | undefined;
    setReplicatedRegisterMap(value?: ReplicatedRegisterMapDef): ReplicatedEntityDef;

    hasReplicatedMultiMap(): boolean;
    clearReplicatedMultiMap(): void;
    getReplicatedMultiMap(): ReplicatedMultiMapDef | undefined;
    setReplicatedMultiMap(value?: ReplicatedMultiMapDef): ReplicatedEntityDef;

    hasReplicatedVote(): boolean;
    clearReplicatedVote(): void;
    getReplicatedVote(): ReplicatedVoteDef | undefined;
    setReplicatedVote(value?: ReplicatedVoteDef): ReplicatedEntityDef;

    getReplicatedDataCase(): ReplicatedEntityDef.ReplicatedDataCase;

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

export namespace ReplicatedEntityDef {
    export type AsObject = {
        name: string,
        entityType: string,
        replicatedCounter?: ReplicatedCounterDef.AsObject,
        replicatedRegister?: ReplicatedRegisterDef.AsObject,
        replicatedSet?: ReplicatedSetDef.AsObject,
        replicatedMap?: ReplicatedMapDef.AsObject,
        replicatedCounterMap?: ReplicatedCounterMapDef.AsObject,
        replicatedRegisterMap?: ReplicatedRegisterMapDef.AsObject,
        replicatedMultiMap?: ReplicatedMultiMapDef.AsObject,
        replicatedVote?: ReplicatedVoteDef.AsObject,
    }

    export enum ReplicatedDataCase {
        REPLICATED_DATA_NOT_SET = 0,
        REPLICATED_COUNTER = 3,
        REPLICATED_REGISTER = 4,
        REPLICATED_SET = 5,
        REPLICATED_MAP = 6,
        REPLICATED_COUNTER_MAP = 7,
        REPLICATED_REGISTER_MAP = 8,
        REPLICATED_MULTI_MAP = 9,
        REPLICATED_VOTE = 10,
    }

}

export class ReplicatedCounterDef extends jspb.Message { 

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

export namespace ReplicatedCounterDef {
    export type AsObject = {
    }
}

export class ReplicatedRegisterDef extends jspb.Message { 
    getValue(): string;
    setValue(value: string): ReplicatedRegisterDef;

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

export namespace ReplicatedRegisterDef {
    export type AsObject = {
        value: string,
    }
}

export class ReplicatedSetDef extends jspb.Message { 
    getElement(): string;
    setElement(value: string): ReplicatedSetDef;

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

export namespace ReplicatedSetDef {
    export type AsObject = {
        element: string,
    }
}

export class ReplicatedMapDef extends jspb.Message { 
    getKey(): string;
    setKey(value: string): ReplicatedMapDef;

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

export namespace ReplicatedMapDef {
    export type AsObject = {
        key: string,
    }
}

export class ReplicatedCounterMapDef extends jspb.Message { 
    getKey(): string;
    setKey(value: string): ReplicatedCounterMapDef;

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

export namespace ReplicatedCounterMapDef {
    export type AsObject = {
        key: string,
    }
}

export class ReplicatedRegisterMapDef extends jspb.Message { 
    getKey(): string;
    setKey(value: string): ReplicatedRegisterMapDef;
    getValue(): string;
    setValue(value: string): ReplicatedRegisterMapDef;

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

export namespace ReplicatedRegisterMapDef {
    export type AsObject = {
        key: string,
        value: string,
    }
}

export class ReplicatedMultiMapDef extends jspb.Message { 
    getKey(): string;
    setKey(value: string): ReplicatedMultiMapDef;
    getValue(): string;
    setValue(value: string): ReplicatedMultiMapDef;

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

export namespace ReplicatedMultiMapDef {
    export type AsObject = {
        key: string,
        value: string,
    }
}

export class ReplicatedVoteDef extends jspb.Message { 

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

export namespace ReplicatedVoteDef {
    export type AsObject = {
    }
}

export class EventSourcedEntity extends jspb.Message { 
    getName(): string;
    setName(value: string): EventSourcedEntity;
    getEntityType(): string;
    setEntityType(value: string): EventSourcedEntity;
    getState(): string;
    setState(value: string): EventSourcedEntity;
    clearEventsList(): void;
    getEventsList(): Array<string>;
    setEventsList(value: Array<string>): EventSourcedEntity;
    addEvents(value: string, index?: number): string;

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

export namespace EventSourcedEntity {
    export type AsObject = {
        name: string,
        entityType: string,
        state: string,
        eventsList: Array<string>,
    }
}

export class ValueEntity extends jspb.Message { 
    getName(): string;
    setName(value: string): ValueEntity;
    getEntityType(): string;
    setEntityType(value: string): ValueEntity;
    getState(): string;
    setState(value: string): ValueEntity;

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

export namespace ValueEntity {
    export type AsObject = {
        name: string,
        entityType: string,
        state: string,
    }
}

export class ReplicatedEntity extends jspb.Message { 
    getName(): string;
    setName(value: string): ReplicatedEntity;
    getEntityType(): string;
    setEntityType(value: string): ReplicatedEntity;

    hasReplicatedCounter(): boolean;
    clearReplicatedCounter(): void;
    getReplicatedCounter(): ReplicatedCounter | undefined;
    setReplicatedCounter(value?: ReplicatedCounter): ReplicatedEntity;

    hasReplicatedRegister(): boolean;
    clearReplicatedRegister(): void;
    getReplicatedRegister(): ReplicatedRegister | undefined;
    setReplicatedRegister(value?: ReplicatedRegister): ReplicatedEntity;

    hasReplicatedSet(): boolean;
    clearReplicatedSet(): void;
    getReplicatedSet(): ReplicatedSet | undefined;
    setReplicatedSet(value?: ReplicatedSet): ReplicatedEntity;

    hasReplicatedMap(): boolean;
    clearReplicatedMap(): void;
    getReplicatedMap(): ReplicatedMap | undefined;
    setReplicatedMap(value?: ReplicatedMap): ReplicatedEntity;

    hasReplicatedCounterMap(): boolean;
    clearReplicatedCounterMap(): void;
    getReplicatedCounterMap(): ReplicatedCounterMap | undefined;
    setReplicatedCounterMap(value?: ReplicatedCounterMap): ReplicatedEntity;

    hasReplicatedRegisterMap(): boolean;
    clearReplicatedRegisterMap(): void;
    getReplicatedRegisterMap(): ReplicatedRegisterMap | undefined;
    setReplicatedRegisterMap(value?: ReplicatedRegisterMap): ReplicatedEntity;

    hasReplicatedMultiMap(): boolean;
    clearReplicatedMultiMap(): void;
    getReplicatedMultiMap(): ReplicatedMultiMap | undefined;
    setReplicatedMultiMap(value?: ReplicatedMultiMap): ReplicatedEntity;

    hasReplicatedVote(): boolean;
    clearReplicatedVote(): void;
    getReplicatedVote(): ReplicatedVote | undefined;
    setReplicatedVote(value?: ReplicatedVote): ReplicatedEntity;

    getReplicatedDataCase(): ReplicatedEntity.ReplicatedDataCase;

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

export namespace ReplicatedEntity {
    export type AsObject = {
        name: string,
        entityType: string,
        replicatedCounter?: ReplicatedCounter.AsObject,
        replicatedRegister?: ReplicatedRegister.AsObject,
        replicatedSet?: ReplicatedSet.AsObject,
        replicatedMap?: ReplicatedMap.AsObject,
        replicatedCounterMap?: ReplicatedCounterMap.AsObject,
        replicatedRegisterMap?: ReplicatedRegisterMap.AsObject,
        replicatedMultiMap?: ReplicatedMultiMap.AsObject,
        replicatedVote?: ReplicatedVote.AsObject,
    }

    export enum ReplicatedDataCase {
        REPLICATED_DATA_NOT_SET = 0,
        REPLICATED_COUNTER = 3,
        REPLICATED_REGISTER = 4,
        REPLICATED_SET = 5,
        REPLICATED_MAP = 6,
        REPLICATED_COUNTER_MAP = 7,
        REPLICATED_REGISTER_MAP = 8,
        REPLICATED_MULTI_MAP = 9,
        REPLICATED_VOTE = 10,
    }

}

export class ReplicatedCounter extends jspb.Message { 

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

export namespace ReplicatedCounter {
    export type AsObject = {
    }
}

export class ReplicatedRegister extends jspb.Message { 
    getValue(): string;
    setValue(value: string): ReplicatedRegister;

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

export namespace ReplicatedRegister {
    export type AsObject = {
        value: string,
    }
}

export class ReplicatedSet extends jspb.Message { 
    getElement(): string;
    setElement(value: string): ReplicatedSet;

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

export namespace ReplicatedSet {
    export type AsObject = {
        element: string,
    }
}

export class ReplicatedMap extends jspb.Message { 
    getKey(): string;
    setKey(value: string): ReplicatedMap;

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

export namespace ReplicatedMap {
    export type AsObject = {
        key: string,
    }
}

export class ReplicatedCounterMap extends jspb.Message { 
    getKey(): string;
    setKey(value: string): ReplicatedCounterMap;

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

export namespace ReplicatedCounterMap {
    export type AsObject = {
        key: string,
    }
}

export class ReplicatedRegisterMap extends jspb.Message { 
    getKey(): string;
    setKey(value: string): ReplicatedRegisterMap;
    getValue(): string;
    setValue(value: string): ReplicatedRegisterMap;

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

export namespace ReplicatedRegisterMap {
    export type AsObject = {
        key: string,
        value: string,
    }
}

export class ReplicatedMultiMap extends jspb.Message { 
    getKey(): string;
    setKey(value: string): ReplicatedMultiMap;
    getValue(): string;
    setValue(value: string): ReplicatedMultiMap;

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

export namespace ReplicatedMultiMap {
    export type AsObject = {
        key: string,
        value: string,
    }
}

export class ReplicatedVote extends jspb.Message { 

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

export namespace ReplicatedVote {
    export type AsObject = {
    }
}