// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v7.34.1
// source: kv.proto

package waymaker_kv

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type KvCreateBucketRequest struct {
	state        protoimpl.MessageState `protogen:"open.v1"`
	Bucket       string                 `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	MaxBytes     uint64                 `protobuf:"varint,2,opt,name=max_bytes,json=maxBytes,proto3" json:"max_bytes,omitempty"`               // 0 = unbounded
	MaxValueSize uint64                 `protobuf:"varint,3,opt,name=max_value_size,json=maxValueSize,proto3" json:"max_value_size,omitempty"` // 0 = no per-value cap
	// Bucket-level TTL (ms). 0 = no time-based eviction.
	// Independent of per-key TTL set via Put.
	MaxAgeMs  uint64 `protobuf:"varint,4,opt,name=max_age_ms,json=maxAgeMs,proto3" json:"max_age_ms,omitempty"`
	Ephemeral bool   `protobuf:"varint,5,opt,name=ephemeral,proto3" json:"ephemeral,omitempty"`
	// Per-key revision cap. 0 (default) = unbounded — history depth
	// is then bounded only by the bucket's stream-level retention
	// (max_age_ms / max_bytes). When N > 0, after each successful
	// write to a key, older revisions of *that key* beyond the N
	// most recent are dropped via per-message pruning. Useful when
	// one bucket hosts many keys with very different write rates —
	// a fast-churning key won't crowd out older revisions of a
	// slow-changing key. NATS JetStream's "MaxRevisions" semantic.
	MaxRevisions  uint64 `protobuf:"varint,6,opt,name=max_revisions,json=maxRevisions,proto3" json:"max_revisions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvCreateBucketRequest) Reset() {
	*x = KvCreateBucketRequest{}
	mi := &file_kv_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvCreateBucketRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvCreateBucketRequest) ProtoMessage() {}

func (x *KvCreateBucketRequest) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvCreateBucketRequest.ProtoReflect.Descriptor instead.
func (*KvCreateBucketRequest) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{0}
}

func (x *KvCreateBucketRequest) GetBucket() string {
	if x != nil {
		return x.Bucket
	}
	return ""
}

func (x *KvCreateBucketRequest) GetMaxBytes() uint64 {
	if x != nil {
		return x.MaxBytes
	}
	return 0
}

func (x *KvCreateBucketRequest) GetMaxValueSize() uint64 {
	if x != nil {
		return x.MaxValueSize
	}
	return 0
}

func (x *KvCreateBucketRequest) GetMaxAgeMs() uint64 {
	if x != nil {
		return x.MaxAgeMs
	}
	return 0
}

func (x *KvCreateBucketRequest) GetEphemeral() bool {
	if x != nil {
		return x.Ephemeral
	}
	return false
}

func (x *KvCreateBucketRequest) GetMaxRevisions() uint64 {
	if x != nil {
		return x.MaxRevisions
	}
	return 0
}

type KvCreateBucketResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	ResultCode    string                 `protobuf:"bytes,2,opt,name=result_code,json=resultCode,proto3" json:"result_code,omitempty"` // "ok" | "already_exists" | "invalid_config" | "internal"
	Message       string                 `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvCreateBucketResponse) Reset() {
	*x = KvCreateBucketResponse{}
	mi := &file_kv_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvCreateBucketResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvCreateBucketResponse) ProtoMessage() {}

func (x *KvCreateBucketResponse) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvCreateBucketResponse.ProtoReflect.Descriptor instead.
func (*KvCreateBucketResponse) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{1}
}

func (x *KvCreateBucketResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *KvCreateBucketResponse) GetResultCode() string {
	if x != nil {
		return x.ResultCode
	}
	return ""
}

func (x *KvCreateBucketResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

type KvDeleteBucketRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Bucket        string                 `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvDeleteBucketRequest) Reset() {
	*x = KvDeleteBucketRequest{}
	mi := &file_kv_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvDeleteBucketRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvDeleteBucketRequest) ProtoMessage() {}

func (x *KvDeleteBucketRequest) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvDeleteBucketRequest.ProtoReflect.Descriptor instead.
func (*KvDeleteBucketRequest) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{2}
}

func (x *KvDeleteBucketRequest) GetBucket() string {
	if x != nil {
		return x.Bucket
	}
	return ""
}

type KvDeleteBucketResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	ResultCode    string                 `protobuf:"bytes,2,opt,name=result_code,json=resultCode,proto3" json:"result_code,omitempty"` // "ok" | "no_such_bucket" | "internal"
	Message       string                 `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvDeleteBucketResponse) Reset() {
	*x = KvDeleteBucketResponse{}
	mi := &file_kv_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvDeleteBucketResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvDeleteBucketResponse) ProtoMessage() {}

func (x *KvDeleteBucketResponse) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvDeleteBucketResponse.ProtoReflect.Descriptor instead.
func (*KvDeleteBucketResponse) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{3}
}

func (x *KvDeleteBucketResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *KvDeleteBucketResponse) GetResultCode() string {
	if x != nil {
		return x.ResultCode
	}
	return ""
}

func (x *KvDeleteBucketResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

type KvPutRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Bucket        string                 `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	Key           string                 `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	Value         []byte                 `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	TtlMs         uint64                 `protobuf:"varint,4,opt,name=ttl_ms,json=ttlMs,proto3" json:"ttl_ms,omitempty"` // per-key TTL; 0 = no TTL
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvPutRequest) Reset() {
	*x = KvPutRequest{}
	mi := &file_kv_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvPutRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvPutRequest) ProtoMessage() {}

func (x *KvPutRequest) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvPutRequest.ProtoReflect.Descriptor instead.
func (*KvPutRequest) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{4}
}

func (x *KvPutRequest) GetBucket() string {
	if x != nil {
		return x.Bucket
	}
	return ""
}

func (x *KvPutRequest) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *KvPutRequest) GetValue() []byte {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *KvPutRequest) GetTtlMs() uint64 {
	if x != nil {
		return x.TtlMs
	}
	return 0
}

type KvCreateRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Bucket        string                 `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	Key           string                 `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	Value         []byte                 `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	TtlMs         uint64                 `protobuf:"varint,4,opt,name=ttl_ms,json=ttlMs,proto3" json:"ttl_ms,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvCreateRequest) Reset() {
	*x = KvCreateRequest{}
	mi := &file_kv_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvCreateRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvCreateRequest) ProtoMessage() {}

func (x *KvCreateRequest) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvCreateRequest.ProtoReflect.Descriptor instead.
func (*KvCreateRequest) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{5}
}

func (x *KvCreateRequest) GetBucket() string {
	if x != nil {
		return x.Bucket
	}
	return ""
}

func (x *KvCreateRequest) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *KvCreateRequest) GetValue() []byte {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *KvCreateRequest) GetTtlMs() uint64 {
	if x != nil {
		return x.TtlMs
	}
	return 0
}

type KvUpdateRequest struct {
	state  protoimpl.MessageState `protogen:"open.v1"`
	Bucket string                 `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	Key    string                 `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	Value  []byte                 `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	// The revision the caller believes is current. Server returns
	// wrong_revision if mismatch.
	ExpectedRevision uint64 `protobuf:"varint,4,opt,name=expected_revision,json=expectedRevision,proto3" json:"expected_revision,omitempty"`
	TtlMs            uint64 `protobuf:"varint,5,opt,name=ttl_ms,json=ttlMs,proto3" json:"ttl_ms,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *KvUpdateRequest) Reset() {
	*x = KvUpdateRequest{}
	mi := &file_kv_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvUpdateRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvUpdateRequest) ProtoMessage() {}

func (x *KvUpdateRequest) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvUpdateRequest.ProtoReflect.Descriptor instead.
func (*KvUpdateRequest) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{6}
}

func (x *KvUpdateRequest) GetBucket() string {
	if x != nil {
		return x.Bucket
	}
	return ""
}

func (x *KvUpdateRequest) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *KvUpdateRequest) GetValue() []byte {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *KvUpdateRequest) GetExpectedRevision() uint64 {
	if x != nil {
		return x.ExpectedRevision
	}
	return 0
}

func (x *KvUpdateRequest) GetTtlMs() uint64 {
	if x != nil {
		return x.TtlMs
	}
	return 0
}

type KvPutResponse struct {
	state   protoimpl.MessageState `protogen:"open.v1"`
	Success bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	// "ok" | "no_such_bucket" | "wrong_revision" | "invalid_key" | "internal"
	ResultCode    string `protobuf:"bytes,2,opt,name=result_code,json=resultCode,proto3" json:"result_code,omitempty"`
	Message       string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	Revision      uint64 `protobuf:"varint,4,opt,name=revision,proto3" json:"revision,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvPutResponse) Reset() {
	*x = KvPutResponse{}
	mi := &file_kv_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvPutResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvPutResponse) ProtoMessage() {}

func (x *KvPutResponse) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvPutResponse.ProtoReflect.Descriptor instead.
func (*KvPutResponse) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{7}
}

func (x *KvPutResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *KvPutResponse) GetResultCode() string {
	if x != nil {
		return x.ResultCode
	}
	return ""
}

func (x *KvPutResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

func (x *KvPutResponse) GetRevision() uint64 {
	if x != nil {
		return x.Revision
	}
	return 0
}

type KvGetRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Bucket        string                 `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	Key           string                 `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvGetRequest) Reset() {
	*x = KvGetRequest{}
	mi := &file_kv_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvGetRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvGetRequest) ProtoMessage() {}

func (x *KvGetRequest) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvGetRequest.ProtoReflect.Descriptor instead.
func (*KvGetRequest) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{8}
}

func (x *KvGetRequest) GetBucket() string {
	if x != nil {
		return x.Bucket
	}
	return ""
}

func (x *KvGetRequest) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

type KvGetResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	ResultCode    string                 `protobuf:"bytes,2,opt,name=result_code,json=resultCode,proto3" json:"result_code,omitempty"`
	Message       string                 `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	Entry         *KvEntry               `protobuf:"bytes,4,opt,name=entry,proto3,oneof" json:"entry,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvGetResponse) Reset() {
	*x = KvGetResponse{}
	mi := &file_kv_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvGetResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvGetResponse) ProtoMessage() {}

func (x *KvGetResponse) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvGetResponse.ProtoReflect.Descriptor instead.
func (*KvGetResponse) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{9}
}

func (x *KvGetResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *KvGetResponse) GetResultCode() string {
	if x != nil {
		return x.ResultCode
	}
	return ""
}

func (x *KvGetResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

func (x *KvGetResponse) GetEntry() *KvEntry {
	if x != nil {
		return x.Entry
	}
	return nil
}

type KvEntry struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Value         []byte                 `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	Revision      uint64                 `protobuf:"varint,2,opt,name=revision,proto3" json:"revision,omitempty"`
	TsMs          int64                  `protobuf:"varint,3,opt,name=ts_ms,json=tsMs,proto3" json:"ts_ms,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvEntry) Reset() {
	*x = KvEntry{}
	mi := &file_kv_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvEntry) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvEntry) ProtoMessage() {}

func (x *KvEntry) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvEntry.ProtoReflect.Descriptor instead.
func (*KvEntry) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{10}
}

func (x *KvEntry) GetValue() []byte {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *KvEntry) GetRevision() uint64 {
	if x != nil {
		return x.Revision
	}
	return 0
}

func (x *KvEntry) GetTsMs() int64 {
	if x != nil {
		return x.TsMs
	}
	return 0
}

type KvDeleteRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Bucket        string                 `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	Key           string                 `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvDeleteRequest) Reset() {
	*x = KvDeleteRequest{}
	mi := &file_kv_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvDeleteRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvDeleteRequest) ProtoMessage() {}

func (x *KvDeleteRequest) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvDeleteRequest.ProtoReflect.Descriptor instead.
func (*KvDeleteRequest) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{11}
}

func (x *KvDeleteRequest) GetBucket() string {
	if x != nil {
		return x.Bucket
	}
	return ""
}

func (x *KvDeleteRequest) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

type KvDeleteResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	ResultCode    string                 `protobuf:"bytes,2,opt,name=result_code,json=resultCode,proto3" json:"result_code,omitempty"`
	Message       string                 `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	Revision      uint64                 `protobuf:"varint,4,opt,name=revision,proto3" json:"revision,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvDeleteResponse) Reset() {
	*x = KvDeleteResponse{}
	mi := &file_kv_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvDeleteResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvDeleteResponse) ProtoMessage() {}

func (x *KvDeleteResponse) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvDeleteResponse.ProtoReflect.Descriptor instead.
func (*KvDeleteResponse) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{12}
}

func (x *KvDeleteResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *KvDeleteResponse) GetResultCode() string {
	if x != nil {
		return x.ResultCode
	}
	return ""
}

func (x *KvDeleteResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

func (x *KvDeleteResponse) GetRevision() uint64 {
	if x != nil {
		return x.Revision
	}
	return 0
}

type KvKeysRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Bucket        string                 `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvKeysRequest) Reset() {
	*x = KvKeysRequest{}
	mi := &file_kv_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvKeysRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvKeysRequest) ProtoMessage() {}

func (x *KvKeysRequest) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvKeysRequest.ProtoReflect.Descriptor instead.
func (*KvKeysRequest) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{13}
}

func (x *KvKeysRequest) GetBucket() string {
	if x != nil {
		return x.Bucket
	}
	return ""
}

type KvKeysResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	ResultCode    string                 `protobuf:"bytes,2,opt,name=result_code,json=resultCode,proto3" json:"result_code,omitempty"`
	Message       string                 `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	Entries       []*KvKeyEntry          `protobuf:"bytes,4,rep,name=entries,proto3" json:"entries,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvKeysResponse) Reset() {
	*x = KvKeysResponse{}
	mi := &file_kv_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvKeysResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvKeysResponse) ProtoMessage() {}

func (x *KvKeysResponse) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvKeysResponse.ProtoReflect.Descriptor instead.
func (*KvKeysResponse) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{14}
}

func (x *KvKeysResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *KvKeysResponse) GetResultCode() string {
	if x != nil {
		return x.ResultCode
	}
	return ""
}

func (x *KvKeysResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

func (x *KvKeysResponse) GetEntries() []*KvKeyEntry {
	if x != nil {
		return x.Entries
	}
	return nil
}

type KvKeyEntry struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Revision      uint64                 `protobuf:"varint,2,opt,name=revision,proto3" json:"revision,omitempty"`
	Deleted       bool                   `protobuf:"varint,3,opt,name=deleted,proto3" json:"deleted,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvKeyEntry) Reset() {
	*x = KvKeyEntry{}
	mi := &file_kv_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvKeyEntry) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvKeyEntry) ProtoMessage() {}

func (x *KvKeyEntry) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvKeyEntry.ProtoReflect.Descriptor instead.
func (*KvKeyEntry) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{15}
}

func (x *KvKeyEntry) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *KvKeyEntry) GetRevision() uint64 {
	if x != nil {
		return x.Revision
	}
	return 0
}

func (x *KvKeyEntry) GetDeleted() bool {
	if x != nil {
		return x.Deleted
	}
	return false
}

type KvHistoryRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Bucket        string                 `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	Key           string                 `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	FromRevision  uint64                 `protobuf:"varint,3,opt,name=from_revision,json=fromRevision,proto3" json:"from_revision,omitempty"` // 0 = from beginning
	Limit         uint64                 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`                                   // 0 = server default
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvHistoryRequest) Reset() {
	*x = KvHistoryRequest{}
	mi := &file_kv_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvHistoryRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvHistoryRequest) ProtoMessage() {}

func (x *KvHistoryRequest) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvHistoryRequest.ProtoReflect.Descriptor instead.
func (*KvHistoryRequest) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{16}
}

func (x *KvHistoryRequest) GetBucket() string {
	if x != nil {
		return x.Bucket
	}
	return ""
}

func (x *KvHistoryRequest) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *KvHistoryRequest) GetFromRevision() uint64 {
	if x != nil {
		return x.FromRevision
	}
	return 0
}

func (x *KvHistoryRequest) GetLimit() uint64 {
	if x != nil {
		return x.Limit
	}
	return 0
}

type KvHistoryResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	ResultCode    string                 `protobuf:"bytes,2,opt,name=result_code,json=resultCode,proto3" json:"result_code,omitempty"`
	Message       string                 `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	Entries       []*KvHistoryEntry      `protobuf:"bytes,4,rep,name=entries,proto3" json:"entries,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvHistoryResponse) Reset() {
	*x = KvHistoryResponse{}
	mi := &file_kv_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvHistoryResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvHistoryResponse) ProtoMessage() {}

func (x *KvHistoryResponse) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvHistoryResponse.ProtoReflect.Descriptor instead.
func (*KvHistoryResponse) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{17}
}

func (x *KvHistoryResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *KvHistoryResponse) GetResultCode() string {
	if x != nil {
		return x.ResultCode
	}
	return ""
}

func (x *KvHistoryResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

func (x *KvHistoryResponse) GetEntries() []*KvHistoryEntry {
	if x != nil {
		return x.Entries
	}
	return nil
}

type KvHistoryEntry struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Value         []byte                 `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	Revision      uint64                 `protobuf:"varint,2,opt,name=revision,proto3" json:"revision,omitempty"`
	TsMs          int64                  `protobuf:"varint,3,opt,name=ts_ms,json=tsMs,proto3" json:"ts_ms,omitempty"`
	Deleted       bool                   `protobuf:"varint,4,opt,name=deleted,proto3" json:"deleted,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvHistoryEntry) Reset() {
	*x = KvHistoryEntry{}
	mi := &file_kv_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvHistoryEntry) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvHistoryEntry) ProtoMessage() {}

func (x *KvHistoryEntry) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvHistoryEntry.ProtoReflect.Descriptor instead.
func (*KvHistoryEntry) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{18}
}

func (x *KvHistoryEntry) GetValue() []byte {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *KvHistoryEntry) GetRevision() uint64 {
	if x != nil {
		return x.Revision
	}
	return 0
}

func (x *KvHistoryEntry) GetTsMs() int64 {
	if x != nil {
		return x.TsMs
	}
	return 0
}

func (x *KvHistoryEntry) GetDeleted() bool {
	if x != nil {
		return x.Deleted
	}
	return false
}

type KvTouchRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Bucket        string                 `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	Key           string                 `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	TtlMs         uint64                 `protobuf:"varint,3,opt,name=ttl_ms,json=ttlMs,proto3" json:"ttl_ms,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvTouchRequest) Reset() {
	*x = KvTouchRequest{}
	mi := &file_kv_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvTouchRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvTouchRequest) ProtoMessage() {}

func (x *KvTouchRequest) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[19]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvTouchRequest.ProtoReflect.Descriptor instead.
func (*KvTouchRequest) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{19}
}

func (x *KvTouchRequest) GetBucket() string {
	if x != nil {
		return x.Bucket
	}
	return ""
}

func (x *KvTouchRequest) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *KvTouchRequest) GetTtlMs() uint64 {
	if x != nil {
		return x.TtlMs
	}
	return 0
}

type KvWatchRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Bucket        string                 `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
	Key           string                 `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` // empty = whole bucket
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvWatchRequest) Reset() {
	*x = KvWatchRequest{}
	mi := &file_kv_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvWatchRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvWatchRequest) ProtoMessage() {}

func (x *KvWatchRequest) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[20]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvWatchRequest.ProtoReflect.Descriptor instead.
func (*KvWatchRequest) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{20}
}

func (x *KvWatchRequest) GetBucket() string {
	if x != nil {
		return x.Bucket
	}
	return ""
}

func (x *KvWatchRequest) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

type KvWatchEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Event:
	//
	//	*KvWatchEvent_Put
	//	*KvWatchEvent_Delete
	Event         isKvWatchEvent_Event `protobuf_oneof:"event"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvWatchEvent) Reset() {
	*x = KvWatchEvent{}
	mi := &file_kv_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvWatchEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvWatchEvent) ProtoMessage() {}

func (x *KvWatchEvent) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[21]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvWatchEvent.ProtoReflect.Descriptor instead.
func (*KvWatchEvent) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{21}
}

func (x *KvWatchEvent) GetEvent() isKvWatchEvent_Event {
	if x != nil {
		return x.Event
	}
	return nil
}

func (x *KvWatchEvent) GetPut() *KvPutEvent {
	if x != nil {
		if x, ok := x.Event.(*KvWatchEvent_Put); ok {
			return x.Put
		}
	}
	return nil
}

func (x *KvWatchEvent) GetDelete() *KvDeleteEvent {
	if x != nil {
		if x, ok := x.Event.(*KvWatchEvent_Delete); ok {
			return x.Delete
		}
	}
	return nil
}

type isKvWatchEvent_Event interface {
	isKvWatchEvent_Event()
}

type KvWatchEvent_Put struct {
	Put *KvPutEvent `protobuf:"bytes,1,opt,name=put,proto3,oneof"`
}

type KvWatchEvent_Delete struct {
	Delete *KvDeleteEvent `protobuf:"bytes,2,opt,name=delete,proto3,oneof"`
}

func (*KvWatchEvent_Put) isKvWatchEvent_Event() {}

func (*KvWatchEvent_Delete) isKvWatchEvent_Event() {}

type KvPutEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value         []byte                 `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	Revision      uint64                 `protobuf:"varint,3,opt,name=revision,proto3" json:"revision,omitempty"`
	TsMs          int64                  `protobuf:"varint,4,opt,name=ts_ms,json=tsMs,proto3" json:"ts_ms,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvPutEvent) Reset() {
	*x = KvPutEvent{}
	mi := &file_kv_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvPutEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvPutEvent) ProtoMessage() {}

func (x *KvPutEvent) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[22]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvPutEvent.ProtoReflect.Descriptor instead.
func (*KvPutEvent) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{22}
}

func (x *KvPutEvent) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *KvPutEvent) GetValue() []byte {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *KvPutEvent) GetRevision() uint64 {
	if x != nil {
		return x.Revision
	}
	return 0
}

func (x *KvPutEvent) GetTsMs() int64 {
	if x != nil {
		return x.TsMs
	}
	return 0
}

type KvDeleteEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Revision      uint64                 `protobuf:"varint,2,opt,name=revision,proto3" json:"revision,omitempty"`
	TsMs          int64                  `protobuf:"varint,3,opt,name=ts_ms,json=tsMs,proto3" json:"ts_ms,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KvDeleteEvent) Reset() {
	*x = KvDeleteEvent{}
	mi := &file_kv_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KvDeleteEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KvDeleteEvent) ProtoMessage() {}

func (x *KvDeleteEvent) ProtoReflect() protoreflect.Message {
	mi := &file_kv_proto_msgTypes[23]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KvDeleteEvent.ProtoReflect.Descriptor instead.
func (*KvDeleteEvent) Descriptor() ([]byte, []int) {
	return file_kv_proto_rawDescGZIP(), []int{23}
}

func (x *KvDeleteEvent) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *KvDeleteEvent) GetRevision() uint64 {
	if x != nil {
		return x.Revision
	}
	return 0
}

func (x *KvDeleteEvent) GetTsMs() int64 {
	if x != nil {
		return x.TsMs
	}
	return 0
}

var File_kv_proto protoreflect.FileDescriptor

const file_kv_proto_rawDesc = "" +
	"\n" +
	"\bkv.proto\x12\vwaymaker.kv\"\xd3\x01\n" +
	"\x15KvCreateBucketRequest\x12\x16\n" +
	"\x06bucket\x18\x01 \x01(\tR\x06bucket\x12\x1b\n" +
	"\tmax_bytes\x18\x02 \x01(\x04R\bmaxBytes\x12$\n" +
	"\x0emax_value_size\x18\x03 \x01(\x04R\fmaxValueSize\x12\x1c\n" +
	"\n" +
	"max_age_ms\x18\x04 \x01(\x04R\bmaxAgeMs\x12\x1c\n" +
	"\tephemeral\x18\x05 \x01(\bR\tephemeral\x12#\n" +
	"\rmax_revisions\x18\x06 \x01(\x04R\fmaxRevisions\"m\n" +
	"\x16KvCreateBucketResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x1f\n" +
	"\vresult_code\x18\x02 \x01(\tR\n" +
	"resultCode\x12\x18\n" +
	"\amessage\x18\x03 \x01(\tR\amessage\"/\n" +
	"\x15KvDeleteBucketRequest\x12\x16\n" +
	"\x06bucket\x18\x01 \x01(\tR\x06bucket\"m\n" +
	"\x16KvDeleteBucketResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x1f\n" +
	"\vresult_code\x18\x02 \x01(\tR\n" +
	"resultCode\x12\x18\n" +
	"\amessage\x18\x03 \x01(\tR\amessage\"e\n" +
	"\fKvPutRequest\x12\x16\n" +
	"\x06bucket\x18\x01 \x01(\tR\x06bucket\x12\x10\n" +
	"\x03key\x18\x02 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x03 \x01(\fR\x05value\x12\x15\n" +
	"\x06ttl_ms\x18\x04 \x01(\x04R\x05ttlMs\"h\n" +
	"\x0fKvCreateRequest\x12\x16\n" +
	"\x06bucket\x18\x01 \x01(\tR\x06bucket\x12\x10\n" +
	"\x03key\x18\x02 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x03 \x01(\fR\x05value\x12\x15\n" +
	"\x06ttl_ms\x18\x04 \x01(\x04R\x05ttlMs\"\x95\x01\n" +
	"\x0fKvUpdateRequest\x12\x16\n" +
	"\x06bucket\x18\x01 \x01(\tR\x06bucket\x12\x10\n" +
	"\x03key\x18\x02 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x03 \x01(\fR\x05value\x12+\n" +
	"\x11expected_revision\x18\x04 \x01(\x04R\x10expectedRevision\x12\x15\n" +
	"\x06ttl_ms\x18\x05 \x01(\x04R\x05ttlMs\"\x80\x01\n" +
	"\rKvPutResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x1f\n" +
	"\vresult_code\x18\x02 \x01(\tR\n" +
	"resultCode\x12\x18\n" +
	"\amessage\x18\x03 \x01(\tR\amessage\x12\x1a\n" +
	"\brevision\x18\x04 \x01(\x04R\brevision\"8\n" +
	"\fKvGetRequest\x12\x16\n" +
	"\x06bucket\x18\x01 \x01(\tR\x06bucket\x12\x10\n" +
	"\x03key\x18\x02 \x01(\tR\x03key\"\x9f\x01\n" +
	"\rKvGetResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x1f\n" +
	"\vresult_code\x18\x02 \x01(\tR\n" +
	"resultCode\x12\x18\n" +
	"\amessage\x18\x03 \x01(\tR\amessage\x12/\n" +
	"\x05entry\x18\x04 \x01(\v2\x14.waymaker.kv.KvEntryH\x00R\x05entry\x88\x01\x01B\b\n" +
	"\x06_entry\"P\n" +
	"\aKvEntry\x12\x14\n" +
	"\x05value\x18\x01 \x01(\fR\x05value\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\x04R\brevision\x12\x13\n" +
	"\x05ts_ms\x18\x03 \x01(\x03R\x04tsMs\";\n" +
	"\x0fKvDeleteRequest\x12\x16\n" +
	"\x06bucket\x18\x01 \x01(\tR\x06bucket\x12\x10\n" +
	"\x03key\x18\x02 \x01(\tR\x03key\"\x83\x01\n" +
	"\x10KvDeleteResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x1f\n" +
	"\vresult_code\x18\x02 \x01(\tR\n" +
	"resultCode\x12\x18\n" +
	"\amessage\x18\x03 \x01(\tR\amessage\x12\x1a\n" +
	"\brevision\x18\x04 \x01(\x04R\brevision\"'\n" +
	"\rKvKeysRequest\x12\x16\n" +
	"\x06bucket\x18\x01 \x01(\tR\x06bucket\"\x98\x01\n" +
	"\x0eKvKeysResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x1f\n" +
	"\vresult_code\x18\x02 \x01(\tR\n" +
	"resultCode\x12\x18\n" +
	"\amessage\x18\x03 \x01(\tR\amessage\x121\n" +
	"\aentries\x18\x04 \x03(\v2\x17.waymaker.kv.KvKeyEntryR\aentries\"T\n" +
	"\n" +
	"KvKeyEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\x04R\brevision\x12\x18\n" +
	"\adeleted\x18\x03 \x01(\bR\adeleted\"w\n" +
	"\x10KvHistoryRequest\x12\x16\n" +
	"\x06bucket\x18\x01 \x01(\tR\x06bucket\x12\x10\n" +
	"\x03key\x18\x02 \x01(\tR\x03key\x12#\n" +
	"\rfrom_revision\x18\x03 \x01(\x04R\ffromRevision\x12\x14\n" +
	"\x05limit\x18\x04 \x01(\x04R\x05limit\"\x9f\x01\n" +
	"\x11KvHistoryResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x1f\n" +
	"\vresult_code\x18\x02 \x01(\tR\n" +
	"resultCode\x12\x18\n" +
	"\amessage\x18\x03 \x01(\tR\amessage\x125\n" +
	"\aentries\x18\x04 \x03(\v2\x1b.waymaker.kv.KvHistoryEntryR\aentries\"q\n" +
	"\x0eKvHistoryEntry\x12\x14\n" +
	"\x05value\x18\x01 \x01(\fR\x05value\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\x04R\brevision\x12\x13\n" +
	"\x05ts_ms\x18\x03 \x01(\x03R\x04tsMs\x12\x18\n" +
	"\adeleted\x18\x04 \x01(\bR\adeleted\"Q\n" +
	"\x0eKvTouchRequest\x12\x16\n" +
	"\x06bucket\x18\x01 \x01(\tR\x06bucket\x12\x10\n" +
	"\x03key\x18\x02 \x01(\tR\x03key\x12\x15\n" +
	"\x06ttl_ms\x18\x03 \x01(\x04R\x05ttlMs\":\n" +
	"\x0eKvWatchRequest\x12\x16\n" +
	"\x06bucket\x18\x01 \x01(\tR\x06bucket\x12\x10\n" +
	"\x03key\x18\x02 \x01(\tR\x03key\"z\n" +
	"\fKvWatchEvent\x12+\n" +
	"\x03put\x18\x01 \x01(\v2\x17.waymaker.kv.KvPutEventH\x00R\x03put\x124\n" +
	"\x06delete\x18\x02 \x01(\v2\x1a.waymaker.kv.KvDeleteEventH\x00R\x06deleteB\a\n" +
	"\x05event\"e\n" +
	"\n" +
	"KvPutEvent\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\fR\x05value\x12\x1a\n" +
	"\brevision\x18\x03 \x01(\x04R\brevision\x12\x13\n" +
	"\x05ts_ms\x18\x04 \x01(\x03R\x04tsMs\"R\n" +
	"\rKvDeleteEvent\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x1a\n" +
	"\brevision\x18\x02 \x01(\x04R\brevision\x12\x13\n" +
	"\x05ts_ms\x18\x03 \x01(\x03R\x04tsMs2\xa0\x06\n" +
	"\x11WaymakerKvService\x12W\n" +
	"\fCreateBucket\x12\".waymaker.kv.KvCreateBucketRequest\x1a#.waymaker.kv.KvCreateBucketResponse\x12W\n" +
	"\fDeleteBucket\x12\".waymaker.kv.KvDeleteBucketRequest\x1a#.waymaker.kv.KvDeleteBucketResponse\x12<\n" +
	"\x03Put\x12\x19.waymaker.kv.KvPutRequest\x1a\x1a.waymaker.kv.KvPutResponse\x12B\n" +
	"\x06Create\x12\x1c.waymaker.kv.KvCreateRequest\x1a\x1a.waymaker.kv.KvPutResponse\x12B\n" +
	"\x06Update\x12\x1c.waymaker.kv.KvUpdateRequest\x1a\x1a.waymaker.kv.KvPutResponse\x12E\n" +
	"\x06Delete\x12\x1c.waymaker.kv.KvDeleteRequest\x1a\x1d.waymaker.kv.KvDeleteResponse\x12<\n" +
	"\x03Get\x12\x19.waymaker.kv.KvGetRequest\x1a\x1a.waymaker.kv.KvGetResponse\x12?\n" +
	"\x04Keys\x12\x1a.waymaker.kv.KvKeysRequest\x1a\x1b.waymaker.kv.KvKeysResponse\x12H\n" +
	"\aHistory\x12\x1d.waymaker.kv.KvHistoryRequest\x1a\x1e.waymaker.kv.KvHistoryResponse\x12@\n" +
	"\x05Touch\x12\x1b.waymaker.kv.KvTouchRequest\x1a\x1a.waymaker.kv.KvPutResponse\x12A\n" +
	"\x05Watch\x12\x1b.waymaker.kv.KvWatchRequest\x1a\x19.waymaker.kv.KvWatchEvent0\x01B\x13Z\x11/apis/waymaker_kvb\x06proto3"

var (
	file_kv_proto_rawDescOnce sync.Once
	file_kv_proto_rawDescData []byte
)

func file_kv_proto_rawDescGZIP() []byte {
	file_kv_proto_rawDescOnce.Do(func() {
		file_kv_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_kv_proto_rawDesc), len(file_kv_proto_rawDesc)))
	})
	return file_kv_proto_rawDescData
}

var file_kv_proto_msgTypes = make([]protoimpl.MessageInfo, 24)
var file_kv_proto_goTypes = []any{
	(*KvCreateBucketRequest)(nil),  // 0: waymaker.kv.KvCreateBucketRequest
	(*KvCreateBucketResponse)(nil), // 1: waymaker.kv.KvCreateBucketResponse
	(*KvDeleteBucketRequest)(nil),  // 2: waymaker.kv.KvDeleteBucketRequest
	(*KvDeleteBucketResponse)(nil), // 3: waymaker.kv.KvDeleteBucketResponse
	(*KvPutRequest)(nil),           // 4: waymaker.kv.KvPutRequest
	(*KvCreateRequest)(nil),        // 5: waymaker.kv.KvCreateRequest
	(*KvUpdateRequest)(nil),        // 6: waymaker.kv.KvUpdateRequest
	(*KvPutResponse)(nil),          // 7: waymaker.kv.KvPutResponse
	(*KvGetRequest)(nil),           // 8: waymaker.kv.KvGetRequest
	(*KvGetResponse)(nil),          // 9: waymaker.kv.KvGetResponse
	(*KvEntry)(nil),                // 10: waymaker.kv.KvEntry
	(*KvDeleteRequest)(nil),        // 11: waymaker.kv.KvDeleteRequest
	(*KvDeleteResponse)(nil),       // 12: waymaker.kv.KvDeleteResponse
	(*KvKeysRequest)(nil),          // 13: waymaker.kv.KvKeysRequest
	(*KvKeysResponse)(nil),         // 14: waymaker.kv.KvKeysResponse
	(*KvKeyEntry)(nil),             // 15: waymaker.kv.KvKeyEntry
	(*KvHistoryRequest)(nil),       // 16: waymaker.kv.KvHistoryRequest
	(*KvHistoryResponse)(nil),      // 17: waymaker.kv.KvHistoryResponse
	(*KvHistoryEntry)(nil),         // 18: waymaker.kv.KvHistoryEntry
	(*KvTouchRequest)(nil),         // 19: waymaker.kv.KvTouchRequest
	(*KvWatchRequest)(nil),         // 20: waymaker.kv.KvWatchRequest
	(*KvWatchEvent)(nil),           // 21: waymaker.kv.KvWatchEvent
	(*KvPutEvent)(nil),             // 22: waymaker.kv.KvPutEvent
	(*KvDeleteEvent)(nil),          // 23: waymaker.kv.KvDeleteEvent
}
var file_kv_proto_depIdxs = []int32{
	10, // 0: waymaker.kv.KvGetResponse.entry:type_name -> waymaker.kv.KvEntry
	15, // 1: waymaker.kv.KvKeysResponse.entries:type_name -> waymaker.kv.KvKeyEntry
	18, // 2: waymaker.kv.KvHistoryResponse.entries:type_name -> waymaker.kv.KvHistoryEntry
	22, // 3: waymaker.kv.KvWatchEvent.put:type_name -> waymaker.kv.KvPutEvent
	23, // 4: waymaker.kv.KvWatchEvent.delete:type_name -> waymaker.kv.KvDeleteEvent
	0,  // 5: waymaker.kv.WaymakerKvService.CreateBucket:input_type -> waymaker.kv.KvCreateBucketRequest
	2,  // 6: waymaker.kv.WaymakerKvService.DeleteBucket:input_type -> waymaker.kv.KvDeleteBucketRequest
	4,  // 7: waymaker.kv.WaymakerKvService.Put:input_type -> waymaker.kv.KvPutRequest
	5,  // 8: waymaker.kv.WaymakerKvService.Create:input_type -> waymaker.kv.KvCreateRequest
	6,  // 9: waymaker.kv.WaymakerKvService.Update:input_type -> waymaker.kv.KvUpdateRequest
	11, // 10: waymaker.kv.WaymakerKvService.Delete:input_type -> waymaker.kv.KvDeleteRequest
	8,  // 11: waymaker.kv.WaymakerKvService.Get:input_type -> waymaker.kv.KvGetRequest
	13, // 12: waymaker.kv.WaymakerKvService.Keys:input_type -> waymaker.kv.KvKeysRequest
	16, // 13: waymaker.kv.WaymakerKvService.History:input_type -> waymaker.kv.KvHistoryRequest
	19, // 14: waymaker.kv.WaymakerKvService.Touch:input_type -> waymaker.kv.KvTouchRequest
	20, // 15: waymaker.kv.WaymakerKvService.Watch:input_type -> waymaker.kv.KvWatchRequest
	1,  // 16: waymaker.kv.WaymakerKvService.CreateBucket:output_type -> waymaker.kv.KvCreateBucketResponse
	3,  // 17: waymaker.kv.WaymakerKvService.DeleteBucket:output_type -> waymaker.kv.KvDeleteBucketResponse
	7,  // 18: waymaker.kv.WaymakerKvService.Put:output_type -> waymaker.kv.KvPutResponse
	7,  // 19: waymaker.kv.WaymakerKvService.Create:output_type -> waymaker.kv.KvPutResponse
	7,  // 20: waymaker.kv.WaymakerKvService.Update:output_type -> waymaker.kv.KvPutResponse
	12, // 21: waymaker.kv.WaymakerKvService.Delete:output_type -> waymaker.kv.KvDeleteResponse
	9,  // 22: waymaker.kv.WaymakerKvService.Get:output_type -> waymaker.kv.KvGetResponse
	14, // 23: waymaker.kv.WaymakerKvService.Keys:output_type -> waymaker.kv.KvKeysResponse
	17, // 24: waymaker.kv.WaymakerKvService.History:output_type -> waymaker.kv.KvHistoryResponse
	7,  // 25: waymaker.kv.WaymakerKvService.Touch:output_type -> waymaker.kv.KvPutResponse
	21, // 26: waymaker.kv.WaymakerKvService.Watch:output_type -> waymaker.kv.KvWatchEvent
	16, // [16:27] is the sub-list for method output_type
	5,  // [5:16] is the sub-list for method input_type
	5,  // [5:5] is the sub-list for extension type_name
	5,  // [5:5] is the sub-list for extension extendee
	0,  // [0:5] is the sub-list for field type_name
}

func init() { file_kv_proto_init() }
func file_kv_proto_init() {
	if File_kv_proto != nil {
		return
	}
	file_kv_proto_msgTypes[9].OneofWrappers = []any{}
	file_kv_proto_msgTypes[21].OneofWrappers = []any{
		(*KvWatchEvent_Put)(nil),
		(*KvWatchEvent_Delete)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_kv_proto_rawDesc), len(file_kv_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   24,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_kv_proto_goTypes,
		DependencyIndexes: file_kv_proto_depIdxs,
		MessageInfos:      file_kv_proto_msgTypes,
	}.Build()
	File_kv_proto = out.File
	file_kv_proto_goTypes = nil
	file_kv_proto_depIdxs = nil
}