// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v3.21.12
// source: primitives.proto

package clngrpc

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 ChannelSide int32

const (
	ChannelSide_LOCAL  ChannelSide = 0
	ChannelSide_REMOTE ChannelSide = 1
)

// Enum value maps for ChannelSide.
var (
	ChannelSide_name = map[int32]string{
		0: "LOCAL",
		1: "REMOTE",
	}
	ChannelSide_value = map[string]int32{
		"LOCAL":  0,
		"REMOTE": 1,
	}
)

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

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

func (ChannelSide) Descriptor() protoreflect.EnumDescriptor {
	return file_primitives_proto_enumTypes[0].Descriptor()
}

func (ChannelSide) Type() protoreflect.EnumType {
	return &file_primitives_proto_enumTypes[0]
}

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

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

type ChannelState int32

const (
	ChannelState_Openingd                  ChannelState = 0
	ChannelState_ChanneldAwaitingLockin    ChannelState = 1
	ChannelState_ChanneldNormal            ChannelState = 2
	ChannelState_ChanneldShuttingDown      ChannelState = 3
	ChannelState_ClosingdSigexchange       ChannelState = 4
	ChannelState_ClosingdComplete          ChannelState = 5
	ChannelState_AwaitingUnilateral        ChannelState = 6
	ChannelState_FundingSpendSeen          ChannelState = 7
	ChannelState_Onchain                   ChannelState = 8
	ChannelState_DualopendOpenInit         ChannelState = 9
	ChannelState_DualopendAwaitingLockin   ChannelState = 10
	ChannelState_ChanneldAwaitingSplice    ChannelState = 11
	ChannelState_DualopendOpenCommitted    ChannelState = 12
	ChannelState_DualopendOpenCommittReady ChannelState = 13
	ChannelState_Closed                    ChannelState = 14
)

// Enum value maps for ChannelState.
var (
	ChannelState_name = map[int32]string{
		0:  "Openingd",
		1:  "ChanneldAwaitingLockin",
		2:  "ChanneldNormal",
		3:  "ChanneldShuttingDown",
		4:  "ClosingdSigexchange",
		5:  "ClosingdComplete",
		6:  "AwaitingUnilateral",
		7:  "FundingSpendSeen",
		8:  "Onchain",
		9:  "DualopendOpenInit",
		10: "DualopendAwaitingLockin",
		11: "ChanneldAwaitingSplice",
		12: "DualopendOpenCommitted",
		13: "DualopendOpenCommittReady",
		14: "Closed",
	}
	ChannelState_value = map[string]int32{
		"Openingd":                  0,
		"ChanneldAwaitingLockin":    1,
		"ChanneldNormal":            2,
		"ChanneldShuttingDown":      3,
		"ClosingdSigexchange":       4,
		"ClosingdComplete":          5,
		"AwaitingUnilateral":        6,
		"FundingSpendSeen":          7,
		"Onchain":                   8,
		"DualopendOpenInit":         9,
		"DualopendAwaitingLockin":   10,
		"ChanneldAwaitingSplice":    11,
		"DualopendOpenCommitted":    12,
		"DualopendOpenCommittReady": 13,
		"Closed":                    14,
	}
)

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

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

func (ChannelState) Descriptor() protoreflect.EnumDescriptor {
	return file_primitives_proto_enumTypes[1].Descriptor()
}

func (ChannelState) Type() protoreflect.EnumType {
	return &file_primitives_proto_enumTypes[1]
}

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

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

type HtlcState int32

const (
	HtlcState_SentAddHtlc             HtlcState = 0
	HtlcState_SentAddCommit           HtlcState = 1
	HtlcState_RcvdAddRevocation       HtlcState = 2
	HtlcState_RcvdAddAckCommit        HtlcState = 3
	HtlcState_SentAddAckRevocation    HtlcState = 4
	HtlcState_RcvdAddAckRevocation    HtlcState = 5
	HtlcState_RcvdRemoveHtlc          HtlcState = 6
	HtlcState_RcvdRemoveCommit        HtlcState = 7
	HtlcState_SentRemoveRevocation    HtlcState = 8
	HtlcState_SentRemoveAckCommit     HtlcState = 9
	HtlcState_RcvdRemoveAckRevocation HtlcState = 10
	HtlcState_RcvdAddHtlc             HtlcState = 11
	HtlcState_RcvdAddCommit           HtlcState = 12
	HtlcState_SentAddRevocation       HtlcState = 13
	HtlcState_SentAddAckCommit        HtlcState = 14
	HtlcState_SentRemoveHtlc          HtlcState = 15
	HtlcState_SentRemoveCommit        HtlcState = 16
	HtlcState_RcvdRemoveRevocation    HtlcState = 17
	HtlcState_RcvdRemoveAckCommit     HtlcState = 18
	HtlcState_SentRemoveAckRevocation HtlcState = 19
)

// Enum value maps for HtlcState.
var (
	HtlcState_name = map[int32]string{
		0:  "SentAddHtlc",
		1:  "SentAddCommit",
		2:  "RcvdAddRevocation",
		3:  "RcvdAddAckCommit",
		4:  "SentAddAckRevocation",
		5:  "RcvdAddAckRevocation",
		6:  "RcvdRemoveHtlc",
		7:  "RcvdRemoveCommit",
		8:  "SentRemoveRevocation",
		9:  "SentRemoveAckCommit",
		10: "RcvdRemoveAckRevocation",
		11: "RcvdAddHtlc",
		12: "RcvdAddCommit",
		13: "SentAddRevocation",
		14: "SentAddAckCommit",
		15: "SentRemoveHtlc",
		16: "SentRemoveCommit",
		17: "RcvdRemoveRevocation",
		18: "RcvdRemoveAckCommit",
		19: "SentRemoveAckRevocation",
	}
	HtlcState_value = map[string]int32{
		"SentAddHtlc":             0,
		"SentAddCommit":           1,
		"RcvdAddRevocation":       2,
		"RcvdAddAckCommit":        3,
		"SentAddAckRevocation":    4,
		"RcvdAddAckRevocation":    5,
		"RcvdRemoveHtlc":          6,
		"RcvdRemoveCommit":        7,
		"SentRemoveRevocation":    8,
		"SentRemoveAckCommit":     9,
		"RcvdRemoveAckRevocation": 10,
		"RcvdAddHtlc":             11,
		"RcvdAddCommit":           12,
		"SentAddRevocation":       13,
		"SentAddAckCommit":        14,
		"SentRemoveHtlc":          15,
		"SentRemoveCommit":        16,
		"RcvdRemoveRevocation":    17,
		"RcvdRemoveAckCommit":     18,
		"SentRemoveAckRevocation": 19,
	}
)

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

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

func (HtlcState) Descriptor() protoreflect.EnumDescriptor {
	return file_primitives_proto_enumTypes[2].Descriptor()
}

func (HtlcState) Type() protoreflect.EnumType {
	return &file_primitives_proto_enumTypes[2]
}

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

// Deprecated: Use HtlcState.Descriptor instead.
func (HtlcState) EnumDescriptor() ([]byte, []int) {
	return file_primitives_proto_rawDescGZIP(), []int{2}
}

type ChannelTypeName int32

const (
	ChannelTypeName_static_remotekey_even         ChannelTypeName = 0
	ChannelTypeName_anchor_outputs_even           ChannelTypeName = 1
	ChannelTypeName_anchors_zero_fee_htlc_tx_even ChannelTypeName = 2
	ChannelTypeName_scid_alias_even               ChannelTypeName = 3
	ChannelTypeName_zeroconf_even                 ChannelTypeName = 4
	ChannelTypeName_anchors_even                  ChannelTypeName = 5
)

// Enum value maps for ChannelTypeName.
var (
	ChannelTypeName_name = map[int32]string{
		0: "static_remotekey_even",
		1: "anchor_outputs_even",
		2: "anchors_zero_fee_htlc_tx_even",
		3: "scid_alias_even",
		4: "zeroconf_even",
		5: "anchors_even",
	}
	ChannelTypeName_value = map[string]int32{
		"static_remotekey_even":         0,
		"anchor_outputs_even":           1,
		"anchors_zero_fee_htlc_tx_even": 2,
		"scid_alias_even":               3,
		"zeroconf_even":                 4,
		"anchors_even":                  5,
	}
)

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

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

func (ChannelTypeName) Descriptor() protoreflect.EnumDescriptor {
	return file_primitives_proto_enumTypes[3].Descriptor()
}

func (ChannelTypeName) Type() protoreflect.EnumType {
	return &file_primitives_proto_enumTypes[3]
}

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

// Deprecated: Use ChannelTypeName.Descriptor instead.
func (ChannelTypeName) EnumDescriptor() ([]byte, []int) {
	return file_primitives_proto_rawDescGZIP(), []int{3}
}

type AutocleanSubsystem int32

const (
	AutocleanSubsystem_SUCCEEDEDFORWARDS AutocleanSubsystem = 0
	AutocleanSubsystem_FAILEDFORWARDS    AutocleanSubsystem = 1
	AutocleanSubsystem_SUCCEEDEDPAYS     AutocleanSubsystem = 2
	AutocleanSubsystem_FAILEDPAYS        AutocleanSubsystem = 3
	AutocleanSubsystem_PAIDINVOICES      AutocleanSubsystem = 4
	AutocleanSubsystem_EXPIREDINVOICES   AutocleanSubsystem = 5
)

// Enum value maps for AutocleanSubsystem.
var (
	AutocleanSubsystem_name = map[int32]string{
		0: "SUCCEEDEDFORWARDS",
		1: "FAILEDFORWARDS",
		2: "SUCCEEDEDPAYS",
		3: "FAILEDPAYS",
		4: "PAIDINVOICES",
		5: "EXPIREDINVOICES",
	}
	AutocleanSubsystem_value = map[string]int32{
		"SUCCEEDEDFORWARDS": 0,
		"FAILEDFORWARDS":    1,
		"SUCCEEDEDPAYS":     2,
		"FAILEDPAYS":        3,
		"PAIDINVOICES":      4,
		"EXPIREDINVOICES":   5,
	}
)

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

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

func (AutocleanSubsystem) Descriptor() protoreflect.EnumDescriptor {
	return file_primitives_proto_enumTypes[4].Descriptor()
}

func (AutocleanSubsystem) Type() protoreflect.EnumType {
	return &file_primitives_proto_enumTypes[4]
}

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

// Deprecated: Use AutocleanSubsystem.Descriptor instead.
func (AutocleanSubsystem) EnumDescriptor() ([]byte, []int) {
	return file_primitives_proto_rawDescGZIP(), []int{4}
}

type PluginSubcommand int32

const (
	PluginSubcommand_START    PluginSubcommand = 0
	PluginSubcommand_STOP     PluginSubcommand = 1
	PluginSubcommand_RESCAN   PluginSubcommand = 2
	PluginSubcommand_STARTDIR PluginSubcommand = 3
	PluginSubcommand_LIST     PluginSubcommand = 4
)

// Enum value maps for PluginSubcommand.
var (
	PluginSubcommand_name = map[int32]string{
		0: "START",
		1: "STOP",
		2: "RESCAN",
		3: "STARTDIR",
		4: "LIST",
	}
	PluginSubcommand_value = map[string]int32{
		"START":    0,
		"STOP":     1,
		"RESCAN":   2,
		"STARTDIR": 3,
		"LIST":     4,
	}
)

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

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

func (PluginSubcommand) Descriptor() protoreflect.EnumDescriptor {
	return file_primitives_proto_enumTypes[5].Descriptor()
}

func (PluginSubcommand) Type() protoreflect.EnumType {
	return &file_primitives_proto_enumTypes[5]
}

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

// Deprecated: Use PluginSubcommand.Descriptor instead.
func (PluginSubcommand) EnumDescriptor() ([]byte, []int) {
	return file_primitives_proto_rawDescGZIP(), []int{5}
}

type Amount struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Msat          uint64                 `protobuf:"varint,1,opt,name=msat,proto3" json:"msat,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Amount) ProtoMessage() {}

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

func (x *Amount) GetMsat() uint64 {
	if x != nil {
		return x.Msat
	}
	return 0
}

type AmountOrAll struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Value:
	//
	//	*AmountOrAll_Amount
	//	*AmountOrAll_All
	Value         isAmountOrAll_Value `protobuf_oneof:"value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AmountOrAll) ProtoMessage() {}

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

func (x *AmountOrAll) GetValue() isAmountOrAll_Value {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *AmountOrAll) GetAmount() *Amount {
	if x != nil {
		if x, ok := x.Value.(*AmountOrAll_Amount); ok {
			return x.Amount
		}
	}
	return nil
}

func (x *AmountOrAll) GetAll() bool {
	if x != nil {
		if x, ok := x.Value.(*AmountOrAll_All); ok {
			return x.All
		}
	}
	return false
}

type isAmountOrAll_Value interface {
	isAmountOrAll_Value()
}

type AmountOrAll_Amount struct {
	Amount *Amount `protobuf:"bytes,1,opt,name=amount,proto3,oneof"`
}

type AmountOrAll_All struct {
	All bool `protobuf:"varint,2,opt,name=all,proto3,oneof"`
}

func (*AmountOrAll_Amount) isAmountOrAll_Value() {}

func (*AmountOrAll_All) isAmountOrAll_Value() {}

type AmountOrAny struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Value:
	//
	//	*AmountOrAny_Amount
	//	*AmountOrAny_Any
	Value         isAmountOrAny_Value `protobuf_oneof:"value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AmountOrAny) ProtoMessage() {}

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

func (x *AmountOrAny) GetValue() isAmountOrAny_Value {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *AmountOrAny) GetAmount() *Amount {
	if x != nil {
		if x, ok := x.Value.(*AmountOrAny_Amount); ok {
			return x.Amount
		}
	}
	return nil
}

func (x *AmountOrAny) GetAny() bool {
	if x != nil {
		if x, ok := x.Value.(*AmountOrAny_Any); ok {
			return x.Any
		}
	}
	return false
}

type isAmountOrAny_Value interface {
	isAmountOrAny_Value()
}

type AmountOrAny_Amount struct {
	Amount *Amount `protobuf:"bytes,1,opt,name=amount,proto3,oneof"`
}

type AmountOrAny_Any struct {
	Any bool `protobuf:"varint,2,opt,name=any,proto3,oneof"`
}

func (*AmountOrAny_Amount) isAmountOrAny_Value() {}

func (*AmountOrAny_Any) isAmountOrAny_Value() {}

type Outpoint struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Txid          []byte                 `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"`
	Outnum        uint32                 `protobuf:"varint,2,opt,name=outnum,proto3" json:"outnum,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Outpoint) ProtoMessage() {}

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

func (x *Outpoint) GetTxid() []byte {
	if x != nil {
		return x.Txid
	}
	return nil
}

func (x *Outpoint) GetOutnum() uint32 {
	if x != nil {
		return x.Outnum
	}
	return 0
}

type Feerate struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Style:
	//
	//	*Feerate_Slow
	//	*Feerate_Normal
	//	*Feerate_Urgent
	//	*Feerate_Perkb
	//	*Feerate_Perkw
	Style         isFeerate_Style `protobuf_oneof:"style"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Feerate) ProtoMessage() {}

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

func (x *Feerate) GetStyle() isFeerate_Style {
	if x != nil {
		return x.Style
	}
	return nil
}

func (x *Feerate) GetSlow() bool {
	if x != nil {
		if x, ok := x.Style.(*Feerate_Slow); ok {
			return x.Slow
		}
	}
	return false
}

func (x *Feerate) GetNormal() bool {
	if x != nil {
		if x, ok := x.Style.(*Feerate_Normal); ok {
			return x.Normal
		}
	}
	return false
}

func (x *Feerate) GetUrgent() bool {
	if x != nil {
		if x, ok := x.Style.(*Feerate_Urgent); ok {
			return x.Urgent
		}
	}
	return false
}

func (x *Feerate) GetPerkb() uint32 {
	if x != nil {
		if x, ok := x.Style.(*Feerate_Perkb); ok {
			return x.Perkb
		}
	}
	return 0
}

func (x *Feerate) GetPerkw() uint32 {
	if x != nil {
		if x, ok := x.Style.(*Feerate_Perkw); ok {
			return x.Perkw
		}
	}
	return 0
}

type isFeerate_Style interface {
	isFeerate_Style()
}

type Feerate_Slow struct {
	Slow bool `protobuf:"varint,1,opt,name=slow,proto3,oneof"`
}

type Feerate_Normal struct {
	Normal bool `protobuf:"varint,2,opt,name=normal,proto3,oneof"`
}

type Feerate_Urgent struct {
	Urgent bool `protobuf:"varint,3,opt,name=urgent,proto3,oneof"`
}

type Feerate_Perkb struct {
	Perkb uint32 `protobuf:"varint,4,opt,name=perkb,proto3,oneof"`
}

type Feerate_Perkw struct {
	Perkw uint32 `protobuf:"varint,5,opt,name=perkw,proto3,oneof"`
}

func (*Feerate_Slow) isFeerate_Style() {}

func (*Feerate_Normal) isFeerate_Style() {}

func (*Feerate_Urgent) isFeerate_Style() {}

func (*Feerate_Perkb) isFeerate_Style() {}

func (*Feerate_Perkw) isFeerate_Style() {}

type OutputDesc struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Address       string                 `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	Amount        *Amount                `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*OutputDesc) ProtoMessage() {}

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

func (x *OutputDesc) GetAddress() string {
	if x != nil {
		return x.Address
	}
	return ""
}

func (x *OutputDesc) GetAmount() *Amount {
	if x != nil {
		return x.Amount
	}
	return nil
}

type RouteHop struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            []byte                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Scid          string                 `protobuf:"bytes,2,opt,name=scid,proto3" json:"scid,omitempty"`
	Feebase       *Amount                `protobuf:"bytes,3,opt,name=feebase,proto3" json:"feebase,omitempty"`
	Feeprop       uint32                 `protobuf:"varint,4,opt,name=feeprop,proto3" json:"feeprop,omitempty"`
	Expirydelta   uint32                 `protobuf:"varint,5,opt,name=expirydelta,proto3" json:"expirydelta,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RouteHop) ProtoMessage() {}

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

func (x *RouteHop) GetId() []byte {
	if x != nil {
		return x.Id
	}
	return nil
}

func (x *RouteHop) GetScid() string {
	if x != nil {
		return x.Scid
	}
	return ""
}

func (x *RouteHop) GetFeebase() *Amount {
	if x != nil {
		return x.Feebase
	}
	return nil
}

func (x *RouteHop) GetFeeprop() uint32 {
	if x != nil {
		return x.Feeprop
	}
	return 0
}

func (x *RouteHop) GetExpirydelta() uint32 {
	if x != nil {
		return x.Expirydelta
	}
	return 0
}

type Routehint struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Hops          []*RouteHop            `protobuf:"bytes,1,rep,name=hops,proto3" json:"hops,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Routehint) ProtoMessage() {}

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

func (x *Routehint) GetHops() []*RouteHop {
	if x != nil {
		return x.Hops
	}
	return nil
}

type RoutehintList struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Hints         []*Routehint           `protobuf:"bytes,2,rep,name=hints,proto3" json:"hints,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RoutehintList) ProtoMessage() {}

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

func (x *RoutehintList) GetHints() []*Routehint {
	if x != nil {
		return x.Hints
	}
	return nil
}

type DecodeRouteHop struct {
	state                     protoimpl.MessageState `protogen:"open.v1"`
	Pubkey                    []byte                 `protobuf:"bytes,1,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
	ShortChannelId            string                 `protobuf:"bytes,2,opt,name=short_channel_id,json=shortChannelId,proto3" json:"short_channel_id,omitempty"`
	FeeBaseMsat               *Amount                `protobuf:"bytes,3,opt,name=fee_base_msat,json=feeBaseMsat,proto3" json:"fee_base_msat,omitempty"`
	FeeProportionalMillionths uint32                 `protobuf:"varint,4,opt,name=fee_proportional_millionths,json=feeProportionalMillionths,proto3" json:"fee_proportional_millionths,omitempty"`
	CltvExpiryDelta           uint32                 `protobuf:"varint,5,opt,name=cltv_expiry_delta,json=cltvExpiryDelta,proto3" json:"cltv_expiry_delta,omitempty"`
	unknownFields             protoimpl.UnknownFields
	sizeCache                 protoimpl.SizeCache
}

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

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

func (*DecodeRouteHop) ProtoMessage() {}

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

func (x *DecodeRouteHop) GetPubkey() []byte {
	if x != nil {
		return x.Pubkey
	}
	return nil
}

func (x *DecodeRouteHop) GetShortChannelId() string {
	if x != nil {
		return x.ShortChannelId
	}
	return ""
}

func (x *DecodeRouteHop) GetFeeBaseMsat() *Amount {
	if x != nil {
		return x.FeeBaseMsat
	}
	return nil
}

func (x *DecodeRouteHop) GetFeeProportionalMillionths() uint32 {
	if x != nil {
		return x.FeeProportionalMillionths
	}
	return 0
}

func (x *DecodeRouteHop) GetCltvExpiryDelta() uint32 {
	if x != nil {
		return x.CltvExpiryDelta
	}
	return 0
}

type DecodeRoutehint struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Hops          []*DecodeRouteHop      `protobuf:"bytes,1,rep,name=hops,proto3" json:"hops,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DecodeRoutehint) ProtoMessage() {}

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

func (x *DecodeRoutehint) GetHops() []*DecodeRouteHop {
	if x != nil {
		return x.Hops
	}
	return nil
}

type DecodeRoutehintList struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Hints         []*DecodeRoutehint     `protobuf:"bytes,2,rep,name=hints,proto3" json:"hints,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DecodeRoutehintList) ProtoMessage() {}

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

func (x *DecodeRoutehintList) GetHints() []*DecodeRoutehint {
	if x != nil {
		return x.Hints
	}
	return nil
}

type TlvEntry struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Type          uint64                 `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"`
	Value         []byte                 `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TlvEntry) ProtoMessage() {}

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

func (x *TlvEntry) GetType() uint64 {
	if x != nil {
		return x.Type
	}
	return 0
}

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

type TlvStream struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Entries       []*TlvEntry            `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TlvStream) ProtoMessage() {}

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

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

type JsonObjectOrArray struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Structure:
	//
	//	*JsonObjectOrArray_Object
	//	*JsonObjectOrArray_Array
	Structure     isJsonObjectOrArray_Structure `protobuf_oneof:"structure"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*JsonObjectOrArray) ProtoMessage() {}

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

func (x *JsonObjectOrArray) GetStructure() isJsonObjectOrArray_Structure {
	if x != nil {
		return x.Structure
	}
	return nil
}

func (x *JsonObjectOrArray) GetObject() *JsonObject {
	if x != nil {
		if x, ok := x.Structure.(*JsonObjectOrArray_Object); ok {
			return x.Object
		}
	}
	return nil
}

func (x *JsonObjectOrArray) GetArray() *JsonArray {
	if x != nil {
		if x, ok := x.Structure.(*JsonObjectOrArray_Array); ok {
			return x.Array
		}
	}
	return nil
}

type isJsonObjectOrArray_Structure interface {
	isJsonObjectOrArray_Structure()
}

type JsonObjectOrArray_Object struct {
	Object *JsonObject `protobuf:"bytes,1,opt,name=object,proto3,oneof"`
}

type JsonObjectOrArray_Array struct {
	Array *JsonArray `protobuf:"bytes,2,opt,name=array,proto3,oneof"`
}

func (*JsonObjectOrArray_Object) isJsonObjectOrArray_Structure() {}

func (*JsonObjectOrArray_Array) isJsonObjectOrArray_Structure() {}

type JsonObject struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Fields        map[string]*JsonValue  `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*JsonObject) ProtoMessage() {}

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

func (x *JsonObject) GetFields() map[string]*JsonValue {
	if x != nil {
		return x.Fields
	}
	return nil
}

type JsonArray struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Values        []*JsonValue           `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*JsonArray) ProtoMessage() {}

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

func (x *JsonArray) GetValues() []*JsonValue {
	if x != nil {
		return x.Values
	}
	return nil
}

type JsonValue struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Kind:
	//
	//	*JsonValue_BoolValue
	//	*JsonValue_IntValue
	//	*JsonValue_UintValue
	//	*JsonValue_DoubleValue
	//	*JsonValue_StringValue
	//	*JsonValue_Array
	//	*JsonValue_Object
	Kind          isJsonValue_Kind `protobuf_oneof:"kind"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*JsonValue) ProtoMessage() {}

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

func (x *JsonValue) GetKind() isJsonValue_Kind {
	if x != nil {
		return x.Kind
	}
	return nil
}

func (x *JsonValue) GetBoolValue() bool {
	if x != nil {
		if x, ok := x.Kind.(*JsonValue_BoolValue); ok {
			return x.BoolValue
		}
	}
	return false
}

func (x *JsonValue) GetIntValue() int64 {
	if x != nil {
		if x, ok := x.Kind.(*JsonValue_IntValue); ok {
			return x.IntValue
		}
	}
	return 0
}

func (x *JsonValue) GetUintValue() uint64 {
	if x != nil {
		if x, ok := x.Kind.(*JsonValue_UintValue); ok {
			return x.UintValue
		}
	}
	return 0
}

func (x *JsonValue) GetDoubleValue() float64 {
	if x != nil {
		if x, ok := x.Kind.(*JsonValue_DoubleValue); ok {
			return x.DoubleValue
		}
	}
	return 0
}

func (x *JsonValue) GetStringValue() string {
	if x != nil {
		if x, ok := x.Kind.(*JsonValue_StringValue); ok {
			return x.StringValue
		}
	}
	return ""
}

func (x *JsonValue) GetArray() *JsonArray {
	if x != nil {
		if x, ok := x.Kind.(*JsonValue_Array); ok {
			return x.Array
		}
	}
	return nil
}

func (x *JsonValue) GetObject() *JsonObject {
	if x != nil {
		if x, ok := x.Kind.(*JsonValue_Object); ok {
			return x.Object
		}
	}
	return nil
}

type isJsonValue_Kind interface {
	isJsonValue_Kind()
}

type JsonValue_BoolValue struct {
	BoolValue bool `protobuf:"varint,1,opt,name=bool_value,json=boolValue,proto3,oneof"`
}

type JsonValue_IntValue struct {
	IntValue int64 `protobuf:"varint,2,opt,name=int_value,json=intValue,proto3,oneof"`
}

type JsonValue_UintValue struct {
	UintValue uint64 `protobuf:"varint,3,opt,name=uint_value,json=uintValue,proto3,oneof"`
}

type JsonValue_DoubleValue struct {
	DoubleValue float64 `protobuf:"fixed64,4,opt,name=double_value,json=doubleValue,proto3,oneof"`
}

type JsonValue_StringValue struct {
	StringValue string `protobuf:"bytes,5,opt,name=string_value,json=stringValue,proto3,oneof"`
}

type JsonValue_Array struct {
	Array *JsonArray `protobuf:"bytes,6,opt,name=array,proto3,oneof"`
}

type JsonValue_Object struct {
	Object *JsonObject `protobuf:"bytes,7,opt,name=object,proto3,oneof"`
}

func (*JsonValue_BoolValue) isJsonValue_Kind() {}

func (*JsonValue_IntValue) isJsonValue_Kind() {}

func (*JsonValue_UintValue) isJsonValue_Kind() {}

func (*JsonValue_DoubleValue) isJsonValue_Kind() {}

func (*JsonValue_StringValue) isJsonValue_Kind() {}

func (*JsonValue_Array) isJsonValue_Kind() {}

func (*JsonValue_Object) isJsonValue_Kind() {}

type JsonScalar struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Scalar:
	//
	//	*JsonScalar_BoolValue
	//	*JsonScalar_IntValue
	//	*JsonScalar_UintValue
	//	*JsonScalar_DoubleValue
	//	*JsonScalar_StringValue
	Scalar        isJsonScalar_Scalar `protobuf_oneof:"scalar"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*JsonScalar) ProtoMessage() {}

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

func (x *JsonScalar) GetScalar() isJsonScalar_Scalar {
	if x != nil {
		return x.Scalar
	}
	return nil
}

func (x *JsonScalar) GetBoolValue() bool {
	if x != nil {
		if x, ok := x.Scalar.(*JsonScalar_BoolValue); ok {
			return x.BoolValue
		}
	}
	return false
}

func (x *JsonScalar) GetIntValue() int64 {
	if x != nil {
		if x, ok := x.Scalar.(*JsonScalar_IntValue); ok {
			return x.IntValue
		}
	}
	return 0
}

func (x *JsonScalar) GetUintValue() uint64 {
	if x != nil {
		if x, ok := x.Scalar.(*JsonScalar_UintValue); ok {
			return x.UintValue
		}
	}
	return 0
}

func (x *JsonScalar) GetDoubleValue() float64 {
	if x != nil {
		if x, ok := x.Scalar.(*JsonScalar_DoubleValue); ok {
			return x.DoubleValue
		}
	}
	return 0
}

func (x *JsonScalar) GetStringValue() string {
	if x != nil {
		if x, ok := x.Scalar.(*JsonScalar_StringValue); ok {
			return x.StringValue
		}
	}
	return ""
}

type isJsonScalar_Scalar interface {
	isJsonScalar_Scalar()
}

type JsonScalar_BoolValue struct {
	BoolValue bool `protobuf:"varint,1,opt,name=bool_value,json=boolValue,proto3,oneof"`
}

type JsonScalar_IntValue struct {
	IntValue int64 `protobuf:"varint,2,opt,name=int_value,json=intValue,proto3,oneof"`
}

type JsonScalar_UintValue struct {
	UintValue uint64 `protobuf:"varint,3,opt,name=uint_value,json=uintValue,proto3,oneof"`
}

type JsonScalar_DoubleValue struct {
	DoubleValue float64 `protobuf:"fixed64,4,opt,name=double_value,json=doubleValue,proto3,oneof"`
}

type JsonScalar_StringValue struct {
	StringValue string `protobuf:"bytes,5,opt,name=string_value,json=stringValue,proto3,oneof"`
}

func (*JsonScalar_BoolValue) isJsonScalar_Scalar() {}

func (*JsonScalar_IntValue) isJsonScalar_Scalar() {}

func (*JsonScalar_UintValue) isJsonScalar_Scalar() {}

func (*JsonScalar_DoubleValue) isJsonScalar_Scalar() {}

func (*JsonScalar_StringValue) isJsonScalar_Scalar() {}

var File_primitives_proto protoreflect.FileDescriptor

const file_primitives_proto_rawDesc = "" +
	"\n" +
	"\x10primitives.proto\x12\x03cln\"\x1c\n" +
	"\x06Amount\x12\x12\n" +
	"\x04msat\x18\x01 \x01(\x04R\x04msat\"Q\n" +
	"\vAmountOrAll\x12%\n" +
	"\x06amount\x18\x01 \x01(\v2\v.cln.AmountH\x00R\x06amount\x12\x12\n" +
	"\x03all\x18\x02 \x01(\bH\x00R\x03allB\a\n" +
	"\x05value\"Q\n" +
	"\vAmountOrAny\x12%\n" +
	"\x06amount\x18\x01 \x01(\v2\v.cln.AmountH\x00R\x06amount\x12\x12\n" +
	"\x03any\x18\x02 \x01(\bH\x00R\x03anyB\a\n" +
	"\x05value\"6\n" +
	"\bOutpoint\x12\x12\n" +
	"\x04txid\x18\x01 \x01(\fR\x04txid\x12\x16\n" +
	"\x06outnum\x18\x02 \x01(\rR\x06outnum\"\x8c\x01\n" +
	"\aFeerate\x12\x14\n" +
	"\x04slow\x18\x01 \x01(\bH\x00R\x04slow\x12\x18\n" +
	"\x06normal\x18\x02 \x01(\bH\x00R\x06normal\x12\x18\n" +
	"\x06urgent\x18\x03 \x01(\bH\x00R\x06urgent\x12\x16\n" +
	"\x05perkb\x18\x04 \x01(\rH\x00R\x05perkb\x12\x16\n" +
	"\x05perkw\x18\x05 \x01(\rH\x00R\x05perkwB\a\n" +
	"\x05style\"K\n" +
	"\n" +
	"OutputDesc\x12\x18\n" +
	"\aaddress\x18\x01 \x01(\tR\aaddress\x12#\n" +
	"\x06amount\x18\x02 \x01(\v2\v.cln.AmountR\x06amount\"\x91\x01\n" +
	"\bRouteHop\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\fR\x02id\x12\x12\n" +
	"\x04scid\x18\x02 \x01(\tR\x04scid\x12%\n" +
	"\afeebase\x18\x03 \x01(\v2\v.cln.AmountR\afeebase\x12\x18\n" +
	"\afeeprop\x18\x04 \x01(\rR\afeeprop\x12 \n" +
	"\vexpirydelta\x18\x05 \x01(\rR\vexpirydelta\".\n" +
	"\tRoutehint\x12!\n" +
	"\x04hops\x18\x01 \x03(\v2\r.cln.RouteHopR\x04hops\"5\n" +
	"\rRoutehintList\x12$\n" +
	"\x05hints\x18\x02 \x03(\v2\x0e.cln.RoutehintR\x05hints\"\xef\x01\n" +
	"\x0eDecodeRouteHop\x12\x16\n" +
	"\x06pubkey\x18\x01 \x01(\fR\x06pubkey\x12(\n" +
	"\x10short_channel_id\x18\x02 \x01(\tR\x0eshortChannelId\x12/\n" +
	"\rfee_base_msat\x18\x03 \x01(\v2\v.cln.AmountR\vfeeBaseMsat\x12>\n" +
	"\x1bfee_proportional_millionths\x18\x04 \x01(\rR\x19feeProportionalMillionths\x12*\n" +
	"\x11cltv_expiry_delta\x18\x05 \x01(\rR\x0fcltvExpiryDelta\":\n" +
	"\x0fDecodeRoutehint\x12'\n" +
	"\x04hops\x18\x01 \x03(\v2\x13.cln.DecodeRouteHopR\x04hops\"A\n" +
	"\x13DecodeRoutehintList\x12*\n" +
	"\x05hints\x18\x02 \x03(\v2\x14.cln.DecodeRoutehintR\x05hints\"4\n" +
	"\bTlvEntry\x12\x12\n" +
	"\x04type\x18\x01 \x01(\x04R\x04type\x12\x14\n" +
	"\x05value\x18\x02 \x01(\fR\x05value\"4\n" +
	"\tTlvStream\x12'\n" +
	"\aentries\x18\x01 \x03(\v2\r.cln.TlvEntryR\aentries\"s\n" +
	"\x11JsonObjectOrArray\x12)\n" +
	"\x06object\x18\x01 \x01(\v2\x0f.cln.JsonObjectH\x00R\x06object\x12&\n" +
	"\x05array\x18\x02 \x01(\v2\x0e.cln.JsonArrayH\x00R\x05arrayB\v\n" +
	"\tstructure\"\x8c\x01\n" +
	"\n" +
	"JsonObject\x123\n" +
	"\x06fields\x18\x01 \x03(\v2\x1b.cln.JsonObject.FieldsEntryR\x06fields\x1aI\n" +
	"\vFieldsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12$\n" +
	"\x05value\x18\x02 \x01(\v2\x0e.cln.JsonValueR\x05value:\x028\x01\"3\n" +
	"\tJsonArray\x12&\n" +
	"\x06values\x18\x01 \x03(\v2\x0e.cln.JsonValueR\x06values\"\x91\x02\n" +
	"\tJsonValue\x12\x1f\n" +
	"\n" +
	"bool_value\x18\x01 \x01(\bH\x00R\tboolValue\x12\x1d\n" +
	"\tint_value\x18\x02 \x01(\x03H\x00R\bintValue\x12\x1f\n" +
	"\n" +
	"uint_value\x18\x03 \x01(\x04H\x00R\tuintValue\x12#\n" +
	"\fdouble_value\x18\x04 \x01(\x01H\x00R\vdoubleValue\x12#\n" +
	"\fstring_value\x18\x05 \x01(\tH\x00R\vstringValue\x12&\n" +
	"\x05array\x18\x06 \x01(\v2\x0e.cln.JsonArrayH\x00R\x05array\x12)\n" +
	"\x06object\x18\a \x01(\v2\x0f.cln.JsonObjectH\x00R\x06objectB\x06\n" +
	"\x04kind\"\xc1\x01\n" +
	"\n" +
	"JsonScalar\x12\x1f\n" +
	"\n" +
	"bool_value\x18\x01 \x01(\bH\x00R\tboolValue\x12\x1d\n" +
	"\tint_value\x18\x02 \x01(\x03H\x00R\bintValue\x12\x1f\n" +
	"\n" +
	"uint_value\x18\x03 \x01(\x04H\x00R\tuintValue\x12#\n" +
	"\fdouble_value\x18\x04 \x01(\x01H\x00R\vdoubleValue\x12#\n" +
	"\fstring_value\x18\x05 \x01(\tH\x00R\vstringValueB\b\n" +
	"\x06scalar*$\n" +
	"\vChannelSide\x12\t\n" +
	"\x05LOCAL\x10\x00\x12\n" +
	"\n" +
	"\x06REMOTE\x10\x01*\xe7\x02\n" +
	"\fChannelState\x12\f\n" +
	"\bOpeningd\x10\x00\x12\x1a\n" +
	"\x16ChanneldAwaitingLockin\x10\x01\x12\x12\n" +
	"\x0eChanneldNormal\x10\x02\x12\x18\n" +
	"\x14ChanneldShuttingDown\x10\x03\x12\x17\n" +
	"\x13ClosingdSigexchange\x10\x04\x12\x14\n" +
	"\x10ClosingdComplete\x10\x05\x12\x16\n" +
	"\x12AwaitingUnilateral\x10\x06\x12\x14\n" +
	"\x10FundingSpendSeen\x10\a\x12\v\n" +
	"\aOnchain\x10\b\x12\x15\n" +
	"\x11DualopendOpenInit\x10\t\x12\x1b\n" +
	"\x17DualopendAwaitingLockin\x10\n" +
	"\x12\x1a\n" +
	"\x16ChanneldAwaitingSplice\x10\v\x12\x1a\n" +
	"\x16DualopendOpenCommitted\x10\f\x12\x1d\n" +
	"\x19DualopendOpenCommittReady\x10\r\x12\n" +
	"\n" +
	"\x06Closed\x10\x0e*\xd5\x03\n" +
	"\tHtlcState\x12\x0f\n" +
	"\vSentAddHtlc\x10\x00\x12\x11\n" +
	"\rSentAddCommit\x10\x01\x12\x15\n" +
	"\x11RcvdAddRevocation\x10\x02\x12\x14\n" +
	"\x10RcvdAddAckCommit\x10\x03\x12\x18\n" +
	"\x14SentAddAckRevocation\x10\x04\x12\x18\n" +
	"\x14RcvdAddAckRevocation\x10\x05\x12\x12\n" +
	"\x0eRcvdRemoveHtlc\x10\x06\x12\x14\n" +
	"\x10RcvdRemoveCommit\x10\a\x12\x18\n" +
	"\x14SentRemoveRevocation\x10\b\x12\x17\n" +
	"\x13SentRemoveAckCommit\x10\t\x12\x1b\n" +
	"\x17RcvdRemoveAckRevocation\x10\n" +
	"\x12\x0f\n" +
	"\vRcvdAddHtlc\x10\v\x12\x11\n" +
	"\rRcvdAddCommit\x10\f\x12\x15\n" +
	"\x11SentAddRevocation\x10\r\x12\x14\n" +
	"\x10SentAddAckCommit\x10\x0e\x12\x12\n" +
	"\x0eSentRemoveHtlc\x10\x0f\x12\x14\n" +
	"\x10SentRemoveCommit\x10\x10\x12\x18\n" +
	"\x14RcvdRemoveRevocation\x10\x11\x12\x17\n" +
	"\x13RcvdRemoveAckCommit\x10\x12\x12\x1b\n" +
	"\x17SentRemoveAckRevocation\x10\x13*\xa2\x01\n" +
	"\x0fChannelTypeName\x12\x19\n" +
	"\x15static_remotekey_even\x10\x00\x12\x17\n" +
	"\x13anchor_outputs_even\x10\x01\x12!\n" +
	"\x1danchors_zero_fee_htlc_tx_even\x10\x02\x12\x13\n" +
	"\x0fscid_alias_even\x10\x03\x12\x11\n" +
	"\rzeroconf_even\x10\x04\x12\x10\n" +
	"\fanchors_even\x10\x05*\x89\x01\n" +
	"\x12AutocleanSubsystem\x12\x15\n" +
	"\x11SUCCEEDEDFORWARDS\x10\x00\x12\x12\n" +
	"\x0eFAILEDFORWARDS\x10\x01\x12\x11\n" +
	"\rSUCCEEDEDPAYS\x10\x02\x12\x0e\n" +
	"\n" +
	"FAILEDPAYS\x10\x03\x12\x10\n" +
	"\fPAIDINVOICES\x10\x04\x12\x13\n" +
	"\x0fEXPIREDINVOICES\x10\x05*K\n" +
	"\x10PluginSubcommand\x12\t\n" +
	"\x05START\x10\x00\x12\b\n" +
	"\x04STOP\x10\x01\x12\n" +
	"\n" +
	"\x06RESCAN\x10\x02\x12\f\n" +
	"\bSTARTDIR\x10\x03\x12\b\n" +
	"\x04LIST\x10\x04b\x06proto3"

var (
	file_primitives_proto_rawDescOnce sync.Once
	file_primitives_proto_rawDescData []byte
)

func file_primitives_proto_rawDescGZIP() []byte {
	file_primitives_proto_rawDescOnce.Do(func() {
		file_primitives_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_primitives_proto_rawDesc), len(file_primitives_proto_rawDesc)))
	})
	return file_primitives_proto_rawDescData
}

var file_primitives_proto_enumTypes = make([]protoimpl.EnumInfo, 6)
var file_primitives_proto_msgTypes = make([]protoimpl.MessageInfo, 20)
var file_primitives_proto_goTypes = []any{
	(ChannelSide)(0),            // 0: cln.ChannelSide
	(ChannelState)(0),           // 1: cln.ChannelState
	(HtlcState)(0),              // 2: cln.HtlcState
	(ChannelTypeName)(0),        // 3: cln.ChannelTypeName
	(AutocleanSubsystem)(0),     // 4: cln.AutocleanSubsystem
	(PluginSubcommand)(0),       // 5: cln.PluginSubcommand
	(*Amount)(nil),              // 6: cln.Amount
	(*AmountOrAll)(nil),         // 7: cln.AmountOrAll
	(*AmountOrAny)(nil),         // 8: cln.AmountOrAny
	(*Outpoint)(nil),            // 9: cln.Outpoint
	(*Feerate)(nil),             // 10: cln.Feerate
	(*OutputDesc)(nil),          // 11: cln.OutputDesc
	(*RouteHop)(nil),            // 12: cln.RouteHop
	(*Routehint)(nil),           // 13: cln.Routehint
	(*RoutehintList)(nil),       // 14: cln.RoutehintList
	(*DecodeRouteHop)(nil),      // 15: cln.DecodeRouteHop
	(*DecodeRoutehint)(nil),     // 16: cln.DecodeRoutehint
	(*DecodeRoutehintList)(nil), // 17: cln.DecodeRoutehintList
	(*TlvEntry)(nil),            // 18: cln.TlvEntry
	(*TlvStream)(nil),           // 19: cln.TlvStream
	(*JsonObjectOrArray)(nil),   // 20: cln.JsonObjectOrArray
	(*JsonObject)(nil),          // 21: cln.JsonObject
	(*JsonArray)(nil),           // 22: cln.JsonArray
	(*JsonValue)(nil),           // 23: cln.JsonValue
	(*JsonScalar)(nil),          // 24: cln.JsonScalar
	nil,                         // 25: cln.JsonObject.FieldsEntry
}
var file_primitives_proto_depIdxs = []int32{
	6,  // 0: cln.AmountOrAll.amount:type_name -> cln.Amount
	6,  // 1: cln.AmountOrAny.amount:type_name -> cln.Amount
	6,  // 2: cln.OutputDesc.amount:type_name -> cln.Amount
	6,  // 3: cln.RouteHop.feebase:type_name -> cln.Amount
	12, // 4: cln.Routehint.hops:type_name -> cln.RouteHop
	13, // 5: cln.RoutehintList.hints:type_name -> cln.Routehint
	6,  // 6: cln.DecodeRouteHop.fee_base_msat:type_name -> cln.Amount
	15, // 7: cln.DecodeRoutehint.hops:type_name -> cln.DecodeRouteHop
	16, // 8: cln.DecodeRoutehintList.hints:type_name -> cln.DecodeRoutehint
	18, // 9: cln.TlvStream.entries:type_name -> cln.TlvEntry
	21, // 10: cln.JsonObjectOrArray.object:type_name -> cln.JsonObject
	22, // 11: cln.JsonObjectOrArray.array:type_name -> cln.JsonArray
	25, // 12: cln.JsonObject.fields:type_name -> cln.JsonObject.FieldsEntry
	23, // 13: cln.JsonArray.values:type_name -> cln.JsonValue
	22, // 14: cln.JsonValue.array:type_name -> cln.JsonArray
	21, // 15: cln.JsonValue.object:type_name -> cln.JsonObject
	23, // 16: cln.JsonObject.FieldsEntry.value:type_name -> cln.JsonValue
	17, // [17:17] is the sub-list for method output_type
	17, // [17:17] is the sub-list for method input_type
	17, // [17:17] is the sub-list for extension type_name
	17, // [17:17] is the sub-list for extension extendee
	0,  // [0:17] is the sub-list for field type_name
}

func init() { file_primitives_proto_init() }
func file_primitives_proto_init() {
	if File_primitives_proto != nil {
		return
	}
	file_primitives_proto_msgTypes[1].OneofWrappers = []any{
		(*AmountOrAll_Amount)(nil),
		(*AmountOrAll_All)(nil),
	}
	file_primitives_proto_msgTypes[2].OneofWrappers = []any{
		(*AmountOrAny_Amount)(nil),
		(*AmountOrAny_Any)(nil),
	}
	file_primitives_proto_msgTypes[4].OneofWrappers = []any{
		(*Feerate_Slow)(nil),
		(*Feerate_Normal)(nil),
		(*Feerate_Urgent)(nil),
		(*Feerate_Perkb)(nil),
		(*Feerate_Perkw)(nil),
	}
	file_primitives_proto_msgTypes[14].OneofWrappers = []any{
		(*JsonObjectOrArray_Object)(nil),
		(*JsonObjectOrArray_Array)(nil),
	}
	file_primitives_proto_msgTypes[17].OneofWrappers = []any{
		(*JsonValue_BoolValue)(nil),
		(*JsonValue_IntValue)(nil),
		(*JsonValue_UintValue)(nil),
		(*JsonValue_DoubleValue)(nil),
		(*JsonValue_StringValue)(nil),
		(*JsonValue_Array)(nil),
		(*JsonValue_Object)(nil),
	}
	file_primitives_proto_msgTypes[18].OneofWrappers = []any{
		(*JsonScalar_BoolValue)(nil),
		(*JsonScalar_IntValue)(nil),
		(*JsonScalar_UintValue)(nil),
		(*JsonScalar_DoubleValue)(nil),
		(*JsonScalar_StringValue)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_primitives_proto_rawDesc), len(file_primitives_proto_rawDesc)),
			NumEnums:      6,
			NumMessages:   20,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_primitives_proto_goTypes,
		DependencyIndexes: file_primitives_proto_depIdxs,
		EnumInfos:         file_primitives_proto_enumTypes,
		MessageInfos:      file_primitives_proto_msgTypes,
	}.Build()
	File_primitives_proto = out.File
	file_primitives_proto_goTypes = nil
	file_primitives_proto_depIdxs = nil
}