@kurrent/kurrentdb-client 1.0.0-alpha.1

package/generated/projections_pb.d.ts

@@ -0,0 +1,821 @@
+// package: event_store.client.projections
+// file: projections.proto
+
+/* tslint:disable */
+/* eslint-disable */
+
+import * as jspb from "google-protobuf";
+import * as google_protobuf_struct_pb from "google-protobuf/google/protobuf/struct_pb";
+import * as shared_pb from "./shared_pb";
+
+export class CreateReq extends jspb.Message { 
+
+    hasOptions(): boolean;
+    clearOptions(): void;
+    getOptions(): CreateReq.Options | undefined;
+    setOptions(value?: CreateReq.Options): CreateReq;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CreateReq.AsObject;
+    static toObject(includeInstance: boolean, msg: CreateReq): CreateReq.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CreateReq, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CreateReq;
+    static deserializeBinaryFromReader(message: CreateReq, reader: jspb.BinaryReader): CreateReq;
+}
+
+export namespace CreateReq {
+    export type AsObject = {
+        options?: CreateReq.Options.AsObject,
+    }
+
+
+    export class Options extends jspb.Message { 
+
+        hasOneTime(): boolean;
+        clearOneTime(): void;
+        getOneTime(): shared_pb.Empty | undefined;
+        setOneTime(value?: shared_pb.Empty): Options;
+
+        hasTransient(): boolean;
+        clearTransient(): void;
+        getTransient(): CreateReq.Options.Transient | undefined;
+        setTransient(value?: CreateReq.Options.Transient): Options;
+
+        hasContinuous(): boolean;
+        clearContinuous(): void;
+        getContinuous(): CreateReq.Options.Continuous | undefined;
+        setContinuous(value?: CreateReq.Options.Continuous): Options;
+        getQuery(): string;
+        setQuery(value: string): Options;
+
+        getModeCase(): Options.ModeCase;
+
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): Options.AsObject;
+        static toObject(includeInstance: boolean, msg: Options): Options.AsObject;
+        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+        static serializeBinaryToWriter(message: Options, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): Options;
+        static deserializeBinaryFromReader(message: Options, reader: jspb.BinaryReader): Options;
+    }
+
+    export namespace Options {
+        export type AsObject = {
+            oneTime?: shared_pb.Empty.AsObject,
+            pb_transient?: CreateReq.Options.Transient.AsObject,
+            continuous?: CreateReq.Options.Continuous.AsObject,
+            query: string,
+        }
+
+
+        export class Transient extends jspb.Message { 
+            getName(): string;
+            setName(value: string): Transient;
+
+            serializeBinary(): Uint8Array;
+            toObject(includeInstance?: boolean): Transient.AsObject;
+            static toObject(includeInstance: boolean, msg: Transient): Transient.AsObject;
+            static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+            static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+            static serializeBinaryToWriter(message: Transient, writer: jspb.BinaryWriter): void;
+            static deserializeBinary(bytes: Uint8Array): Transient;
+            static deserializeBinaryFromReader(message: Transient, reader: jspb.BinaryReader): Transient;
+        }
+
+        export namespace Transient {
+            export type AsObject = {
+                name: string,
+            }
+        }
+
+        export class Continuous extends jspb.Message { 
+            getName(): string;
+            setName(value: string): Continuous;
+            getEmitEnabled(): boolean;
+            setEmitEnabled(value: boolean): Continuous;
+            getTrackEmittedStreams(): boolean;
+            setTrackEmittedStreams(value: boolean): Continuous;
+
+            serializeBinary(): Uint8Array;
+            toObject(includeInstance?: boolean): Continuous.AsObject;
+            static toObject(includeInstance: boolean, msg: Continuous): Continuous.AsObject;
+            static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+            static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+            static serializeBinaryToWriter(message: Continuous, writer: jspb.BinaryWriter): void;
+            static deserializeBinary(bytes: Uint8Array): Continuous;
+            static deserializeBinaryFromReader(message: Continuous, reader: jspb.BinaryReader): Continuous;
+        }
+
+        export namespace Continuous {
+            export type AsObject = {
+                name: string,
+                emitEnabled: boolean,
+                trackEmittedStreams: boolean,
+            }
+        }
+
+
+        export enum ModeCase {
+            MODE_NOT_SET = 0,
+            ONE_TIME = 1,
+            TRANSIENT = 2,
+            CONTINUOUS = 3,
+        }
+
+    }
+
+}
+
+export class CreateResp extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CreateResp.AsObject;
+    static toObject(includeInstance: boolean, msg: CreateResp): CreateResp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CreateResp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CreateResp;
+    static deserializeBinaryFromReader(message: CreateResp, reader: jspb.BinaryReader): CreateResp;
+}
+
+export namespace CreateResp {
+    export type AsObject = {
+    }
+}
+
+export class UpdateReq extends jspb.Message { 
+
+    hasOptions(): boolean;
+    clearOptions(): void;
+    getOptions(): UpdateReq.Options | undefined;
+    setOptions(value?: UpdateReq.Options): UpdateReq;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UpdateReq.AsObject;
+    static toObject(includeInstance: boolean, msg: UpdateReq): UpdateReq.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: UpdateReq, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UpdateReq;
+    static deserializeBinaryFromReader(message: UpdateReq, reader: jspb.BinaryReader): UpdateReq;
+}
+
+export namespace UpdateReq {
+    export type AsObject = {
+        options?: UpdateReq.Options.AsObject,
+    }
+
+
+    export class Options extends jspb.Message { 
+        getName(): string;
+        setName(value: string): Options;
+        getQuery(): string;
+        setQuery(value: string): Options;
+
+        hasEmitEnabled(): boolean;
+        clearEmitEnabled(): void;
+        getEmitEnabled(): boolean;
+        setEmitEnabled(value: boolean): Options;
+
+        hasNoEmitOptions(): boolean;
+        clearNoEmitOptions(): void;
+        getNoEmitOptions(): shared_pb.Empty | undefined;
+        setNoEmitOptions(value?: shared_pb.Empty): Options;
+
+        getEmitOptionCase(): Options.EmitOptionCase;
+
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): Options.AsObject;
+        static toObject(includeInstance: boolean, msg: Options): Options.AsObject;
+        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+        static serializeBinaryToWriter(message: Options, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): Options;
+        static deserializeBinaryFromReader(message: Options, reader: jspb.BinaryReader): Options;
+    }
+
+    export namespace Options {
+        export type AsObject = {
+            name: string,
+            query: string,
+            emitEnabled: boolean,
+            noEmitOptions?: shared_pb.Empty.AsObject,
+        }
+
+        export enum EmitOptionCase {
+            EMIT_OPTION_NOT_SET = 0,
+            EMIT_ENABLED = 3,
+            NO_EMIT_OPTIONS = 4,
+        }
+
+    }
+
+}
+
+export class UpdateResp extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UpdateResp.AsObject;
+    static toObject(includeInstance: boolean, msg: UpdateResp): UpdateResp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: UpdateResp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UpdateResp;
+    static deserializeBinaryFromReader(message: UpdateResp, reader: jspb.BinaryReader): UpdateResp;
+}
+
+export namespace UpdateResp {
+    export type AsObject = {
+    }
+}
+
+export class DeleteReq extends jspb.Message { 
+
+    hasOptions(): boolean;
+    clearOptions(): void;
+    getOptions(): DeleteReq.Options | undefined;
+    setOptions(value?: DeleteReq.Options): DeleteReq;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DeleteReq.AsObject;
+    static toObject(includeInstance: boolean, msg: DeleteReq): DeleteReq.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DeleteReq, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DeleteReq;
+    static deserializeBinaryFromReader(message: DeleteReq, reader: jspb.BinaryReader): DeleteReq;
+}
+
+export namespace DeleteReq {
+    export type AsObject = {
+        options?: DeleteReq.Options.AsObject,
+    }
+
+
+    export class Options extends jspb.Message { 
+        getName(): string;
+        setName(value: string): Options;
+        getDeleteEmittedStreams(): boolean;
+        setDeleteEmittedStreams(value: boolean): Options;
+        getDeleteStateStream(): boolean;
+        setDeleteStateStream(value: boolean): Options;
+        getDeleteCheckpointStream(): boolean;
+        setDeleteCheckpointStream(value: boolean): Options;
+
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): Options.AsObject;
+        static toObject(includeInstance: boolean, msg: Options): Options.AsObject;
+        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+        static serializeBinaryToWriter(message: Options, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): Options;
+        static deserializeBinaryFromReader(message: Options, reader: jspb.BinaryReader): Options;
+    }
+
+    export namespace Options {
+        export type AsObject = {
+            name: string,
+            deleteEmittedStreams: boolean,
+            deleteStateStream: boolean,
+            deleteCheckpointStream: boolean,
+        }
+    }
+
+}
+
+export class DeleteResp extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DeleteResp.AsObject;
+    static toObject(includeInstance: boolean, msg: DeleteResp): DeleteResp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DeleteResp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DeleteResp;
+    static deserializeBinaryFromReader(message: DeleteResp, reader: jspb.BinaryReader): DeleteResp;
+}
+
+export namespace DeleteResp {
+    export type AsObject = {
+    }
+}
+
+export class StatisticsReq extends jspb.Message { 
+
+    hasOptions(): boolean;
+    clearOptions(): void;
+    getOptions(): StatisticsReq.Options | undefined;
+    setOptions(value?: StatisticsReq.Options): StatisticsReq;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): StatisticsReq.AsObject;
+    static toObject(includeInstance: boolean, msg: StatisticsReq): StatisticsReq.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: StatisticsReq, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): StatisticsReq;
+    static deserializeBinaryFromReader(message: StatisticsReq, reader: jspb.BinaryReader): StatisticsReq;
+}
+
+export namespace StatisticsReq {
+    export type AsObject = {
+        options?: StatisticsReq.Options.AsObject,
+    }
+
+
+    export class Options extends jspb.Message { 
+
+        hasName(): boolean;
+        clearName(): void;
+        getName(): string;
+        setName(value: string): Options;
+
+        hasAll(): boolean;
+        clearAll(): void;
+        getAll(): shared_pb.Empty | undefined;
+        setAll(value?: shared_pb.Empty): Options;
+
+        hasTransient(): boolean;
+        clearTransient(): void;
+        getTransient(): shared_pb.Empty | undefined;
+        setTransient(value?: shared_pb.Empty): Options;
+
+        hasContinuous(): boolean;
+        clearContinuous(): void;
+        getContinuous(): shared_pb.Empty | undefined;
+        setContinuous(value?: shared_pb.Empty): Options;
+
+        hasOneTime(): boolean;
+        clearOneTime(): void;
+        getOneTime(): shared_pb.Empty | undefined;
+        setOneTime(value?: shared_pb.Empty): Options;
+
+        getModeCase(): Options.ModeCase;
+
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): Options.AsObject;
+        static toObject(includeInstance: boolean, msg: Options): Options.AsObject;
+        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+        static serializeBinaryToWriter(message: Options, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): Options;
+        static deserializeBinaryFromReader(message: Options, reader: jspb.BinaryReader): Options;
+    }
+
+    export namespace Options {
+        export type AsObject = {
+            name: string,
+            all?: shared_pb.Empty.AsObject,
+            pb_transient?: shared_pb.Empty.AsObject,
+            continuous?: shared_pb.Empty.AsObject,
+            oneTime?: shared_pb.Empty.AsObject,
+        }
+
+        export enum ModeCase {
+            MODE_NOT_SET = 0,
+            NAME = 1,
+            ALL = 2,
+            TRANSIENT = 3,
+            CONTINUOUS = 4,
+            ONE_TIME = 5,
+        }
+
+    }
+
+}
+
+export class StatisticsResp extends jspb.Message { 
+
+    hasDetails(): boolean;
+    clearDetails(): void;
+    getDetails(): StatisticsResp.Details | undefined;
+    setDetails(value?: StatisticsResp.Details): StatisticsResp;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): StatisticsResp.AsObject;
+    static toObject(includeInstance: boolean, msg: StatisticsResp): StatisticsResp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: StatisticsResp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): StatisticsResp;
+    static deserializeBinaryFromReader(message: StatisticsResp, reader: jspb.BinaryReader): StatisticsResp;
+}
+
+export namespace StatisticsResp {
+    export type AsObject = {
+        details?: StatisticsResp.Details.AsObject,
+    }
+
+
+    export class Details extends jspb.Message { 
+        getCoreprocessingtime(): string;
+        setCoreprocessingtime(value: string): Details;
+        getVersion(): string;
+        setVersion(value: string): Details;
+        getEpoch(): string;
+        setEpoch(value: string): Details;
+        getEffectivename(): string;
+        setEffectivename(value: string): Details;
+        getWritesinprogress(): number;
+        setWritesinprogress(value: number): Details;
+        getReadsinprogress(): number;
+        setReadsinprogress(value: number): Details;
+        getPartitionscached(): number;
+        setPartitionscached(value: number): Details;
+        getStatus(): string;
+        setStatus(value: string): Details;
+        getStatereason(): string;
+        setStatereason(value: string): Details;
+        getName(): string;
+        setName(value: string): Details;
+        getMode(): string;
+        setMode(value: string): Details;
+        getPosition(): string;
+        setPosition(value: string): Details;
+        getProgress(): number;
+        setProgress(value: number): Details;
+        getLastcheckpoint(): string;
+        setLastcheckpoint(value: string): Details;
+        getEventsprocessedafterrestart(): string;
+        setEventsprocessedafterrestart(value: string): Details;
+        getCheckpointstatus(): string;
+        setCheckpointstatus(value: string): Details;
+        getBufferedevents(): string;
+        setBufferedevents(value: string): Details;
+        getWritependingeventsbeforecheckpoint(): number;
+        setWritependingeventsbeforecheckpoint(value: number): Details;
+        getWritependingeventsaftercheckpoint(): number;
+        setWritependingeventsaftercheckpoint(value: number): Details;
+
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): Details.AsObject;
+        static toObject(includeInstance: boolean, msg: Details): Details.AsObject;
+        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+        static serializeBinaryToWriter(message: Details, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): Details;
+        static deserializeBinaryFromReader(message: Details, reader: jspb.BinaryReader): Details;
+    }
+
+    export namespace Details {
+        export type AsObject = {
+            coreprocessingtime: string,
+            version: string,
+            epoch: string,
+            effectivename: string,
+            writesinprogress: number,
+            readsinprogress: number,
+            partitionscached: number,
+            status: string,
+            statereason: string,
+            name: string,
+            mode: string,
+            position: string,
+            progress: number,
+            lastcheckpoint: string,
+            eventsprocessedafterrestart: string,
+            checkpointstatus: string,
+            bufferedevents: string,
+            writependingeventsbeforecheckpoint: number,
+            writependingeventsaftercheckpoint: number,
+        }
+    }
+
+}
+
+export class StateReq extends jspb.Message { 
+
+    hasOptions(): boolean;
+    clearOptions(): void;
+    getOptions(): StateReq.Options | undefined;
+    setOptions(value?: StateReq.Options): StateReq;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): StateReq.AsObject;
+    static toObject(includeInstance: boolean, msg: StateReq): StateReq.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: StateReq, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): StateReq;
+    static deserializeBinaryFromReader(message: StateReq, reader: jspb.BinaryReader): StateReq;
+}
+
+export namespace StateReq {
+    export type AsObject = {
+        options?: StateReq.Options.AsObject,
+    }
+
+
+    export class Options extends jspb.Message { 
+        getName(): string;
+        setName(value: string): Options;
+        getPartition(): string;
+        setPartition(value: string): Options;
+
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): Options.AsObject;
+        static toObject(includeInstance: boolean, msg: Options): Options.AsObject;
+        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+        static serializeBinaryToWriter(message: Options, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): Options;
+        static deserializeBinaryFromReader(message: Options, reader: jspb.BinaryReader): Options;
+    }
+
+    export namespace Options {
+        export type AsObject = {
+            name: string,
+            partition: string,
+        }
+    }
+
+}
+
+export class StateResp extends jspb.Message { 
+
+    hasState(): boolean;
+    clearState(): void;
+    getState(): google_protobuf_struct_pb.Value | undefined;
+    setState(value?: google_protobuf_struct_pb.Value): StateResp;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): StateResp.AsObject;
+    static toObject(includeInstance: boolean, msg: StateResp): StateResp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: StateResp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): StateResp;
+    static deserializeBinaryFromReader(message: StateResp, reader: jspb.BinaryReader): StateResp;
+}
+
+export namespace StateResp {
+    export type AsObject = {
+        state?: google_protobuf_struct_pb.Value.AsObject,
+    }
+}
+
+export class ResultReq extends jspb.Message { 
+
+    hasOptions(): boolean;
+    clearOptions(): void;
+    getOptions(): ResultReq.Options | undefined;
+    setOptions(value?: ResultReq.Options): ResultReq;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ResultReq.AsObject;
+    static toObject(includeInstance: boolean, msg: ResultReq): ResultReq.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ResultReq, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ResultReq;
+    static deserializeBinaryFromReader(message: ResultReq, reader: jspb.BinaryReader): ResultReq;
+}
+
+export namespace ResultReq {
+    export type AsObject = {
+        options?: ResultReq.Options.AsObject,
+    }
+
+
+    export class Options extends jspb.Message { 
+        getName(): string;
+        setName(value: string): Options;
+        getPartition(): string;
+        setPartition(value: string): Options;
+
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): Options.AsObject;
+        static toObject(includeInstance: boolean, msg: Options): Options.AsObject;
+        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+        static serializeBinaryToWriter(message: Options, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): Options;
+        static deserializeBinaryFromReader(message: Options, reader: jspb.BinaryReader): Options;
+    }
+
+    export namespace Options {
+        export type AsObject = {
+            name: string,
+            partition: string,
+        }
+    }
+
+}
+
+export class ResultResp extends jspb.Message { 
+
+    hasResult(): boolean;
+    clearResult(): void;
+    getResult(): google_protobuf_struct_pb.Value | undefined;
+    setResult(value?: google_protobuf_struct_pb.Value): ResultResp;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ResultResp.AsObject;
+    static toObject(includeInstance: boolean, msg: ResultResp): ResultResp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ResultResp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ResultResp;
+    static deserializeBinaryFromReader(message: ResultResp, reader: jspb.BinaryReader): ResultResp;
+}
+
+export namespace ResultResp {
+    export type AsObject = {
+        result?: google_protobuf_struct_pb.Value.AsObject,
+    }
+}
+
+export class ResetReq extends jspb.Message { 
+
+    hasOptions(): boolean;
+    clearOptions(): void;
+    getOptions(): ResetReq.Options | undefined;
+    setOptions(value?: ResetReq.Options): ResetReq;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ResetReq.AsObject;
+    static toObject(includeInstance: boolean, msg: ResetReq): ResetReq.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ResetReq, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ResetReq;
+    static deserializeBinaryFromReader(message: ResetReq, reader: jspb.BinaryReader): ResetReq;
+}
+
+export namespace ResetReq {
+    export type AsObject = {
+        options?: ResetReq.Options.AsObject,
+    }
+
+
+    export class Options extends jspb.Message { 
+        getName(): string;
+        setName(value: string): Options;
+        getWriteCheckpoint(): boolean;
+        setWriteCheckpoint(value: boolean): Options;
+
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): Options.AsObject;
+        static toObject(includeInstance: boolean, msg: Options): Options.AsObject;
+        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+        static serializeBinaryToWriter(message: Options, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): Options;
+        static deserializeBinaryFromReader(message: Options, reader: jspb.BinaryReader): Options;
+    }
+
+    export namespace Options {
+        export type AsObject = {
+            name: string,
+            writeCheckpoint: boolean,
+        }
+    }
+
+}
+
+export class ResetResp extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ResetResp.AsObject;
+    static toObject(includeInstance: boolean, msg: ResetResp): ResetResp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ResetResp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ResetResp;
+    static deserializeBinaryFromReader(message: ResetResp, reader: jspb.BinaryReader): ResetResp;
+}
+
+export namespace ResetResp {
+    export type AsObject = {
+    }
+}
+
+export class EnableReq extends jspb.Message { 
+
+    hasOptions(): boolean;
+    clearOptions(): void;
+    getOptions(): EnableReq.Options | undefined;
+    setOptions(value?: EnableReq.Options): EnableReq;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): EnableReq.AsObject;
+    static toObject(includeInstance: boolean, msg: EnableReq): EnableReq.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: EnableReq, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): EnableReq;
+    static deserializeBinaryFromReader(message: EnableReq, reader: jspb.BinaryReader): EnableReq;
+}
+
+export namespace EnableReq {
+    export type AsObject = {
+        options?: EnableReq.Options.AsObject,
+    }
+
+
+    export class Options extends jspb.Message { 
+        getName(): string;
+        setName(value: string): Options;
+
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): Options.AsObject;
+        static toObject(includeInstance: boolean, msg: Options): Options.AsObject;
+        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+        static serializeBinaryToWriter(message: Options, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): Options;
+        static deserializeBinaryFromReader(message: Options, reader: jspb.BinaryReader): Options;
+    }
+
+    export namespace Options {
+        export type AsObject = {
+            name: string,
+        }
+    }
+
+}
+
+export class EnableResp extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): EnableResp.AsObject;
+    static toObject(includeInstance: boolean, msg: EnableResp): EnableResp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: EnableResp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): EnableResp;
+    static deserializeBinaryFromReader(message: EnableResp, reader: jspb.BinaryReader): EnableResp;
+}
+
+export namespace EnableResp {
+    export type AsObject = {
+    }
+}
+
+export class DisableReq extends jspb.Message { 
+
+    hasOptions(): boolean;
+    clearOptions(): void;
+    getOptions(): DisableReq.Options | undefined;
+    setOptions(value?: DisableReq.Options): DisableReq;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DisableReq.AsObject;
+    static toObject(includeInstance: boolean, msg: DisableReq): DisableReq.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DisableReq, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DisableReq;
+    static deserializeBinaryFromReader(message: DisableReq, reader: jspb.BinaryReader): DisableReq;
+}
+
+export namespace DisableReq {
+    export type AsObject = {
+        options?: DisableReq.Options.AsObject,
+    }
+
+
+    export class Options extends jspb.Message { 
+        getName(): string;
+        setName(value: string): Options;
+        getWriteCheckpoint(): boolean;
+        setWriteCheckpoint(value: boolean): Options;
+
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): Options.AsObject;
+        static toObject(includeInstance: boolean, msg: Options): Options.AsObject;
+        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+        static serializeBinaryToWriter(message: Options, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): Options;
+        static deserializeBinaryFromReader(message: Options, reader: jspb.BinaryReader): Options;
+    }
+
+    export namespace Options {
+        export type AsObject = {
+            name: string,
+            writeCheckpoint: boolean,
+        }
+    }
+
+}
+
+export class DisableResp extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DisableResp.AsObject;
+    static toObject(includeInstance: boolean, msg: DisableResp): DisableResp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DisableResp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DisableResp;
+    static deserializeBinaryFromReader(message: DisableResp, reader: jspb.BinaryReader): DisableResp;
+}
+
+export namespace DisableResp {
+    export type AsObject = {
+    }
+}