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

package waymaker

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)
)

// LockEventType defines the various types of events that can occur during
// the lock acquisition process.
type LockEventType int32

const (
	LockEventType_Unknown   LockEventType = 0 // Default value when the event type is not known.
	LockEventType_Waiting   LockEventType = 1 // Indicates that the lock request is waiting to be granted.
	LockEventType_Acquired  LockEventType = 2 // Indicates that the lock has been successfully acquired.
	LockEventType_Failed    LockEventType = 3 // Indicates that the lock request has failed.
	LockEventType_Expired   LockEventType = 4 // Indicates that the lock has expired.
	LockEventType_Heartbeat LockEventType = 5 // Periodic event indicating that the lock is still active.
)

// Enum value maps for LockEventType.
var (
	LockEventType_name = map[int32]string{
		0: "Unknown",
		1: "Waiting",
		2: "Acquired",
		3: "Failed",
		4: "Expired",
		5: "Heartbeat",
	}
	LockEventType_value = map[string]int32{
		"Unknown":   0,
		"Waiting":   1,
		"Acquired":  2,
		"Failed":    3,
		"Expired":   4,
		"Heartbeat": 5,
	}
)

func (x LockEventType) Enum() *LockEventType {
	p := new(LockEventType)
	*p = x
	return p
}

func (x LockEventType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (LockEventType) Descriptor() protoreflect.EnumDescriptor {
	return file_waymaker_locks_proto_enumTypes[0].Descriptor()
}

func (LockEventType) Type() protoreflect.EnumType {
	return &file_waymaker_locks_proto_enumTypes[0]
}

func (x LockEventType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use LockEventType.Descriptor instead.
func (LockEventType) EnumDescriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{0}
}

// FenceScope controls ONE thing: how durable the per-key fence_token
// counter (the monotonic uint64) is across failures. Three things it does
// NOT control — do not conflate them with the scope:
//
//   - Whether a HELD LOCK survives a node loss / rollout. That is
//     cluster.replication-factor plus secondary adoption, and it already
//     applies to every non-Ephemeral lock regardless of scope. A stronger
//     scope does not make a lock survive; a replicated lease does.
//
//   - Client-side transparency across a primary bounce. The lock client
//     transparently re-binds its event stream and re-confirms ownership
//     after a disconnect, but that is a client-lib behaviour — no scope
//     value changes it.
//
//   - Mutual exclusion. Holding the lock is NOT, by itself, a guarantee
//     that no one else acts. The holder MUST validate fence_token at its
//     own side effect (the DB write / object PUT) and reject anything
//     carrying a fence below the last one it durably committed. Even
//     ScopeQuorum does not let you skip that check — an all-at-once
//     cluster restart can still drop an in-memory token. See USAGE.md
//     "Fence tokens" for the enforcement rule.
//
//     Unspecified: server treats as Ephemeral.
//     Ephemeral:   per-key counter in RAM on the owning node. Resets on
//     process restart or hash-ring rebalance. Fast — no I/O.
//     Right for rate limiting, cache lockout, advisory locks,
//     anywhere fence resets across failure are tolerable.
//     Local:       per-key counter persisted to disk on the owning node.
//     Survives process restart on the same node. Still resets
//     on hash-ring rebalance (a different node has its own
//     disk). One fsync per acquire (~1-5ms on SSD).
//     Quorum:      Raft-replicated per-key counter — cluster-wide monotonic,
//     survives any single-node failure (the surviving quorum
//     keeps the count). One Raft commit per acquire (~5ms).
//     Requires the cluster Raft backend to be wired; a
//     single-node or test build returns BadInput for this
//     scope. Pick this when an external resource fences on the
//     token and two holders must never see fences that fail to
//     prove an ordering. (Named Quorum, not Global: the
//     guarantee is "a Raft quorum agrees on the count", which
//     carries its own limit and makes no geographic claim.)
type FenceScope int32

const (
	FenceScope_ScopeUnspecified FenceScope = 0
	FenceScope_ScopeEphemeral   FenceScope = 1
	FenceScope_ScopeLocal       FenceScope = 2
	// Wire value 3 is unchanged from the former ScopeGlobal — old and new
	// binaries interoperate mid-rollout; only the symbol name changed.
	FenceScope_ScopeQuorum FenceScope = 3
)

// Enum value maps for FenceScope.
var (
	FenceScope_name = map[int32]string{
		0: "ScopeUnspecified",
		1: "ScopeEphemeral",
		2: "ScopeLocal",
		3: "ScopeQuorum",
	}
	FenceScope_value = map[string]int32{
		"ScopeUnspecified": 0,
		"ScopeEphemeral":   1,
		"ScopeLocal":       2,
		"ScopeQuorum":      3,
	}
)

func (x FenceScope) Enum() *FenceScope {
	p := new(FenceScope)
	*p = x
	return p
}

func (x FenceScope) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (FenceScope) Descriptor() protoreflect.EnumDescriptor {
	return file_waymaker_locks_proto_enumTypes[1].Descriptor()
}

func (FenceScope) Type() protoreflect.EnumType {
	return &file_waymaker_locks_proto_enumTypes[1]
}

func (x FenceScope) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use FenceScope.Descriptor instead.
func (FenceScope) EnumDescriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{1}
}

// LockRequest defines the parameters for requesting a lock.
type LockRequest struct {
	state                protoimpl.MessageState `protogen:"open.v1"`
	Key                  string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`                                                                // The unique key representing the lock.
	MaxWaitPeriod        uint32                 `protobuf:"varint,2,opt,name=max_wait_period,json=maxWaitPeriod,proto3" json:"max_wait_period,omitempty"`                    // The maximum time (in milliseconds) to wait for the lock to be granted.
	MaxLeasePeriod       uint32                 `protobuf:"varint,3,opt,name=max_lease_period,json=maxLeasePeriod,proto3" json:"max_lease_period,omitempty"`                 // The maximum time (in milliseconds) the lock can be held.
	Priority             uint32                 `protobuf:"varint,4,opt,name=priority,proto3" json:"priority,omitempty"`                                                     // The priority level of the lock request.
	RequesterInfo        string                 `protobuf:"bytes,10,opt,name=requester_info,json=requesterInfo,proto3" json:"requester_info,omitempty"`                      // Additional information about the requester.
	RequesterApplication string                 `protobuf:"bytes,11,opt,name=requester_application,json=requesterApplication,proto3" json:"requester_application,omitempty"` // The name of the application making the request.
	RequestId            string                 `protobuf:"bytes,12,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`                                  // Idempotency key for retries of the same logical acquire request.
	FenceScope           FenceScope             `protobuf:"varint,13,opt,name=fence_scope,json=fenceScope,proto3,enum=waymaker.FenceScope" json:"fence_scope,omitempty"`     // Persistence/durability tier for fence_token. Defaults to Ephemeral.
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

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

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

func (*LockRequest) ProtoMessage() {}

func (x *LockRequest) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 LockRequest.ProtoReflect.Descriptor instead.
func (*LockRequest) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{0}
}

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

func (x *LockRequest) GetMaxWaitPeriod() uint32 {
	if x != nil {
		return x.MaxWaitPeriod
	}
	return 0
}

func (x *LockRequest) GetMaxLeasePeriod() uint32 {
	if x != nil {
		return x.MaxLeasePeriod
	}
	return 0
}

func (x *LockRequest) GetPriority() uint32 {
	if x != nil {
		return x.Priority
	}
	return 0
}

func (x *LockRequest) GetRequesterInfo() string {
	if x != nil {
		return x.RequesterInfo
	}
	return ""
}

func (x *LockRequest) GetRequesterApplication() string {
	if x != nil {
		return x.RequesterApplication
	}
	return ""
}

func (x *LockRequest) GetRequestId() string {
	if x != nil {
		return x.RequestId
	}
	return ""
}

func (x *LockRequest) GetFenceScope() FenceScope {
	if x != nil {
		return x.FenceScope
	}
	return FenceScope_ScopeUnspecified
}

// LockEvent represents an event related to the lock acquisition process.
type LockEvent struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	Success          bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`                                                  // Indicates whether the event was successful.
	EventType        LockEventType          `protobuf:"varint,2,opt,name=event_type,json=eventType,proto3,enum=waymaker.LockEventType" json:"event_type,omitempty"` // The type of event that occurred.
	Message          string                 `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`                                                   // A message providing additional details about the event.
	Id               string                 `protobuf:"bytes,4,opt,name=id,proto3" json:"id,omitempty"`                                                             // The unique identifier of the lock.
	Key              string                 `protobuf:"bytes,5,opt,name=key,proto3" json:"key,omitempty"`                                                           // The key associated with the lock.
	LeaseExpiresAt   int64                  `protobuf:"varint,6,opt,name=lease_expires_at,json=leaseExpiresAt,proto3" json:"lease_expires_at,omitempty"`            // The timestamp (in Unix milliseconds) when the lease expires.
	AcquiredAt       int64                  `protobuf:"varint,7,opt,name=acquired_at,json=acquiredAt,proto3" json:"acquired_at,omitempty"`                          // The timestamp (in Unix milliseconds) when the lock was acquired.
	WaitingExpiresAt int64                  `protobuf:"varint,8,opt,name=waiting_expires_at,json=waitingExpiresAt,proto3" json:"waiting_expires_at,omitempty"`      // The timestamp (in Unix milliseconds) when the waiting period expires.
	// Monotonic-per-key fence token assigned at acquire. Increments by 1 per
	// successful acquisition of `key`. 0 on non-Acquired events.
	//
	// Held in RAM on the consistent-hash-owning node. Monotonic within that
	// node's process lifetime; resets to 0 across node restart, crash, or
	// hash-ring rebalance. This is intentional — see README "Known
	// limitations" and "When to use waymaker" for the use cases this suits
	// vs. when to reach for a different tool (etcd / ZooKeeper / Consul).
	FenceToken    uint64 `protobuf:"varint,9,opt,name=fence_token,json=fenceToken,proto3" json:"fence_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LockEvent) ProtoMessage() {}

func (x *LockEvent) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 LockEvent.ProtoReflect.Descriptor instead.
func (*LockEvent) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{1}
}

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

func (x *LockEvent) GetEventType() LockEventType {
	if x != nil {
		return x.EventType
	}
	return LockEventType_Unknown
}

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

func (x *LockEvent) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

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

func (x *LockEvent) GetLeaseExpiresAt() int64 {
	if x != nil {
		return x.LeaseExpiresAt
	}
	return 0
}

func (x *LockEvent) GetAcquiredAt() int64 {
	if x != nil {
		return x.AcquiredAt
	}
	return 0
}

func (x *LockEvent) GetWaitingExpiresAt() int64 {
	if x != nil {
		return x.WaitingExpiresAt
	}
	return 0
}

func (x *LockEvent) GetFenceToken() uint64 {
	if x != nil {
		return x.FenceToken
	}
	return 0
}

// UnLockRequest defines the parameters for releasing a lock.
type UnLockRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` // The unique key representing the lock.
	Id            string                 `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`   // The unique identifier of the lock to be released.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UnLockRequest) ProtoMessage() {}

func (x *UnLockRequest) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 UnLockRequest.ProtoReflect.Descriptor instead.
func (*UnLockRequest) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{2}
}

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

func (x *UnLockRequest) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

// UnLockResponse represents the response to an UnLock request.
type UnLockResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`                        // Indicates whether the unlock operation was successful.
	ResultCode    string                 `protobuf:"bytes,2,opt,name=result_code,json=resultCode,proto3" json:"result_code,omitempty"` // A code indicating the result of the unlock operation.
	Message       string                 `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`                         // A message providing additional details about the unlock operation.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UnLockResponse) ProtoMessage() {}

func (x *UnLockResponse) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 UnLockResponse.ProtoReflect.Descriptor instead.
func (*UnLockResponse) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{3}
}

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

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

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

// Lease represents the details of a lock lease.
type Lease struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	Id               string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`                                                        // The unique identifier of the lock.
	Key              string                 `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`                                                      // The key associated with the lock.
	Acquired         bool                   `protobuf:"varint,3,opt,name=acquired,proto3" json:"acquired,omitempty"`                                           // Indicates whether the lock has been acquired.
	Priority         uint32                 `protobuf:"varint,5,opt,name=priority,proto3" json:"priority,omitempty"`                                           // The priority level of the lock.
	CreatedAt        int64                  `protobuf:"varint,6,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`                        // The timestamp (in Unix milliseconds) when the lock was created.
	LeaseExpiresAt   int64                  `protobuf:"varint,7,opt,name=lease_expires_at,json=leaseExpiresAt,proto3" json:"lease_expires_at,omitempty"`       // The timestamp (in Unix milliseconds) when the lease expires.
	WaitingExpiresAt int64                  `protobuf:"varint,8,opt,name=waiting_expires_at,json=waitingExpiresAt,proto3" json:"waiting_expires_at,omitempty"` // The timestamp (in Unix milliseconds) when the waiting period expires.
	// Fence token assigned at acquire. See LockEvent.fence_token caveats.
	FenceToken    uint64 `protobuf:"varint,9,opt,name=fence_token,json=fenceToken,proto3" json:"fence_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Lease) ProtoMessage() {}

func (x *Lease) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 Lease.ProtoReflect.Descriptor instead.
func (*Lease) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{4}
}

func (x *Lease) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

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

func (x *Lease) GetAcquired() bool {
	if x != nil {
		return x.Acquired
	}
	return false
}

func (x *Lease) GetPriority() uint32 {
	if x != nil {
		return x.Priority
	}
	return 0
}

func (x *Lease) GetCreatedAt() int64 {
	if x != nil {
		return x.CreatedAt
	}
	return 0
}

func (x *Lease) GetLeaseExpiresAt() int64 {
	if x != nil {
		return x.LeaseExpiresAt
	}
	return 0
}

func (x *Lease) GetWaitingExpiresAt() int64 {
	if x != nil {
		return x.WaitingExpiresAt
	}
	return 0
}

func (x *Lease) GetFenceToken() uint64 {
	if x != nil {
		return x.FenceToken
	}
	return 0
}

// ExtendLeaseRequest defines the parameters for extending the lease of a lock.
type ExtendLeaseRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`                                        // The unique key representing the lock.
	Id            string                 `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`                                          // The unique identifier of the lock to extend the lease for.
	LeaseTimeout  uint32                 `protobuf:"varint,3,opt,name=lease_timeout,json=leaseTimeout,proto3" json:"lease_timeout,omitempty"` // The additional time (in milliseconds) to extend the lease.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ExtendLeaseRequest) ProtoMessage() {}

func (x *ExtendLeaseRequest) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 ExtendLeaseRequest.ProtoReflect.Descriptor instead.
func (*ExtendLeaseRequest) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{5}
}

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

func (x *ExtendLeaseRequest) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *ExtendLeaseRequest) GetLeaseTimeout() uint32 {
	if x != nil {
		return x.LeaseTimeout
	}
	return 0
}

// ExtendLeaseResponse represents the response to an ExtendLease request.
type ExtendLeaseResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`                        // Indicates whether the lease extension was successful.
	ResultCode    string                 `protobuf:"bytes,2,opt,name=result_code,json=resultCode,proto3" json:"result_code,omitempty"` // A code indicating the result of the lease extension.
	Message       string                 `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`                         // A message providing additional details about the lease extension.
	Lease         *Lease                 `protobuf:"bytes,4,opt,name=lease,proto3" json:"lease,omitempty"`                             // The updated lease details after the extension.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ExtendLeaseResponse) ProtoMessage() {}

func (x *ExtendLeaseResponse) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 ExtendLeaseResponse.ProtoReflect.Descriptor instead.
func (*ExtendLeaseResponse) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{6}
}

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

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

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

func (x *ExtendLeaseResponse) GetLease() *Lease {
	if x != nil {
		return x.Lease
	}
	return nil
}

// LeaseStatusRequest defines the parameters for retrieving the status of a lock lease.
type LeaseStatusRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` // The unique key representing the lock.
	Id            string                 `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`   // The unique identifier of the lock to check the status of.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LeaseStatusRequest) ProtoMessage() {}

func (x *LeaseStatusRequest) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 LeaseStatusRequest.ProtoReflect.Descriptor instead.
func (*LeaseStatusRequest) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{7}
}

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

func (x *LeaseStatusRequest) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

// LeaseStatusResponse represents the response to a LeaseStatus request.
type LeaseStatusResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`                        // Indicates whether the lease status retrieval was successful.
	ResultCode    string                 `protobuf:"bytes,2,opt,name=result_code,json=resultCode,proto3" json:"result_code,omitempty"` // A code indicating the result of the lease status retrieval.
	Message       string                 `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`                         // A message providing additional details about the lease status retrieval.
	Lease         *Lease                 `protobuf:"bytes,4,opt,name=lease,proto3" json:"lease,omitempty"`                             // The current lease details for the lock.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LeaseStatusResponse) ProtoMessage() {}

func (x *LeaseStatusResponse) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 LeaseStatusResponse.ProtoReflect.Descriptor instead.
func (*LeaseStatusResponse) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{8}
}

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

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

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

func (x *LeaseStatusResponse) GetLease() *Lease {
	if x != nil {
		return x.Lease
	}
	return nil
}

// A single (key, lock-kind) entry inside a MultiLockRequest.
type MultiLockKey struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`                               // The unique key representing the lock.
	WriteLock     bool                   `protobuf:"varint,2,opt,name=write_lock,json=writeLock,proto3" json:"write_lock,omitempty"` // true = exclusive (write), false = shared (read).
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MultiLockKey) ProtoMessage() {}

func (x *MultiLockKey) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 MultiLockKey.ProtoReflect.Descriptor instead.
func (*MultiLockKey) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{9}
}

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

func (x *MultiLockKey) GetWriteLock() bool {
	if x != nil {
		return x.WriteLock
	}
	return false
}

// MultiLockRequest defines the parameters for atomically acquiring N locks.
// See MultiLock RPC docs for ordering and rollback semantics.
type MultiLockRequest struct {
	state                protoimpl.MessageState `protogen:"open.v1"`
	Keys                 []*MultiLockKey        `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"`                                              // 1..N keys to acquire. Re-ordered server-side.
	MaxWaitPeriod        uint32                 `protobuf:"varint,2,opt,name=max_wait_period,json=maxWaitPeriod,proto3" json:"max_wait_period,omitempty"`    // Total batch deadline (ms). Per-key budget is the remainder.
	MaxLeasePeriod       uint32                 `protobuf:"varint,3,opt,name=max_lease_period,json=maxLeasePeriod,proto3" json:"max_lease_period,omitempty"` // Per-key lease length (ms).
	Priority             uint32                 `protobuf:"varint,4,opt,name=priority,proto3" json:"priority,omitempty"`                                     // Priority applied to every key.
	RequesterInfo        string                 `protobuf:"bytes,10,opt,name=requester_info,json=requesterInfo,proto3" json:"requester_info,omitempty"`
	RequesterApplication string                 `protobuf:"bytes,11,opt,name=requester_application,json=requesterApplication,proto3" json:"requester_application,omitempty"`
	RequestId            string                 `protobuf:"bytes,12,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`                              // Idempotency key for the batch.
	FenceScope           FenceScope             `protobuf:"varint,13,opt,name=fence_scope,json=fenceScope,proto3,enum=waymaker.FenceScope" json:"fence_scope,omitempty"` // Applies to every key in the batch.
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

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

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

func (*MultiLockRequest) ProtoMessage() {}

func (x *MultiLockRequest) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 MultiLockRequest.ProtoReflect.Descriptor instead.
func (*MultiLockRequest) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{10}
}

func (x *MultiLockRequest) GetKeys() []*MultiLockKey {
	if x != nil {
		return x.Keys
	}
	return nil
}

func (x *MultiLockRequest) GetMaxWaitPeriod() uint32 {
	if x != nil {
		return x.MaxWaitPeriod
	}
	return 0
}

func (x *MultiLockRequest) GetMaxLeasePeriod() uint32 {
	if x != nil {
		return x.MaxLeasePeriod
	}
	return 0
}

func (x *MultiLockRequest) GetPriority() uint32 {
	if x != nil {
		return x.Priority
	}
	return 0
}

func (x *MultiLockRequest) GetRequesterInfo() string {
	if x != nil {
		return x.RequesterInfo
	}
	return ""
}

func (x *MultiLockRequest) GetRequesterApplication() string {
	if x != nil {
		return x.RequesterApplication
	}
	return ""
}

func (x *MultiLockRequest) GetRequestId() string {
	if x != nil {
		return x.RequestId
	}
	return ""
}

func (x *MultiLockRequest) GetFenceScope() FenceScope {
	if x != nil {
		return x.FenceScope
	}
	return FenceScope_ScopeUnspecified
}

// MultiLockResponse — unary result of a MultiLock attempt.
type MultiLockResponse struct {
	state      protoimpl.MessageState `protogen:"open.v1"`
	Success    bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`                        // true iff all keys were acquired.
	ResultCode string                 `protobuf:"bytes,2,opt,name=result_code,json=resultCode,proto3" json:"result_code,omitempty"` // "ok" | "timeout" | "no_keys" | "invalid_scope" | "internal"
	Message    string                 `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`                         // Free-form detail; empty on success.
	// Populated only on success, in lexicographic key order (the order the
	// server acquired them in). On failure this is empty and any locks
	// briefly held during the attempt have already been released.
	Leases        []*Lease `protobuf:"bytes,4,rep,name=leases,proto3" json:"leases,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MultiLockResponse) ProtoMessage() {}

func (x *MultiLockResponse) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 MultiLockResponse.ProtoReflect.Descriptor instead.
func (*MultiLockResponse) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{11}
}

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

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

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

func (x *MultiLockResponse) GetLeases() []*Lease {
	if x != nil {
		return x.Leases
	}
	return nil
}

// ListAcquiredLocksRequest — filter for ListAcquiredLocks.
type ListAcquiredLocksRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	KeyPrefix     string                 `protobuf:"bytes,1,opt,name=key_prefix,json=keyPrefix,proto3" json:"key_prefix,omitempty"` // Optional; empty = every held key on this node.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListAcquiredLocksRequest) ProtoMessage() {}

func (x *ListAcquiredLocksRequest) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 ListAcquiredLocksRequest.ProtoReflect.Descriptor instead.
func (*ListAcquiredLocksRequest) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{12}
}

func (x *ListAcquiredLocksRequest) GetKeyPrefix() string {
	if x != nil {
		return x.KeyPrefix
	}
	return ""
}

// AcquiredLock — one lock currently HELD (not waiting) on the serving node.
type AcquiredLock struct {
	state                protoimpl.MessageState `protogen:"open.v1"`
	Key                  string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`                                                                // The lock key.
	LockId               string                 `protobuf:"bytes,2,opt,name=lock_id,json=lockId,proto3" json:"lock_id,omitempty"`                                            // The holder's unique lock id.
	WriteLock            bool                   `protobuf:"varint,3,opt,name=write_lock,json=writeLock,proto3" json:"write_lock,omitempty"`                                  // true = exclusive (write); false = shared (read).
	Priority             uint32                 `protobuf:"varint,4,opt,name=priority,proto3" json:"priority,omitempty"`                                                     // Priority the lock was acquired at.
	FenceToken           uint64                 `protobuf:"varint,5,opt,name=fence_token,json=fenceToken,proto3" json:"fence_token,omitempty"`                               // Fence token assigned at acquire.
	LeaseExpiresAt       int64                  `protobuf:"varint,6,opt,name=lease_expires_at,json=leaseExpiresAt,proto3" json:"lease_expires_at,omitempty"`                 // Lease expiry (epoch ms).
	AcquiredAt           int64                  `protobuf:"varint,7,opt,name=acquired_at,json=acquiredAt,proto3" json:"acquired_at,omitempty"`                               // Acquire time (epoch ms).
	RequestId            string                 `protobuf:"bytes,8,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`                                   // Idempotency key of the acquire.
	RequesterInfo        string                 `protobuf:"bytes,9,opt,name=requester_info,json=requesterInfo,proto3" json:"requester_info,omitempty"`                       // Caller-supplied requester metadata (free-form string).
	RequesterApplication string                 `protobuf:"bytes,10,opt,name=requester_application,json=requesterApplication,proto3" json:"requester_application,omitempty"` // Caller-supplied application name.
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

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

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

func (*AcquiredLock) ProtoMessage() {}

func (x *AcquiredLock) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 AcquiredLock.ProtoReflect.Descriptor instead.
func (*AcquiredLock) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{13}
}

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

func (x *AcquiredLock) GetLockId() string {
	if x != nil {
		return x.LockId
	}
	return ""
}

func (x *AcquiredLock) GetWriteLock() bool {
	if x != nil {
		return x.WriteLock
	}
	return false
}

func (x *AcquiredLock) GetPriority() uint32 {
	if x != nil {
		return x.Priority
	}
	return 0
}

func (x *AcquiredLock) GetFenceToken() uint64 {
	if x != nil {
		return x.FenceToken
	}
	return 0
}

func (x *AcquiredLock) GetLeaseExpiresAt() int64 {
	if x != nil {
		return x.LeaseExpiresAt
	}
	return 0
}

func (x *AcquiredLock) GetAcquiredAt() int64 {
	if x != nil {
		return x.AcquiredAt
	}
	return 0
}

func (x *AcquiredLock) GetRequestId() string {
	if x != nil {
		return x.RequestId
	}
	return ""
}

func (x *AcquiredLock) GetRequesterInfo() string {
	if x != nil {
		return x.RequesterInfo
	}
	return ""
}

func (x *AcquiredLock) GetRequesterApplication() string {
	if x != nil {
		return x.RequesterApplication
	}
	return ""
}

// ListAcquiredLocksResponse — held locks on the serving node.
type ListAcquiredLocksResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Locks         []*AcquiredLock        `protobuf:"bytes,2,rep,name=locks,proto3" json:"locks,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListAcquiredLocksResponse) ProtoMessage() {}

func (x *ListAcquiredLocksResponse) ProtoReflect() protoreflect.Message {
	mi := &file_waymaker_locks_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 ListAcquiredLocksResponse.ProtoReflect.Descriptor instead.
func (*ListAcquiredLocksResponse) Descriptor() ([]byte, []int) {
	return file_waymaker_locks_proto_rawDescGZIP(), []int{14}
}

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

func (x *ListAcquiredLocksResponse) GetLocks() []*AcquiredLock {
	if x != nil {
		return x.Locks
	}
	return nil
}

var File_waymaker_locks_proto protoreflect.FileDescriptor

const file_waymaker_locks_proto_rawDesc = "" +
	"\n" +
	"\x14waymaker_locks.proto\x12\bwaymaker\"\xbf\x02\n" +
	"\vLockRequest\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12&\n" +
	"\x0fmax_wait_period\x18\x02 \x01(\rR\rmaxWaitPeriod\x12(\n" +
	"\x10max_lease_period\x18\x03 \x01(\rR\x0emaxLeasePeriod\x12\x1a\n" +
	"\bpriority\x18\x04 \x01(\rR\bpriority\x12%\n" +
	"\x0erequester_info\x18\n" +
	" \x01(\tR\rrequesterInfo\x123\n" +
	"\x15requester_application\x18\v \x01(\tR\x14requesterApplication\x12\x1d\n" +
	"\n" +
	"request_id\x18\f \x01(\tR\trequestId\x125\n" +
	"\vfence_scope\x18\r \x01(\x0e2\x14.waymaker.FenceScopeR\n" +
	"fenceScope\"\xb3\x02\n" +
	"\tLockEvent\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x126\n" +
	"\n" +
	"event_type\x18\x02 \x01(\x0e2\x17.waymaker.LockEventTypeR\teventType\x12\x18\n" +
	"\amessage\x18\x03 \x01(\tR\amessage\x12\x0e\n" +
	"\x02id\x18\x04 \x01(\tR\x02id\x12\x10\n" +
	"\x03key\x18\x05 \x01(\tR\x03key\x12(\n" +
	"\x10lease_expires_at\x18\x06 \x01(\x03R\x0eleaseExpiresAt\x12\x1f\n" +
	"\vacquired_at\x18\a \x01(\x03R\n" +
	"acquiredAt\x12,\n" +
	"\x12waiting_expires_at\x18\b \x01(\x03R\x10waitingExpiresAt\x12\x1f\n" +
	"\vfence_token\x18\t \x01(\x04R\n" +
	"fenceToken\"1\n" +
	"\rUnLockRequest\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x0e\n" +
	"\x02id\x18\x02 \x01(\tR\x02id\"e\n" +
	"\x0eUnLockResponse\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\"\xff\x01\n" +
	"\x05Lease\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x10\n" +
	"\x03key\x18\x02 \x01(\tR\x03key\x12\x1a\n" +
	"\bacquired\x18\x03 \x01(\bR\bacquired\x12\x1a\n" +
	"\bpriority\x18\x05 \x01(\rR\bpriority\x12\x1d\n" +
	"\n" +
	"created_at\x18\x06 \x01(\x03R\tcreatedAt\x12(\n" +
	"\x10lease_expires_at\x18\a \x01(\x03R\x0eleaseExpiresAt\x12,\n" +
	"\x12waiting_expires_at\x18\b \x01(\x03R\x10waitingExpiresAt\x12\x1f\n" +
	"\vfence_token\x18\t \x01(\x04R\n" +
	"fenceTokenJ\x04\b\x04\x10\x05\"[\n" +
	"\x12ExtendLeaseRequest\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x0e\n" +
	"\x02id\x18\x02 \x01(\tR\x02id\x12#\n" +
	"\rlease_timeout\x18\x03 \x01(\rR\fleaseTimeout\"\x91\x01\n" +
	"\x13ExtendLeaseResponse\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" +
	"\x05lease\x18\x04 \x01(\v2\x0f.waymaker.LeaseR\x05lease\"6\n" +
	"\x12LeaseStatusRequest\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x0e\n" +
	"\x02id\x18\x02 \x01(\tR\x02id\"\x91\x01\n" +
	"\x13LeaseStatusResponse\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" +
	"\x05lease\x18\x04 \x01(\v2\x0f.waymaker.LeaseR\x05lease\"?\n" +
	"\fMultiLockKey\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x1d\n" +
	"\n" +
	"write_lock\x18\x02 \x01(\bR\twriteLock\"\xde\x02\n" +
	"\x10MultiLockRequest\x12*\n" +
	"\x04keys\x18\x01 \x03(\v2\x16.waymaker.MultiLockKeyR\x04keys\x12&\n" +
	"\x0fmax_wait_period\x18\x02 \x01(\rR\rmaxWaitPeriod\x12(\n" +
	"\x10max_lease_period\x18\x03 \x01(\rR\x0emaxLeasePeriod\x12\x1a\n" +
	"\bpriority\x18\x04 \x01(\rR\bpriority\x12%\n" +
	"\x0erequester_info\x18\n" +
	" \x01(\tR\rrequesterInfo\x123\n" +
	"\x15requester_application\x18\v \x01(\tR\x14requesterApplication\x12\x1d\n" +
	"\n" +
	"request_id\x18\f \x01(\tR\trequestId\x125\n" +
	"\vfence_scope\x18\r \x01(\x0e2\x14.waymaker.FenceScopeR\n" +
	"fenceScope\"\x91\x01\n" +
	"\x11MultiLockResponse\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" +
	"\x06leases\x18\x04 \x03(\v2\x0f.waymaker.LeaseR\x06leases\"9\n" +
	"\x18ListAcquiredLocksRequest\x12\x1d\n" +
	"\n" +
	"key_prefix\x18\x01 \x01(\tR\tkeyPrefix\"\xdb\x02\n" +
	"\fAcquiredLock\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x17\n" +
	"\alock_id\x18\x02 \x01(\tR\x06lockId\x12\x1d\n" +
	"\n" +
	"write_lock\x18\x03 \x01(\bR\twriteLock\x12\x1a\n" +
	"\bpriority\x18\x04 \x01(\rR\bpriority\x12\x1f\n" +
	"\vfence_token\x18\x05 \x01(\x04R\n" +
	"fenceToken\x12(\n" +
	"\x10lease_expires_at\x18\x06 \x01(\x03R\x0eleaseExpiresAt\x12\x1f\n" +
	"\vacquired_at\x18\a \x01(\x03R\n" +
	"acquiredAt\x12\x1d\n" +
	"\n" +
	"request_id\x18\b \x01(\tR\trequestId\x12%\n" +
	"\x0erequester_info\x18\t \x01(\tR\rrequesterInfo\x123\n" +
	"\x15requester_application\x18\n" +
	" \x01(\tR\x14requesterApplication\"c\n" +
	"\x19ListAcquiredLocksResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12,\n" +
	"\x05locks\x18\x02 \x03(\v2\x16.waymaker.AcquiredLockR\x05locks*_\n" +
	"\rLockEventType\x12\v\n" +
	"\aUnknown\x10\x00\x12\v\n" +
	"\aWaiting\x10\x01\x12\f\n" +
	"\bAcquired\x10\x02\x12\n" +
	"\n" +
	"\x06Failed\x10\x03\x12\v\n" +
	"\aExpired\x10\x04\x12\r\n" +
	"\tHeartbeat\x10\x05*W\n" +
	"\n" +
	"FenceScope\x12\x14\n" +
	"\x10ScopeUnspecified\x10\x00\x12\x12\n" +
	"\x0eScopeEphemeral\x10\x01\x12\x0e\n" +
	"\n" +
	"ScopeLocal\x10\x02\x12\x0f\n" +
	"\vScopeQuorum\x10\x032\x88\x04\n" +
	"\x0fWaymakerService\x126\n" +
	"\x04Lock\x12\x15.waymaker.LockRequest\x1a\x13.waymaker.LockEvent\"\x000\x01\x12:\n" +
	"\bReadLock\x12\x15.waymaker.LockRequest\x1a\x13.waymaker.LockEvent\"\x000\x01\x12=\n" +
	"\x06UnLock\x12\x17.waymaker.UnLockRequest\x1a\x18.waymaker.UnLockResponse\"\x00\x12L\n" +
	"\vLeaseStatus\x12\x1c.waymaker.LeaseStatusRequest\x1a\x1d.waymaker.LeaseStatusResponse\"\x00\x12L\n" +
	"\vExtendLease\x12\x1c.waymaker.ExtendLeaseRequest\x1a\x1d.waymaker.ExtendLeaseResponse\"\x00\x12F\n" +
	"\tMultiLock\x12\x1a.waymaker.MultiLockRequest\x1a\x1b.waymaker.MultiLockResponse\"\x00\x12^\n" +
	"\x11ListAcquiredLocks\x12\".waymaker.ListAcquiredLocksRequest\x1a#.waymaker.ListAcquiredLocksResponse\"\x00B\x10Z\x0e/apis/waymakerb\x06proto3"

var (
	file_waymaker_locks_proto_rawDescOnce sync.Once
	file_waymaker_locks_proto_rawDescData []byte
)

func file_waymaker_locks_proto_rawDescGZIP() []byte {
	file_waymaker_locks_proto_rawDescOnce.Do(func() {
		file_waymaker_locks_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_waymaker_locks_proto_rawDesc), len(file_waymaker_locks_proto_rawDesc)))
	})
	return file_waymaker_locks_proto_rawDescData
}

var file_waymaker_locks_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_waymaker_locks_proto_msgTypes = make([]protoimpl.MessageInfo, 15)
var file_waymaker_locks_proto_goTypes = []any{
	(LockEventType)(0),                // 0: waymaker.LockEventType
	(FenceScope)(0),                   // 1: waymaker.FenceScope
	(*LockRequest)(nil),               // 2: waymaker.LockRequest
	(*LockEvent)(nil),                 // 3: waymaker.LockEvent
	(*UnLockRequest)(nil),             // 4: waymaker.UnLockRequest
	(*UnLockResponse)(nil),            // 5: waymaker.UnLockResponse
	(*Lease)(nil),                     // 6: waymaker.Lease
	(*ExtendLeaseRequest)(nil),        // 7: waymaker.ExtendLeaseRequest
	(*ExtendLeaseResponse)(nil),       // 8: waymaker.ExtendLeaseResponse
	(*LeaseStatusRequest)(nil),        // 9: waymaker.LeaseStatusRequest
	(*LeaseStatusResponse)(nil),       // 10: waymaker.LeaseStatusResponse
	(*MultiLockKey)(nil),              // 11: waymaker.MultiLockKey
	(*MultiLockRequest)(nil),          // 12: waymaker.MultiLockRequest
	(*MultiLockResponse)(nil),         // 13: waymaker.MultiLockResponse
	(*ListAcquiredLocksRequest)(nil),  // 14: waymaker.ListAcquiredLocksRequest
	(*AcquiredLock)(nil),              // 15: waymaker.AcquiredLock
	(*ListAcquiredLocksResponse)(nil), // 16: waymaker.ListAcquiredLocksResponse
}
var file_waymaker_locks_proto_depIdxs = []int32{
	1,  // 0: waymaker.LockRequest.fence_scope:type_name -> waymaker.FenceScope
	0,  // 1: waymaker.LockEvent.event_type:type_name -> waymaker.LockEventType
	6,  // 2: waymaker.ExtendLeaseResponse.lease:type_name -> waymaker.Lease
	6,  // 3: waymaker.LeaseStatusResponse.lease:type_name -> waymaker.Lease
	11, // 4: waymaker.MultiLockRequest.keys:type_name -> waymaker.MultiLockKey
	1,  // 5: waymaker.MultiLockRequest.fence_scope:type_name -> waymaker.FenceScope
	6,  // 6: waymaker.MultiLockResponse.leases:type_name -> waymaker.Lease
	15, // 7: waymaker.ListAcquiredLocksResponse.locks:type_name -> waymaker.AcquiredLock
	2,  // 8: waymaker.WaymakerService.Lock:input_type -> waymaker.LockRequest
	2,  // 9: waymaker.WaymakerService.ReadLock:input_type -> waymaker.LockRequest
	4,  // 10: waymaker.WaymakerService.UnLock:input_type -> waymaker.UnLockRequest
	9,  // 11: waymaker.WaymakerService.LeaseStatus:input_type -> waymaker.LeaseStatusRequest
	7,  // 12: waymaker.WaymakerService.ExtendLease:input_type -> waymaker.ExtendLeaseRequest
	12, // 13: waymaker.WaymakerService.MultiLock:input_type -> waymaker.MultiLockRequest
	14, // 14: waymaker.WaymakerService.ListAcquiredLocks:input_type -> waymaker.ListAcquiredLocksRequest
	3,  // 15: waymaker.WaymakerService.Lock:output_type -> waymaker.LockEvent
	3,  // 16: waymaker.WaymakerService.ReadLock:output_type -> waymaker.LockEvent
	5,  // 17: waymaker.WaymakerService.UnLock:output_type -> waymaker.UnLockResponse
	10, // 18: waymaker.WaymakerService.LeaseStatus:output_type -> waymaker.LeaseStatusResponse
	8,  // 19: waymaker.WaymakerService.ExtendLease:output_type -> waymaker.ExtendLeaseResponse
	13, // 20: waymaker.WaymakerService.MultiLock:output_type -> waymaker.MultiLockResponse
	16, // 21: waymaker.WaymakerService.ListAcquiredLocks:output_type -> waymaker.ListAcquiredLocksResponse
	15, // [15:22] is the sub-list for method output_type
	8,  // [8:15] is the sub-list for method input_type
	8,  // [8:8] is the sub-list for extension type_name
	8,  // [8:8] is the sub-list for extension extendee
	0,  // [0:8] is the sub-list for field type_name
}

func init() { file_waymaker_locks_proto_init() }
func file_waymaker_locks_proto_init() {
	if File_waymaker_locks_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_waymaker_locks_proto_rawDesc), len(file_waymaker_locks_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   15,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_waymaker_locks_proto_goTypes,
		DependencyIndexes: file_waymaker_locks_proto_depIdxs,
		EnumInfos:         file_waymaker_locks_proto_enumTypes,
		MessageInfos:      file_waymaker_locks_proto_msgTypes,
	}.Build()
	File_waymaker_locks_proto = out.File
	file_waymaker_locks_proto_goTypes = nil
	file_waymaker_locks_proto_depIdxs = nil
}