// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v3.21.12
// source: walletrpc/walletkit.proto

package walletrpc

import (
	lnrpc "github.com/lightningnetwork/lnd/lnrpc"
	signrpc "github.com/lightningnetwork/lnd/lnrpc/signrpc"
	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 AddressType int32

const (
	AddressType_UNKNOWN                           AddressType = 0
	AddressType_WITNESS_PUBKEY_HASH               AddressType = 1
	AddressType_NESTED_WITNESS_PUBKEY_HASH        AddressType = 2
	AddressType_HYBRID_NESTED_WITNESS_PUBKEY_HASH AddressType = 3
	AddressType_TAPROOT_PUBKEY                    AddressType = 4
)

// Enum value maps for AddressType.
var (
	AddressType_name = map[int32]string{
		0: "UNKNOWN",
		1: "WITNESS_PUBKEY_HASH",
		2: "NESTED_WITNESS_PUBKEY_HASH",
		3: "HYBRID_NESTED_WITNESS_PUBKEY_HASH",
		4: "TAPROOT_PUBKEY",
	}
	AddressType_value = map[string]int32{
		"UNKNOWN":                           0,
		"WITNESS_PUBKEY_HASH":               1,
		"NESTED_WITNESS_PUBKEY_HASH":        2,
		"HYBRID_NESTED_WITNESS_PUBKEY_HASH": 3,
		"TAPROOT_PUBKEY":                    4,
	}
)

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

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

func (AddressType) Descriptor() protoreflect.EnumDescriptor {
	return file_walletrpc_walletkit_proto_enumTypes[0].Descriptor()
}

func (AddressType) Type() protoreflect.EnumType {
	return &file_walletrpc_walletkit_proto_enumTypes[0]
}

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

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

type WitnessType int32

const (
	WitnessType_UNKNOWN_WITNESS WitnessType = 0
	// A witness that allows us to spend the output of a commitment transaction
	// after a relative lock-time lockout.
	WitnessType_COMMITMENT_TIME_LOCK WitnessType = 1
	// A witness that allows us to spend a settled no-delay output immediately on a
	// counterparty's commitment transaction.
	WitnessType_COMMITMENT_NO_DELAY WitnessType = 2
	// A witness that allows us to sweep the settled output of a malicious
	// counterparty's who broadcasts a revoked commitment transaction.
	WitnessType_COMMITMENT_REVOKE WitnessType = 3
	// A witness that allows us to sweep an HTLC which we offered to the remote
	// party in the case that they broadcast a revoked commitment state.
	WitnessType_HTLC_OFFERED_REVOKE WitnessType = 4
	// A witness that allows us to sweep an HTLC output sent to us in the case that
	// the remote party broadcasts a revoked commitment state.
	WitnessType_HTLC_ACCEPTED_REVOKE WitnessType = 5
	// A witness that allows us to sweep an HTLC output that we extended to a
	// party, but was never fulfilled.  This HTLC output isn't directly on the
	// commitment transaction, but is the result of a confirmed second-level HTLC
	// transaction. As a result, we can only spend this after a CSV delay.
	WitnessType_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL WitnessType = 6
	// A witness that allows us to sweep an HTLC output that was offered to us, and
	// for which we have a payment preimage. This HTLC output isn't directly on our
	// commitment transaction, but is the result of confirmed second-level HTLC
	// transaction. As a result, we can only spend this after a CSV delay.
	WitnessType_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL WitnessType = 7
	// A witness that allows us to sweep an HTLC that we offered to the remote
	// party which lies in the commitment transaction of the remote party. We can
	// spend this output after the absolute CLTV timeout of the HTLC as passed.
	WitnessType_HTLC_OFFERED_REMOTE_TIMEOUT WitnessType = 8
	// A witness that allows us to sweep an HTLC that was offered to us by the
	// remote party. We use this witness in the case that the remote party goes to
	// chain, and we know the pre-image to the HTLC. We can sweep this without any
	// additional timeout.
	WitnessType_HTLC_ACCEPTED_REMOTE_SUCCESS WitnessType = 9
	// A witness that allows us to sweep an HTLC from the remote party's commitment
	// transaction in the case that the broadcast a revoked commitment, but then
	// also immediately attempt to go to the second level to claim the HTLC.
	WitnessType_HTLC_SECOND_LEVEL_REVOKE WitnessType = 10
	// A witness type that allows us to spend a regular p2wkh output that's sent to
	// an output which is under complete control of the backing wallet.
	WitnessType_WITNESS_KEY_HASH WitnessType = 11
	// A witness type that allows us to sweep an output that sends to a nested P2SH
	// script that pays to a key solely under our control.
	WitnessType_NESTED_WITNESS_KEY_HASH WitnessType = 12
	// A witness type that allows us to spend our anchor on the commitment
	// transaction.
	WitnessType_COMMITMENT_ANCHOR WitnessType = 13
	// A witness type that is similar to the COMMITMENT_NO_DELAY type,
	// but it omits the tweak that randomizes the key we need to
	// spend with a channel peer supplied set of randomness.
	WitnessType_COMMITMENT_NO_DELAY_TWEAKLESS WitnessType = 14
	// A witness type that allows us to spend our output on the counterparty's
	// commitment transaction after a confirmation.
	WitnessType_COMMITMENT_TO_REMOTE_CONFIRMED WitnessType = 15
	// A witness type that allows us to sweep an HTLC output that we extended
	// to a party, but was never fulfilled. This _is_ the HTLC output directly
	// on our commitment transaction, and the input to the second-level HTLC
	// timeout transaction. It can only be spent after CLTV expiry, and
	// commitment confirmation.
	WitnessType_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL_INPUT_CONFIRMED WitnessType = 16
	// A witness type that allows us to sweep an HTLC output that was offered
	// to us, and for which we have a payment preimage. This _is_ the HTLC
	// output directly on our commitment transaction, and the input to the
	// second-level HTLC success transaction. It can only be spent after the
	// commitment has confirmed.
	WitnessType_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL_INPUT_CONFIRMED WitnessType = 17
	// A witness type that allows us to spend our output on our local
	// commitment transaction after a relative and absolute lock-time lockout as
	// part of the script enforced lease commitment type.
	WitnessType_LEASE_COMMITMENT_TIME_LOCK WitnessType = 18
	// A witness type that allows us to spend our output on the counterparty's
	// commitment transaction after a confirmation and absolute locktime as part
	// of the script enforced lease commitment type.
	WitnessType_LEASE_COMMITMENT_TO_REMOTE_CONFIRMED WitnessType = 19
	// A witness type that allows us to sweep an HTLC output that we extended
	// to a party, but was never fulfilled. This HTLC output isn't directly on
	// the commitment transaction, but is the result of a confirmed second-level
	// HTLC transaction. As a result, we can only spend this after a CSV delay
	// and CLTV locktime as part of the script enforced lease commitment type.
	WitnessType_LEASE_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL WitnessType = 20
	// A witness type that allows us to sweep an HTLC output that was offered
	// to us, and for which we have a payment preimage. This HTLC output isn't
	// directly on our commitment transaction, but is the result of confirmed
	// second-level HTLC transaction. As a result, we can only spend this after
	// a CSV delay and CLTV locktime as part of the script enforced lease
	// commitment type.
	WitnessType_LEASE_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL WitnessType = 21
	// A witness type that allows us to spend a regular p2tr output that's sent
	// to an output which is under complete control of the backing wallet.
	WitnessType_TAPROOT_PUB_KEY_SPEND WitnessType = 22
	// A witness type that allows us to spend our settled local commitment after a
	// CSV delay when we force close the channel.
	WitnessType_TAPROOT_LOCAL_COMMIT_SPEND WitnessType = 23
	// A witness type that allows us to spend our settled local commitment after
	// a CSV delay when the remote party has force closed the channel.
	WitnessType_TAPROOT_REMOTE_COMMIT_SPEND WitnessType = 24
	// A witness type that we'll use for spending our own anchor output.
	WitnessType_TAPROOT_ANCHOR_SWEEP_SPEND WitnessType = 25
	// A witness that allows us to timeout an HTLC we offered to the remote party
	// on our commitment transaction. We use this when we need to go on chain to
	// time out an HTLC.
	WitnessType_TAPROOT_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL WitnessType = 26
	// A witness type that allows us to sweep an HTLC we accepted on our commitment
	// transaction after we go to the second level on chain.
	WitnessType_TAPROOT_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL WitnessType = 27
	// A witness that allows us to sweep an HTLC on the revoked transaction of the
	// remote party that goes to the second level.
	WitnessType_TAPROOT_HTLC_SECOND_LEVEL_REVOKE WitnessType = 28
	// A witness that allows us to sweep an HTLC sent to us by the remote party
	// in the event that they broadcast a revoked state.
	WitnessType_TAPROOT_HTLC_ACCEPTED_REVOKE WitnessType = 29
	// A witness that allows us to sweep an HTLC we offered to the remote party if
	// they broadcast a revoked commitment.
	WitnessType_TAPROOT_HTLC_OFFERED_REVOKE WitnessType = 30
	// A witness that allows us to sweep an HTLC we offered to the remote party
	// that lies on the commitment transaction for the remote party. We can spend
	// this output after the absolute CLTV timeout of the HTLC as passed.
	WitnessType_TAPROOT_HTLC_OFFERED_REMOTE_TIMEOUT WitnessType = 31
	// A witness type that allows us to sign the second level HTLC timeout
	// transaction when spending from an HTLC residing on our local commitment
	// transaction.
	// This is used by the sweeper to re-sign inputs if it needs to aggregate
	// several second level HTLCs.
	WitnessType_TAPROOT_HTLC_LOCAL_OFFERED_TIMEOUT WitnessType = 32
	// A witness that allows us to sweep an HTLC that was offered to us by the
	// remote party for a taproot channels. We use this witness in the case that
	// the remote party goes to chain, and we know the pre-image to the HTLC. We
	// can sweep this without any additional timeout.
	WitnessType_TAPROOT_HTLC_ACCEPTED_REMOTE_SUCCESS WitnessType = 33
	// A witness type that allows us to sweep the HTLC offered to us on our local
	// commitment transaction. We'll use this when we need to go on chain to sweep
	// the HTLC. In this case, this is the second level HTLC success transaction.
	WitnessType_TAPROOT_HTLC_ACCEPTED_LOCAL_SUCCESS WitnessType = 34
	// A witness that allows us to sweep the settled output of a malicious
	// counterparty's who broadcasts a revoked taproot commitment transaction.
	WitnessType_TAPROOT_COMMITMENT_REVOKE WitnessType = 35
	// A witness type that allows us to spend our settled local commitment after a
	// CSV delay when we force close a production taproot channel.
	WitnessType_TAPROOT_LOCAL_COMMIT_SPEND_FINAL WitnessType = 36
	// A witness type that allows us to spend our settled local commitment after
	// a CSV delay when the remote party has force closed a production taproot
	// channel.
	WitnessType_TAPROOT_REMOTE_COMMIT_SPEND_FINAL WitnessType = 37
	// A witness that allows us to timeout an HTLC we offered to the remote party
	// on our production taproot commitment transaction. We use this when we need
	// to go on chain to time out an HTLC.
	WitnessType_TAPROOT_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL_FINAL WitnessType = 38
	// A witness type that allows us to sweep an HTLC we accepted on our
	// production taproot commitment transaction after we go to the second level
	// on chain.
	WitnessType_TAPROOT_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL_FINAL WitnessType = 39
	// A witness that allows us to sweep an HTLC we offered to the remote party
	// that lies on the production taproot commitment transaction for the remote
	// party. We can spend this output after the absolute CLTV timeout of the
	// HTLC as passed.
	WitnessType_TAPROOT_HTLC_OFFERED_REMOTE_TIMEOUT_FINAL WitnessType = 40
	// A witness that allows us to sweep an HTLC that was offered to us by the
	// remote party for a production taproot channel. We use this witness in the
	// case that the remote party goes to chain, and we know the pre-image to the
	// HTLC. We can sweep this without any additional timeout.
	WitnessType_TAPROOT_HTLC_ACCEPTED_REMOTE_SUCCESS_FINAL WitnessType = 41
	// A witness type that allows us to sweep the settled output of a malicious
	// counterparty's who broadcasts a revoked production taproot commitment
	// transaction.
	WitnessType_TAPROOT_COMMITMENT_REVOKE_FINAL WitnessType = 42
)

// Enum value maps for WitnessType.
var (
	WitnessType_name = map[int32]string{
		0:  "UNKNOWN_WITNESS",
		1:  "COMMITMENT_TIME_LOCK",
		2:  "COMMITMENT_NO_DELAY",
		3:  "COMMITMENT_REVOKE",
		4:  "HTLC_OFFERED_REVOKE",
		5:  "HTLC_ACCEPTED_REVOKE",
		6:  "HTLC_OFFERED_TIMEOUT_SECOND_LEVEL",
		7:  "HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL",
		8:  "HTLC_OFFERED_REMOTE_TIMEOUT",
		9:  "HTLC_ACCEPTED_REMOTE_SUCCESS",
		10: "HTLC_SECOND_LEVEL_REVOKE",
		11: "WITNESS_KEY_HASH",
		12: "NESTED_WITNESS_KEY_HASH",
		13: "COMMITMENT_ANCHOR",
		14: "COMMITMENT_NO_DELAY_TWEAKLESS",
		15: "COMMITMENT_TO_REMOTE_CONFIRMED",
		16: "HTLC_OFFERED_TIMEOUT_SECOND_LEVEL_INPUT_CONFIRMED",
		17: "HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL_INPUT_CONFIRMED",
		18: "LEASE_COMMITMENT_TIME_LOCK",
		19: "LEASE_COMMITMENT_TO_REMOTE_CONFIRMED",
		20: "LEASE_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL",
		21: "LEASE_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL",
		22: "TAPROOT_PUB_KEY_SPEND",
		23: "TAPROOT_LOCAL_COMMIT_SPEND",
		24: "TAPROOT_REMOTE_COMMIT_SPEND",
		25: "TAPROOT_ANCHOR_SWEEP_SPEND",
		26: "TAPROOT_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL",
		27: "TAPROOT_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL",
		28: "TAPROOT_HTLC_SECOND_LEVEL_REVOKE",
		29: "TAPROOT_HTLC_ACCEPTED_REVOKE",
		30: "TAPROOT_HTLC_OFFERED_REVOKE",
		31: "TAPROOT_HTLC_OFFERED_REMOTE_TIMEOUT",
		32: "TAPROOT_HTLC_LOCAL_OFFERED_TIMEOUT",
		33: "TAPROOT_HTLC_ACCEPTED_REMOTE_SUCCESS",
		34: "TAPROOT_HTLC_ACCEPTED_LOCAL_SUCCESS",
		35: "TAPROOT_COMMITMENT_REVOKE",
		36: "TAPROOT_LOCAL_COMMIT_SPEND_FINAL",
		37: "TAPROOT_REMOTE_COMMIT_SPEND_FINAL",
		38: "TAPROOT_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL_FINAL",
		39: "TAPROOT_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL_FINAL",
		40: "TAPROOT_HTLC_OFFERED_REMOTE_TIMEOUT_FINAL",
		41: "TAPROOT_HTLC_ACCEPTED_REMOTE_SUCCESS_FINAL",
		42: "TAPROOT_COMMITMENT_REVOKE_FINAL",
	}
	WitnessType_value = map[string]int32{
		"UNKNOWN_WITNESS":                                    0,
		"COMMITMENT_TIME_LOCK":                               1,
		"COMMITMENT_NO_DELAY":                                2,
		"COMMITMENT_REVOKE":                                  3,
		"HTLC_OFFERED_REVOKE":                                4,
		"HTLC_ACCEPTED_REVOKE":                               5,
		"HTLC_OFFERED_TIMEOUT_SECOND_LEVEL":                  6,
		"HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL":                 7,
		"HTLC_OFFERED_REMOTE_TIMEOUT":                        8,
		"HTLC_ACCEPTED_REMOTE_SUCCESS":                       9,
		"HTLC_SECOND_LEVEL_REVOKE":                           10,
		"WITNESS_KEY_HASH":                                   11,
		"NESTED_WITNESS_KEY_HASH":                            12,
		"COMMITMENT_ANCHOR":                                  13,
		"COMMITMENT_NO_DELAY_TWEAKLESS":                      14,
		"COMMITMENT_TO_REMOTE_CONFIRMED":                     15,
		"HTLC_OFFERED_TIMEOUT_SECOND_LEVEL_INPUT_CONFIRMED":  16,
		"HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL_INPUT_CONFIRMED": 17,
		"LEASE_COMMITMENT_TIME_LOCK":                         18,
		"LEASE_COMMITMENT_TO_REMOTE_CONFIRMED":               19,
		"LEASE_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL":            20,
		"LEASE_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL":           21,
		"TAPROOT_PUB_KEY_SPEND":                              22,
		"TAPROOT_LOCAL_COMMIT_SPEND":                         23,
		"TAPROOT_REMOTE_COMMIT_SPEND":                        24,
		"TAPROOT_ANCHOR_SWEEP_SPEND":                         25,
		"TAPROOT_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL":          26,
		"TAPROOT_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL":         27,
		"TAPROOT_HTLC_SECOND_LEVEL_REVOKE":                   28,
		"TAPROOT_HTLC_ACCEPTED_REVOKE":                       29,
		"TAPROOT_HTLC_OFFERED_REVOKE":                        30,
		"TAPROOT_HTLC_OFFERED_REMOTE_TIMEOUT":                31,
		"TAPROOT_HTLC_LOCAL_OFFERED_TIMEOUT":                 32,
		"TAPROOT_HTLC_ACCEPTED_REMOTE_SUCCESS":               33,
		"TAPROOT_HTLC_ACCEPTED_LOCAL_SUCCESS":                34,
		"TAPROOT_COMMITMENT_REVOKE":                          35,
		"TAPROOT_LOCAL_COMMIT_SPEND_FINAL":                   36,
		"TAPROOT_REMOTE_COMMIT_SPEND_FINAL":                  37,
		"TAPROOT_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL_FINAL":    38,
		"TAPROOT_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL_FINAL":   39,
		"TAPROOT_HTLC_OFFERED_REMOTE_TIMEOUT_FINAL":          40,
		"TAPROOT_HTLC_ACCEPTED_REMOTE_SUCCESS_FINAL":         41,
		"TAPROOT_COMMITMENT_REVOKE_FINAL":                    42,
	}
)

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

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

func (WitnessType) Descriptor() protoreflect.EnumDescriptor {
	return file_walletrpc_walletkit_proto_enumTypes[1].Descriptor()
}

func (WitnessType) Type() protoreflect.EnumType {
	return &file_walletrpc_walletkit_proto_enumTypes[1]
}

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

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

// The possible change address types for default accounts and single imported
// public keys. By default, P2WPKH will be used. We don't provide the
// possibility to choose P2PKH as it is a legacy key scope, nor NP2WPKH as
// no key scope permits to do so. For custom accounts, no change type should
// be provided as the coin selection key scope will always be used to generate
// the change address.
type ChangeAddressType int32

const (
	// CHANGE_ADDRESS_TYPE_UNSPECIFIED indicates that no change address type is
	// provided. We will then use P2WPKH address type for change (BIP0084 key
	// scope).
	ChangeAddressType_CHANGE_ADDRESS_TYPE_UNSPECIFIED ChangeAddressType = 0
	// CHANGE_ADDRESS_TYPE_P2TR indicates to use P2TR address for change output
	// (BIP0086 key scope).
	ChangeAddressType_CHANGE_ADDRESS_TYPE_P2TR ChangeAddressType = 1
)

// Enum value maps for ChangeAddressType.
var (
	ChangeAddressType_name = map[int32]string{
		0: "CHANGE_ADDRESS_TYPE_UNSPECIFIED",
		1: "CHANGE_ADDRESS_TYPE_P2TR",
	}
	ChangeAddressType_value = map[string]int32{
		"CHANGE_ADDRESS_TYPE_UNSPECIFIED": 0,
		"CHANGE_ADDRESS_TYPE_P2TR":        1,
	}
)

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

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

func (ChangeAddressType) Descriptor() protoreflect.EnumDescriptor {
	return file_walletrpc_walletkit_proto_enumTypes[2].Descriptor()
}

func (ChangeAddressType) Type() protoreflect.EnumType {
	return &file_walletrpc_walletkit_proto_enumTypes[2]
}

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

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

type ListUnspentRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The minimum number of confirmations to be included.
	MinConfs int32 `protobuf:"varint,1,opt,name=min_confs,json=minConfs,proto3" json:"min_confs,omitempty"`
	// The maximum number of confirmations to be included.
	MaxConfs int32 `protobuf:"varint,2,opt,name=max_confs,json=maxConfs,proto3" json:"max_confs,omitempty"`
	// An optional filter to only include outputs belonging to an account.
	Account string `protobuf:"bytes,3,opt,name=account,proto3" json:"account,omitempty"`
	// When min_confs and max_confs are zero, setting false implicitly
	// overrides max_confs to be MaxInt32, otherwise max_confs remains
	// zero. An error is returned if the value is true and both min_confs
	// and max_confs are non-zero. (default: false)
	UnconfirmedOnly bool `protobuf:"varint,4,opt,name=unconfirmed_only,json=unconfirmedOnly,proto3" json:"unconfirmed_only,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*ListUnspentRequest) ProtoMessage() {}

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

func (x *ListUnspentRequest) GetMinConfs() int32 {
	if x != nil {
		return x.MinConfs
	}
	return 0
}

func (x *ListUnspentRequest) GetMaxConfs() int32 {
	if x != nil {
		return x.MaxConfs
	}
	return 0
}

func (x *ListUnspentRequest) GetAccount() string {
	if x != nil {
		return x.Account
	}
	return ""
}

func (x *ListUnspentRequest) GetUnconfirmedOnly() bool {
	if x != nil {
		return x.UnconfirmedOnly
	}
	return false
}

type ListUnspentResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A list of utxos satisfying the specified number of confirmations.
	Utxos         []*lnrpc.Utxo `protobuf:"bytes,1,rep,name=utxos,proto3" json:"utxos,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListUnspentResponse) ProtoMessage() {}

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

func (x *ListUnspentResponse) GetUtxos() []*lnrpc.Utxo {
	if x != nil {
		return x.Utxos
	}
	return nil
}

type LeaseOutputRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// An ID of 32 random bytes that must be unique for each distinct application
	// using this RPC which will be used to bound the output lease to.
	Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// The identifying outpoint of the output being leased.
	Outpoint *lnrpc.OutPoint `protobuf:"bytes,2,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	// The time in seconds before the lock expires. If set to zero, the default
	// lock duration is used.
	ExpirationSeconds uint64 `protobuf:"varint,3,opt,name=expiration_seconds,json=expirationSeconds,proto3" json:"expiration_seconds,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*LeaseOutputRequest) ProtoMessage() {}

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

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

func (x *LeaseOutputRequest) GetOutpoint() *lnrpc.OutPoint {
	if x != nil {
		return x.Outpoint
	}
	return nil
}

func (x *LeaseOutputRequest) GetExpirationSeconds() uint64 {
	if x != nil {
		return x.ExpirationSeconds
	}
	return 0
}

type LeaseOutputResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The absolute expiration of the output lease represented as a unix timestamp.
	Expiration    uint64 `protobuf:"varint,1,opt,name=expiration,proto3" json:"expiration,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LeaseOutputResponse) ProtoMessage() {}

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

func (x *LeaseOutputResponse) GetExpiration() uint64 {
	if x != nil {
		return x.Expiration
	}
	return 0
}

type ReleaseOutputRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The unique ID that was used to lock the output.
	Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// The identifying outpoint of the output being released.
	Outpoint      *lnrpc.OutPoint `protobuf:"bytes,2,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ReleaseOutputRequest) ProtoMessage() {}

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

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

func (x *ReleaseOutputRequest) GetOutpoint() *lnrpc.OutPoint {
	if x != nil {
		return x.Outpoint
	}
	return nil
}

type ReleaseOutputResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The status of the release operation.
	Status        string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ReleaseOutputResponse) ProtoMessage() {}

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

func (x *ReleaseOutputResponse) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

type KeyReq struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Is the key finger print of the root pubkey that this request is targeting.
	// This allows the WalletKit to possibly serve out keys for multiple HD chains
	// via public derivation.
	KeyFingerPrint int32 `protobuf:"varint,1,opt,name=key_finger_print,json=keyFingerPrint,proto3" json:"key_finger_print,omitempty"`
	// The target key family to derive a key from. In other contexts, this is
	// known as the "account".
	KeyFamily     int32 `protobuf:"varint,2,opt,name=key_family,json=keyFamily,proto3" json:"key_family,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*KeyReq) ProtoMessage() {}

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

func (x *KeyReq) GetKeyFingerPrint() int32 {
	if x != nil {
		return x.KeyFingerPrint
	}
	return 0
}

func (x *KeyReq) GetKeyFamily() int32 {
	if x != nil {
		return x.KeyFamily
	}
	return 0
}

type AddrRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name of the account to retrieve the next address of. If empty, the
	// default wallet account is used.
	Account string `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	// The type of address to derive.
	Type AddressType `protobuf:"varint,2,opt,name=type,proto3,enum=walletrpc.AddressType" json:"type,omitempty"`
	// Whether a change address should be derived.
	Change        bool `protobuf:"varint,3,opt,name=change,proto3" json:"change,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AddrRequest) ProtoMessage() {}

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

func (x *AddrRequest) GetAccount() string {
	if x != nil {
		return x.Account
	}
	return ""
}

func (x *AddrRequest) GetType() AddressType {
	if x != nil {
		return x.Type
	}
	return AddressType_UNKNOWN
}

func (x *AddrRequest) GetChange() bool {
	if x != nil {
		return x.Change
	}
	return false
}

type AddrResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The address encoded using a bech32 format.
	Addr          string `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AddrResponse) ProtoMessage() {}

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

func (x *AddrResponse) GetAddr() string {
	if x != nil {
		return x.Addr
	}
	return ""
}

type Account struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name used to identify the account.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The type of addresses the account supports.
	AddressType AddressType `protobuf:"varint,2,opt,name=address_type,json=addressType,proto3,enum=walletrpc.AddressType" json:"address_type,omitempty"`
	// The public key backing the account that all keys are derived from
	// represented as an extended key. This will always be empty for the default
	// imported account in which single public keys are imported into.
	ExtendedPublicKey string `protobuf:"bytes,3,opt,name=extended_public_key,json=extendedPublicKey,proto3" json:"extended_public_key,omitempty"`
	// The fingerprint of the root key from which the account public key was
	// derived from. This will always be zero for the default imported account in
	// which single public keys are imported into. The bytes are in big-endian
	// order.
	MasterKeyFingerprint []byte `protobuf:"bytes,4,opt,name=master_key_fingerprint,json=masterKeyFingerprint,proto3" json:"master_key_fingerprint,omitempty"`
	// The derivation path corresponding to the account public key. This will
	// always be empty for the default imported account in which single public keys
	// are imported into.
	DerivationPath string `protobuf:"bytes,5,opt,name=derivation_path,json=derivationPath,proto3" json:"derivation_path,omitempty"`
	// The number of keys derived from the external branch of the account public
	// key. This will always be zero for the default imported account in which
	// single public keys are imported into.
	ExternalKeyCount uint32 `protobuf:"varint,6,opt,name=external_key_count,json=externalKeyCount,proto3" json:"external_key_count,omitempty"`
	// The number of keys derived from the internal branch of the account public
	// key. This will always be zero for the default imported account in which
	// single public keys are imported into.
	InternalKeyCount uint32 `protobuf:"varint,7,opt,name=internal_key_count,json=internalKeyCount,proto3" json:"internal_key_count,omitempty"`
	// Whether the wallet stores private keys for the account.
	WatchOnly     bool `protobuf:"varint,8,opt,name=watch_only,json=watchOnly,proto3" json:"watch_only,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Account) ProtoMessage() {}

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

func (x *Account) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Account) GetAddressType() AddressType {
	if x != nil {
		return x.AddressType
	}
	return AddressType_UNKNOWN
}

func (x *Account) GetExtendedPublicKey() string {
	if x != nil {
		return x.ExtendedPublicKey
	}
	return ""
}

func (x *Account) GetMasterKeyFingerprint() []byte {
	if x != nil {
		return x.MasterKeyFingerprint
	}
	return nil
}

func (x *Account) GetDerivationPath() string {
	if x != nil {
		return x.DerivationPath
	}
	return ""
}

func (x *Account) GetExternalKeyCount() uint32 {
	if x != nil {
		return x.ExternalKeyCount
	}
	return 0
}

func (x *Account) GetInternalKeyCount() uint32 {
	if x != nil {
		return x.InternalKeyCount
	}
	return 0
}

func (x *Account) GetWatchOnly() bool {
	if x != nil {
		return x.WatchOnly
	}
	return false
}

type AddressProperty struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The address encoded using the appropriate format depending on the
	// address type (base58, bech32, bech32m).
	//
	// Note that lnd's internal/custom keys for channels and other
	// functionality are derived from the same scope. Since they
	// aren't really used as addresses and will never have an
	// on-chain balance, we'll show the public key instead (only if
	// the show_custom_accounts flag is provided).
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// Denotes if the address is a change address.
	IsInternal bool `protobuf:"varint,2,opt,name=is_internal,json=isInternal,proto3" json:"is_internal,omitempty"`
	// The balance of the address.
	Balance int64 `protobuf:"varint,3,opt,name=balance,proto3" json:"balance,omitempty"`
	// The full derivation path of the address. This will be empty for imported
	// addresses.
	DerivationPath string `protobuf:"bytes,4,opt,name=derivation_path,json=derivationPath,proto3" json:"derivation_path,omitempty"`
	// The public key of the address. This will be empty for imported addresses.
	PublicKey     []byte `protobuf:"bytes,5,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AddressProperty) ProtoMessage() {}

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

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

func (x *AddressProperty) GetIsInternal() bool {
	if x != nil {
		return x.IsInternal
	}
	return false
}

func (x *AddressProperty) GetBalance() int64 {
	if x != nil {
		return x.Balance
	}
	return 0
}

func (x *AddressProperty) GetDerivationPath() string {
	if x != nil {
		return x.DerivationPath
	}
	return ""
}

func (x *AddressProperty) GetPublicKey() []byte {
	if x != nil {
		return x.PublicKey
	}
	return nil
}

type AccountWithAddresses struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name used to identify the account.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The type of addresses the account supports.
	AddressType AddressType `protobuf:"varint,2,opt,name=address_type,json=addressType,proto3,enum=walletrpc.AddressType" json:"address_type,omitempty"`
	// The derivation path corresponding to the account public key. This will
	// always be empty for the default imported account in which single public keys
	// are imported into.
	DerivationPath string `protobuf:"bytes,3,opt,name=derivation_path,json=derivationPath,proto3" json:"derivation_path,omitempty"`
	// List of address, its type internal/external & balance.
	// Note that the order of addresses will be random and not according to the
	// derivation index, since that information is not stored by the underlying
	// wallet.
	Addresses     []*AddressProperty `protobuf:"bytes,4,rep,name=addresses,proto3" json:"addresses,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AccountWithAddresses) ProtoMessage() {}

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

func (x *AccountWithAddresses) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *AccountWithAddresses) GetAddressType() AddressType {
	if x != nil {
		return x.AddressType
	}
	return AddressType_UNKNOWN
}

func (x *AccountWithAddresses) GetDerivationPath() string {
	if x != nil {
		return x.DerivationPath
	}
	return ""
}

func (x *AccountWithAddresses) GetAddresses() []*AddressProperty {
	if x != nil {
		return x.Addresses
	}
	return nil
}

type ListAccountsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// An optional filter to only return accounts matching this name.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// An optional filter to only return accounts matching this address type.
	AddressType   AddressType `protobuf:"varint,2,opt,name=address_type,json=addressType,proto3,enum=walletrpc.AddressType" json:"address_type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListAccountsRequest) ProtoMessage() {}

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

func (x *ListAccountsRequest) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *ListAccountsRequest) GetAddressType() AddressType {
	if x != nil {
		return x.AddressType
	}
	return AddressType_UNKNOWN
}

type ListAccountsResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Accounts      []*Account             `protobuf:"bytes,1,rep,name=accounts,proto3" json:"accounts,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListAccountsResponse) ProtoMessage() {}

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

func (x *ListAccountsResponse) GetAccounts() []*Account {
	if x != nil {
		return x.Accounts
	}
	return nil
}

type RequiredReserveRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The number of additional channels the user would like to open.
	AdditionalPublicChannels uint32 `protobuf:"varint,1,opt,name=additional_public_channels,json=additionalPublicChannels,proto3" json:"additional_public_channels,omitempty"`
	unknownFields            protoimpl.UnknownFields
	sizeCache                protoimpl.SizeCache
}

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

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

func (*RequiredReserveRequest) ProtoMessage() {}

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

func (x *RequiredReserveRequest) GetAdditionalPublicChannels() uint32 {
	if x != nil {
		return x.AdditionalPublicChannels
	}
	return 0
}

type RequiredReserveResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The amount of reserve required.
	RequiredReserve int64 `protobuf:"varint,1,opt,name=required_reserve,json=requiredReserve,proto3" json:"required_reserve,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*RequiredReserveResponse) ProtoMessage() {}

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

func (x *RequiredReserveResponse) GetRequiredReserve() int64 {
	if x != nil {
		return x.RequiredReserve
	}
	return 0
}

type ListAddressesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// An optional filter to only return addresses matching this account.
	AccountName string `protobuf:"bytes,1,opt,name=account_name,json=accountName,proto3" json:"account_name,omitempty"`
	// An optional flag to return LND's custom accounts (Purpose=1017)
	// public key along with other addresses.
	ShowCustomAccounts bool `protobuf:"varint,2,opt,name=show_custom_accounts,json=showCustomAccounts,proto3" json:"show_custom_accounts,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

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

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

func (*ListAddressesRequest) ProtoMessage() {}

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

func (x *ListAddressesRequest) GetAccountName() string {
	if x != nil {
		return x.AccountName
	}
	return ""
}

func (x *ListAddressesRequest) GetShowCustomAccounts() bool {
	if x != nil {
		return x.ShowCustomAccounts
	}
	return false
}

type ListAddressesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A list of all the accounts and their addresses.
	AccountWithAddresses []*AccountWithAddresses `protobuf:"bytes,1,rep,name=account_with_addresses,json=accountWithAddresses,proto3" json:"account_with_addresses,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

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

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

func (*ListAddressesResponse) ProtoMessage() {}

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

func (x *ListAddressesResponse) GetAccountWithAddresses() []*AccountWithAddresses {
	if x != nil {
		return x.AccountWithAddresses
	}
	return nil
}

type GetTransactionRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The txid of the transaction.
	Txid          string `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetTransactionRequest) ProtoMessage() {}

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

func (x *GetTransactionRequest) GetTxid() string {
	if x != nil {
		return x.Txid
	}
	return ""
}

type SignMessageWithAddrRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The message to be signed. When using REST, this field must be encoded as
	// base64.
	Msg []byte `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
	// The address which will be used to look up the private key and sign the
	// corresponding message.
	Addr          string `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SignMessageWithAddrRequest) ProtoMessage() {}

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

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

func (x *SignMessageWithAddrRequest) GetMsg() []byte {
	if x != nil {
		return x.Msg
	}
	return nil
}

func (x *SignMessageWithAddrRequest) GetAddr() string {
	if x != nil {
		return x.Addr
	}
	return ""
}

type SignMessageWithAddrResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The compact ECDSA signature for the given message encoded in base64.
	Signature     string `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SignMessageWithAddrResponse) ProtoMessage() {}

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

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

func (x *SignMessageWithAddrResponse) GetSignature() string {
	if x != nil {
		return x.Signature
	}
	return ""
}

type VerifyMessageWithAddrRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The message to be signed. When using REST, this field must be encoded as
	// base64.
	Msg []byte `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
	// The compact ECDSA signature to be verified over the given message
	// ecoded in base64.
	Signature string `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	// The address which will be used to look up the public key and verify the
	// the signature.
	Addr          string `protobuf:"bytes,3,opt,name=addr,proto3" json:"addr,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*VerifyMessageWithAddrRequest) ProtoMessage() {}

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

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

func (x *VerifyMessageWithAddrRequest) GetMsg() []byte {
	if x != nil {
		return x.Msg
	}
	return nil
}

func (x *VerifyMessageWithAddrRequest) GetSignature() string {
	if x != nil {
		return x.Signature
	}
	return ""
}

func (x *VerifyMessageWithAddrRequest) GetAddr() string {
	if x != nil {
		return x.Addr
	}
	return ""
}

type VerifyMessageWithAddrResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Whether the signature was valid over the given message.
	Valid bool `protobuf:"varint,1,opt,name=valid,proto3" json:"valid,omitempty"`
	// The pubkey recovered from the signature.
	Pubkey        []byte `protobuf:"bytes,2,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*VerifyMessageWithAddrResponse) ProtoMessage() {}

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

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

func (x *VerifyMessageWithAddrResponse) GetValid() bool {
	if x != nil {
		return x.Valid
	}
	return false
}

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

type ImportAccountRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A name to identify the account with.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// A public key that corresponds to a wallet account represented as an extended
	// key. It must conform to a derivation path of the form
	// m/purpose'/coin_type'/account'.
	ExtendedPublicKey string `protobuf:"bytes,2,opt,name=extended_public_key,json=extendedPublicKey,proto3" json:"extended_public_key,omitempty"`
	// The fingerprint of the root key (also known as the key with derivation path
	// m/) from which the account public key was derived from. This may be required
	// by some hardware wallets for proper identification and signing. The bytes
	// must be in big-endian order.
	MasterKeyFingerprint []byte `protobuf:"bytes,3,opt,name=master_key_fingerprint,json=masterKeyFingerprint,proto3" json:"master_key_fingerprint,omitempty"`
	// An address type is only required when the extended account public key has a
	// legacy version (xpub, tpub, etc.), such that the wallet cannot detect what
	// address scheme it belongs to.
	AddressType AddressType `protobuf:"varint,4,opt,name=address_type,json=addressType,proto3,enum=walletrpc.AddressType" json:"address_type,omitempty"`
	// Whether a dry run should be attempted when importing the account. This
	// serves as a way to confirm whether the account is being imported correctly
	// by returning the first N addresses for the external and internal branches of
	// the account. If these addresses match as expected, then it should be safe to
	// import the account as is.
	DryRun        bool `protobuf:"varint,5,opt,name=dry_run,json=dryRun,proto3" json:"dry_run,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ImportAccountRequest) ProtoMessage() {}

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

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

func (x *ImportAccountRequest) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *ImportAccountRequest) GetExtendedPublicKey() string {
	if x != nil {
		return x.ExtendedPublicKey
	}
	return ""
}

func (x *ImportAccountRequest) GetMasterKeyFingerprint() []byte {
	if x != nil {
		return x.MasterKeyFingerprint
	}
	return nil
}

func (x *ImportAccountRequest) GetAddressType() AddressType {
	if x != nil {
		return x.AddressType
	}
	return AddressType_UNKNOWN
}

func (x *ImportAccountRequest) GetDryRun() bool {
	if x != nil {
		return x.DryRun
	}
	return false
}

type ImportAccountResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The details of the imported account.
	Account *Account `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	// The first N addresses that belong to the external branch of the account.
	// The external branch is typically used for external non-change addresses.
	// These are only returned if a dry run was specified within the request.
	DryRunExternalAddrs []string `protobuf:"bytes,2,rep,name=dry_run_external_addrs,json=dryRunExternalAddrs,proto3" json:"dry_run_external_addrs,omitempty"`
	// The first N addresses that belong to the internal branch of the account.
	// The internal branch is typically used for change addresses. These are only
	// returned if a dry run was specified within the request.
	DryRunInternalAddrs []string `protobuf:"bytes,3,rep,name=dry_run_internal_addrs,json=dryRunInternalAddrs,proto3" json:"dry_run_internal_addrs,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *ImportAccountResponse) Reset() {
	*x = ImportAccountResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ImportAccountResponse) ProtoMessage() {}

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

func (x *ImportAccountResponse) GetAccount() *Account {
	if x != nil {
		return x.Account
	}
	return nil
}

func (x *ImportAccountResponse) GetDryRunExternalAddrs() []string {
	if x != nil {
		return x.DryRunExternalAddrs
	}
	return nil
}

func (x *ImportAccountResponse) GetDryRunInternalAddrs() []string {
	if x != nil {
		return x.DryRunInternalAddrs
	}
	return nil
}

type ImportPublicKeyRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A compressed public key represented as raw bytes.
	PublicKey []byte `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	// The type of address that will be generated from the public key.
	AddressType   AddressType `protobuf:"varint,2,opt,name=address_type,json=addressType,proto3,enum=walletrpc.AddressType" json:"address_type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ImportPublicKeyRequest) Reset() {
	*x = ImportPublicKeyRequest{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ImportPublicKeyRequest) ProtoMessage() {}

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

func (x *ImportPublicKeyRequest) GetPublicKey() []byte {
	if x != nil {
		return x.PublicKey
	}
	return nil
}

func (x *ImportPublicKeyRequest) GetAddressType() AddressType {
	if x != nil {
		return x.AddressType
	}
	return AddressType_UNKNOWN
}

type ImportPublicKeyResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The status of the import operation.
	Status        string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ImportPublicKeyResponse) Reset() {
	*x = ImportPublicKeyResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ImportPublicKeyResponse) ProtoMessage() {}

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

func (x *ImportPublicKeyResponse) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

type ImportTapscriptRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The internal public key, serialized as 32-byte x-only public key.
	InternalPublicKey []byte `protobuf:"bytes,1,opt,name=internal_public_key,json=internalPublicKey,proto3" json:"internal_public_key,omitempty"`
	// Types that are valid to be assigned to Script:
	//
	//	*ImportTapscriptRequest_FullTree
	//	*ImportTapscriptRequest_PartialReveal
	//	*ImportTapscriptRequest_RootHashOnly
	//	*ImportTapscriptRequest_FullKeyOnly
	Script        isImportTapscriptRequest_Script `protobuf_oneof:"script"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ImportTapscriptRequest) Reset() {
	*x = ImportTapscriptRequest{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ImportTapscriptRequest) ProtoMessage() {}

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

func (x *ImportTapscriptRequest) GetInternalPublicKey() []byte {
	if x != nil {
		return x.InternalPublicKey
	}
	return nil
}

func (x *ImportTapscriptRequest) GetScript() isImportTapscriptRequest_Script {
	if x != nil {
		return x.Script
	}
	return nil
}

func (x *ImportTapscriptRequest) GetFullTree() *TapscriptFullTree {
	if x != nil {
		if x, ok := x.Script.(*ImportTapscriptRequest_FullTree); ok {
			return x.FullTree
		}
	}
	return nil
}

func (x *ImportTapscriptRequest) GetPartialReveal() *TapscriptPartialReveal {
	if x != nil {
		if x, ok := x.Script.(*ImportTapscriptRequest_PartialReveal); ok {
			return x.PartialReveal
		}
	}
	return nil
}

func (x *ImportTapscriptRequest) GetRootHashOnly() []byte {
	if x != nil {
		if x, ok := x.Script.(*ImportTapscriptRequest_RootHashOnly); ok {
			return x.RootHashOnly
		}
	}
	return nil
}

func (x *ImportTapscriptRequest) GetFullKeyOnly() bool {
	if x != nil {
		if x, ok := x.Script.(*ImportTapscriptRequest_FullKeyOnly); ok {
			return x.FullKeyOnly
		}
	}
	return false
}

type isImportTapscriptRequest_Script interface {
	isImportTapscriptRequest_Script()
}

type ImportTapscriptRequest_FullTree struct {
	// The full script tree with all individual leaves is known and the root
	// hash can be constructed from the full tree directly.
	FullTree *TapscriptFullTree `protobuf:"bytes,2,opt,name=full_tree,json=fullTree,proto3,oneof"`
}

type ImportTapscriptRequest_PartialReveal struct {
	// Only a single script leaf is known. To construct the root hash, the full
	// inclusion proof must also be provided.
	PartialReveal *TapscriptPartialReveal `protobuf:"bytes,3,opt,name=partial_reveal,json=partialReveal,proto3,oneof"`
}

type ImportTapscriptRequest_RootHashOnly struct {
	// Only the root hash of the Taproot script tree (or other form of Taproot
	// commitment) is known.
	RootHashOnly []byte `protobuf:"bytes,4,opt,name=root_hash_only,json=rootHashOnly,proto3,oneof"`
}

type ImportTapscriptRequest_FullKeyOnly struct {
	// Only the final, tweaked Taproot key is known and no additional
	// information about the internal key or type of tweak that was used to
	// derive it. When this is set, the wallet treats the key in
	// internal_public_key as the Taproot key directly. This can be useful for
	// tracking arbitrary Taproot outputs without the goal of ever being able
	// to spend from them through the internal wallet.
	FullKeyOnly bool `protobuf:"varint,5,opt,name=full_key_only,json=fullKeyOnly,proto3,oneof"`
}

func (*ImportTapscriptRequest_FullTree) isImportTapscriptRequest_Script() {}

func (*ImportTapscriptRequest_PartialReveal) isImportTapscriptRequest_Script() {}

func (*ImportTapscriptRequest_RootHashOnly) isImportTapscriptRequest_Script() {}

func (*ImportTapscriptRequest_FullKeyOnly) isImportTapscriptRequest_Script() {}

type TapscriptFullTree struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The complete, ordered list of all tap leaves of the tree.
	AllLeaves     []*TapLeaf `protobuf:"bytes,1,rep,name=all_leaves,json=allLeaves,proto3" json:"all_leaves,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TapscriptFullTree) Reset() {
	*x = TapscriptFullTree{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TapscriptFullTree) ProtoMessage() {}

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

func (x *TapscriptFullTree) GetAllLeaves() []*TapLeaf {
	if x != nil {
		return x.AllLeaves
	}
	return nil
}

type TapLeaf struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The leaf version. Should be 0xc0 (192) in case of a SegWit v1 script.
	LeafVersion uint32 `protobuf:"varint,1,opt,name=leaf_version,json=leafVersion,proto3" json:"leaf_version,omitempty"`
	// The script of the tap leaf.
	Script        []byte `protobuf:"bytes,2,opt,name=script,proto3" json:"script,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TapLeaf) Reset() {
	*x = TapLeaf{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[29]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TapLeaf) ProtoMessage() {}

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

func (x *TapLeaf) GetLeafVersion() uint32 {
	if x != nil {
		return x.LeafVersion
	}
	return 0
}

func (x *TapLeaf) GetScript() []byte {
	if x != nil {
		return x.Script
	}
	return nil
}

type TapscriptPartialReveal struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The tap leaf that is known and will be revealed.
	RevealedLeaf *TapLeaf `protobuf:"bytes,1,opt,name=revealed_leaf,json=revealedLeaf,proto3" json:"revealed_leaf,omitempty"`
	// The BIP-0341 serialized inclusion proof that is required to prove that
	// the revealed leaf is part of the tree. This contains 0..n blocks of 32
	// bytes. If the tree only contained a single leaf (which is the revealed
	// leaf), this can be empty.
	FullInclusionProof []byte `protobuf:"bytes,2,opt,name=full_inclusion_proof,json=fullInclusionProof,proto3" json:"full_inclusion_proof,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *TapscriptPartialReveal) Reset() {
	*x = TapscriptPartialReveal{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TapscriptPartialReveal) ProtoMessage() {}

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

func (x *TapscriptPartialReveal) GetRevealedLeaf() *TapLeaf {
	if x != nil {
		return x.RevealedLeaf
	}
	return nil
}

func (x *TapscriptPartialReveal) GetFullInclusionProof() []byte {
	if x != nil {
		return x.FullInclusionProof
	}
	return nil
}

type ImportTapscriptResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The resulting pay-to-Taproot address that represents the imported internal
	// key with the script committed to it.
	P2TrAddress   string `protobuf:"bytes,1,opt,name=p2tr_address,json=p2trAddress,proto3" json:"p2tr_address,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ImportTapscriptResponse) Reset() {
	*x = ImportTapscriptResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[31]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ImportTapscriptResponse) ProtoMessage() {}

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

func (x *ImportTapscriptResponse) GetP2TrAddress() string {
	if x != nil {
		return x.P2TrAddress
	}
	return ""
}

type Transaction struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The raw serialized transaction. Despite the field name, this does need to be
	// specified in raw bytes (or base64 encoded when using REST) and not in hex.
	// To not break existing software, the field can't simply be renamed.
	TxHex []byte `protobuf:"bytes,1,opt,name=tx_hex,json=txHex,proto3" json:"tx_hex,omitempty"`
	// An optional label to save with the transaction. Limited to 500 characters.
	Label         string `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Transaction) Reset() {
	*x = Transaction{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[32]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Transaction) ProtoMessage() {}

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

func (x *Transaction) GetTxHex() []byte {
	if x != nil {
		return x.TxHex
	}
	return nil
}

func (x *Transaction) GetLabel() string {
	if x != nil {
		return x.Label
	}
	return ""
}

type PublishResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// If blank, then no error occurred and the transaction was successfully
	// published. If not the empty string, then a string representation of the
	// broadcast error.
	//
	// TODO(roasbeef): map to a proper enum type
	PublishError  string `protobuf:"bytes,1,opt,name=publish_error,json=publishError,proto3" json:"publish_error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PublishResponse) Reset() {
	*x = PublishResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[33]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PublishResponse) ProtoMessage() {}

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

func (x *PublishResponse) GetPublishError() string {
	if x != nil {
		return x.PublishError
	}
	return ""
}

type SubmitPackageRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The raw serialized transactions forming the package, topologically sorted
	// with unconfirmed parents first and the child last.
	RawTxs [][]byte `protobuf:"bytes,1,rep,name=raw_txs,json=rawTxs,proto3" json:"raw_txs,omitempty"`
	// Optional per-transaction fee-rate ceiling in sat/vByte (mapped onto the
	// submitpackage maxfeerate). When unset the node's default is used; an
	// explicit 0 means no limit, which is required for a CPFP child whose
	// standalone feerate is high.
	SatPerVbyte   *uint64 `protobuf:"varint,2,opt,name=sat_per_vbyte,json=satPerVbyte,proto3,oneof" json:"sat_per_vbyte,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SubmitPackageRequest) Reset() {
	*x = SubmitPackageRequest{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[34]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SubmitPackageRequest) ProtoMessage() {}

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

func (x *SubmitPackageRequest) GetRawTxs() [][]byte {
	if x != nil {
		return x.RawTxs
	}
	return nil
}

func (x *SubmitPackageRequest) GetSatPerVbyte() uint64 {
	if x != nil && x.SatPerVbyte != nil {
		return *x.SatPerVbyte
	}
	return 0
}

type SubmitPackageTxResult struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The transaction id (txid) in hex.
	Txid string `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"`
	// If non-empty, the reason this transaction was rejected.
	Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	// If non-empty, the wtxid (in hex) of a transaction with the same txid but a
	// different witness that was already in the mempool; the submitted
	// transaction was ignored as a duplicate (witness replacement).
	OtherWtxid    string `protobuf:"bytes,3,opt,name=other_wtxid,json=otherWtxid,proto3" json:"other_wtxid,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SubmitPackageTxResult) Reset() {
	*x = SubmitPackageTxResult{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[35]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SubmitPackageTxResult) ProtoMessage() {}

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

func (x *SubmitPackageTxResult) GetTxid() string {
	if x != nil {
		return x.Txid
	}
	return ""
}

func (x *SubmitPackageTxResult) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

func (x *SubmitPackageTxResult) GetOtherWtxid() string {
	if x != nil {
		return x.OtherWtxid
	}
	return ""
}

type SubmitPackageResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A summary message; "success" when the whole package was accepted.
	PackageMsg string `protobuf:"bytes,1,opt,name=package_msg,json=packageMsg,proto3" json:"package_msg,omitempty"`
	// Per-transaction results keyed by wtxid (hex).
	TxResults map[string]*SubmitPackageTxResult `protobuf:"bytes,2,rep,name=tx_results,json=txResults,proto3" json:"tx_results,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// The txids of transactions evicted via package RBF.
	ReplacedTransactions []string `protobuf:"bytes,3,rep,name=replaced_transactions,json=replacedTransactions,proto3" json:"replaced_transactions,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

func (x *SubmitPackageResponse) Reset() {
	*x = SubmitPackageResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[36]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SubmitPackageResponse) ProtoMessage() {}

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

func (x *SubmitPackageResponse) GetPackageMsg() string {
	if x != nil {
		return x.PackageMsg
	}
	return ""
}

func (x *SubmitPackageResponse) GetTxResults() map[string]*SubmitPackageTxResult {
	if x != nil {
		return x.TxResults
	}
	return nil
}

func (x *SubmitPackageResponse) GetReplacedTransactions() []string {
	if x != nil {
		return x.ReplacedTransactions
	}
	return nil
}

type RemoveTransactionResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The status of the remove transaction operation.
	Status        string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RemoveTransactionResponse) Reset() {
	*x = RemoveTransactionResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[37]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*RemoveTransactionResponse) ProtoMessage() {}

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

func (x *RemoveTransactionResponse) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

type SendOutputsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The number of satoshis per kilo weight that should be used when crafting
	// this transaction.
	SatPerKw int64 `protobuf:"varint,1,opt,name=sat_per_kw,json=satPerKw,proto3" json:"sat_per_kw,omitempty"`
	// A slice of the outputs that should be created in the transaction produced.
	Outputs []*signrpc.TxOut `protobuf:"bytes,2,rep,name=outputs,proto3" json:"outputs,omitempty"`
	// An optional label for the transaction, limited to 500 characters.
	Label string `protobuf:"bytes,3,opt,name=label,proto3" json:"label,omitempty"`
	// The minimum number of confirmations each one of your outputs used for
	// the transaction must satisfy.
	MinConfs int32 `protobuf:"varint,4,opt,name=min_confs,json=minConfs,proto3" json:"min_confs,omitempty"`
	// Whether unconfirmed outputs should be used as inputs for the transaction.
	SpendUnconfirmed bool `protobuf:"varint,5,opt,name=spend_unconfirmed,json=spendUnconfirmed,proto3" json:"spend_unconfirmed,omitempty"`
	// The strategy to use for selecting coins during sending the outputs.
	CoinSelectionStrategy lnrpc.CoinSelectionStrategy `protobuf:"varint,6,opt,name=coin_selection_strategy,json=coinSelectionStrategy,proto3,enum=lnrpc.CoinSelectionStrategy" json:"coin_selection_strategy,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *SendOutputsRequest) Reset() {
	*x = SendOutputsRequest{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[38]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SendOutputsRequest) ProtoMessage() {}

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

func (x *SendOutputsRequest) GetSatPerKw() int64 {
	if x != nil {
		return x.SatPerKw
	}
	return 0
}

func (x *SendOutputsRequest) GetOutputs() []*signrpc.TxOut {
	if x != nil {
		return x.Outputs
	}
	return nil
}

func (x *SendOutputsRequest) GetLabel() string {
	if x != nil {
		return x.Label
	}
	return ""
}

func (x *SendOutputsRequest) GetMinConfs() int32 {
	if x != nil {
		return x.MinConfs
	}
	return 0
}

func (x *SendOutputsRequest) GetSpendUnconfirmed() bool {
	if x != nil {
		return x.SpendUnconfirmed
	}
	return false
}

func (x *SendOutputsRequest) GetCoinSelectionStrategy() lnrpc.CoinSelectionStrategy {
	if x != nil {
		return x.CoinSelectionStrategy
	}
	return lnrpc.CoinSelectionStrategy(0)
}

type SendOutputsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The serialized transaction sent out on the network.
	RawTx         []byte `protobuf:"bytes,1,opt,name=raw_tx,json=rawTx,proto3" json:"raw_tx,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SendOutputsResponse) Reset() {
	*x = SendOutputsResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[39]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SendOutputsResponse) ProtoMessage() {}

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

func (x *SendOutputsResponse) GetRawTx() []byte {
	if x != nil {
		return x.RawTx
	}
	return nil
}

type EstimateFeeRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The number of confirmations to shoot for when estimating the fee.
	ConfTarget    int32 `protobuf:"varint,1,opt,name=conf_target,json=confTarget,proto3" json:"conf_target,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *EstimateFeeRequest) Reset() {
	*x = EstimateFeeRequest{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[40]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*EstimateFeeRequest) ProtoMessage() {}

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

func (x *EstimateFeeRequest) GetConfTarget() int32 {
	if x != nil {
		return x.ConfTarget
	}
	return 0
}

type EstimateFeeResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The amount of satoshis per kw that should be used in order to reach the
	// confirmation target in the request.
	SatPerKw int64 `protobuf:"varint,1,opt,name=sat_per_kw,json=satPerKw,proto3" json:"sat_per_kw,omitempty"`
	// The current minimum relay fee based on our chain backend in sat/kw.
	MinRelayFeeSatPerKw int64 `protobuf:"varint,2,opt,name=min_relay_fee_sat_per_kw,json=minRelayFeeSatPerKw,proto3" json:"min_relay_fee_sat_per_kw,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *EstimateFeeResponse) Reset() {
	*x = EstimateFeeResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[41]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*EstimateFeeResponse) ProtoMessage() {}

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

func (x *EstimateFeeResponse) GetSatPerKw() int64 {
	if x != nil {
		return x.SatPerKw
	}
	return 0
}

func (x *EstimateFeeResponse) GetMinRelayFeeSatPerKw() int64 {
	if x != nil {
		return x.MinRelayFeeSatPerKw
	}
	return 0
}

type PendingSweep struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The outpoint of the output we're attempting to sweep.
	Outpoint *lnrpc.OutPoint `protobuf:"bytes,1,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	// The witness type of the output we're attempting to sweep.
	WitnessType WitnessType `protobuf:"varint,2,opt,name=witness_type,json=witnessType,proto3,enum=walletrpc.WitnessType" json:"witness_type,omitempty"`
	// The value of the output we're attempting to sweep.
	AmountSat uint32 `protobuf:"varint,3,opt,name=amount_sat,json=amountSat,proto3" json:"amount_sat,omitempty"`
	// Deprecated, use sat_per_vbyte.
	// The fee rate we'll use to sweep the output, expressed in sat/vbyte. The fee
	// rate is only determined once a sweeping transaction for the output is
	// created, so it's possible for this to be 0 before this.
	//
	// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
	SatPerByte uint32 `protobuf:"varint,4,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"`
	// The number of broadcast attempts we've made to sweep the output.
	BroadcastAttempts uint32 `protobuf:"varint,5,opt,name=broadcast_attempts,json=broadcastAttempts,proto3" json:"broadcast_attempts,omitempty"`
	// Deprecated.
	// The next height of the chain at which we'll attempt to broadcast the
	// sweep transaction of the output.
	//
	// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
	NextBroadcastHeight uint32 `protobuf:"varint,6,opt,name=next_broadcast_height,json=nextBroadcastHeight,proto3" json:"next_broadcast_height,omitempty"`
	// Deprecated, use immediate.
	// Whether this input must be force-swept. This means that it is swept
	// immediately.
	//
	// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
	Force bool `protobuf:"varint,7,opt,name=force,proto3" json:"force,omitempty"`
	// Deprecated, use deadline.
	// The requested confirmation target for this output, which is the deadline
	// used by the sweeper.
	//
	// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
	RequestedConfTarget uint32 `protobuf:"varint,8,opt,name=requested_conf_target,json=requestedConfTarget,proto3" json:"requested_conf_target,omitempty"`
	// Deprecated, use requested_sat_per_vbyte.
	// The requested fee rate, expressed in sat/vbyte, for this output.
	//
	// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
	RequestedSatPerByte uint32 `protobuf:"varint,9,opt,name=requested_sat_per_byte,json=requestedSatPerByte,proto3" json:"requested_sat_per_byte,omitempty"`
	// The current fee rate we'll use to sweep the output, expressed in sat/vbyte.
	// The fee rate is only determined once a sweeping transaction for the output
	// is created, so it's possible for this to be 0 before this.
	SatPerVbyte uint64 `protobuf:"varint,10,opt,name=sat_per_vbyte,json=satPerVbyte,proto3" json:"sat_per_vbyte,omitempty"`
	// The requested starting fee rate, expressed in sat/vbyte, for this
	// output. When not requested, this field will be 0.
	RequestedSatPerVbyte uint64 `protobuf:"varint,11,opt,name=requested_sat_per_vbyte,json=requestedSatPerVbyte,proto3" json:"requested_sat_per_vbyte,omitempty"`
	// Whether this input will be swept immediately.
	Immediate bool `protobuf:"varint,12,opt,name=immediate,proto3" json:"immediate,omitempty"`
	// The budget for this sweep, expressed in satoshis. This is the maximum amount
	// that can be spent as fees to sweep this output.
	Budget uint64 `protobuf:"varint,13,opt,name=budget,proto3" json:"budget,omitempty"`
	// The deadline height used for this output when perform fee bumping.
	DeadlineHeight uint32 `protobuf:"varint,14,opt,name=deadline_height,json=deadlineHeight,proto3" json:"deadline_height,omitempty"`
	// The block height which the input's locktime will expire at. Zero if the
	// input has no locktime.
	MaturityHeight uint32 `protobuf:"varint,15,opt,name=maturity_height,json=maturityHeight,proto3" json:"maturity_height,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *PendingSweep) Reset() {
	*x = PendingSweep{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[42]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PendingSweep) ProtoMessage() {}

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

func (x *PendingSweep) GetOutpoint() *lnrpc.OutPoint {
	if x != nil {
		return x.Outpoint
	}
	return nil
}

func (x *PendingSweep) GetWitnessType() WitnessType {
	if x != nil {
		return x.WitnessType
	}
	return WitnessType_UNKNOWN_WITNESS
}

func (x *PendingSweep) GetAmountSat() uint32 {
	if x != nil {
		return x.AmountSat
	}
	return 0
}

// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
func (x *PendingSweep) GetSatPerByte() uint32 {
	if x != nil {
		return x.SatPerByte
	}
	return 0
}

func (x *PendingSweep) GetBroadcastAttempts() uint32 {
	if x != nil {
		return x.BroadcastAttempts
	}
	return 0
}

// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
func (x *PendingSweep) GetNextBroadcastHeight() uint32 {
	if x != nil {
		return x.NextBroadcastHeight
	}
	return 0
}

// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
func (x *PendingSweep) GetForce() bool {
	if x != nil {
		return x.Force
	}
	return false
}

// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
func (x *PendingSweep) GetRequestedConfTarget() uint32 {
	if x != nil {
		return x.RequestedConfTarget
	}
	return 0
}

// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
func (x *PendingSweep) GetRequestedSatPerByte() uint32 {
	if x != nil {
		return x.RequestedSatPerByte
	}
	return 0
}

func (x *PendingSweep) GetSatPerVbyte() uint64 {
	if x != nil {
		return x.SatPerVbyte
	}
	return 0
}

func (x *PendingSweep) GetRequestedSatPerVbyte() uint64 {
	if x != nil {
		return x.RequestedSatPerVbyte
	}
	return 0
}

func (x *PendingSweep) GetImmediate() bool {
	if x != nil {
		return x.Immediate
	}
	return false
}

func (x *PendingSweep) GetBudget() uint64 {
	if x != nil {
		return x.Budget
	}
	return 0
}

func (x *PendingSweep) GetDeadlineHeight() uint32 {
	if x != nil {
		return x.DeadlineHeight
	}
	return 0
}

func (x *PendingSweep) GetMaturityHeight() uint32 {
	if x != nil {
		return x.MaturityHeight
	}
	return 0
}

type PendingSweepsRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PendingSweepsRequest) Reset() {
	*x = PendingSweepsRequest{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[43]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PendingSweepsRequest) ProtoMessage() {}

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

type PendingSweepsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The set of outputs currently being swept by lnd's central batching engine.
	PendingSweeps []*PendingSweep `protobuf:"bytes,1,rep,name=pending_sweeps,json=pendingSweeps,proto3" json:"pending_sweeps,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PendingSweepsResponse) Reset() {
	*x = PendingSweepsResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[44]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PendingSweepsResponse) ProtoMessage() {}

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

func (x *PendingSweepsResponse) GetPendingSweeps() []*PendingSweep {
	if x != nil {
		return x.PendingSweeps
	}
	return nil
}

type BumpFeeRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The input we're attempting to bump the fee of.
	Outpoint *lnrpc.OutPoint `protobuf:"bytes,1,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	// Optional. The conf target the underlying fee estimator will use to
	// estimate the starting fee rate for the fee function.
	TargetConf uint32 `protobuf:"varint,2,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"`
	// Deprecated, use sat_per_vbyte.
	// The fee rate, expressed in sat/vbyte, that should be used to spend the input
	// with.
	//
	// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
	SatPerByte uint32 `protobuf:"varint,3,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"`
	// Deprecated, use immediate.
	// Whether this input must be force-swept. This means that it is swept
	// immediately.
	//
	// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
	Force bool `protobuf:"varint,4,opt,name=force,proto3" json:"force,omitempty"`
	// Optional. The starting fee rate, expressed in sat/vbyte, that will be used
	// to spend the input with initially. This value will be used by the sweeper's
	// fee function as its starting fee rate. When not set, the sweeper will use
	// the estimated fee rate using the `target_conf` as the starting fee rate.
	SatPerVbyte uint64 `protobuf:"varint,5,opt,name=sat_per_vbyte,json=satPerVbyte,proto3" json:"sat_per_vbyte,omitempty"`
	// Optional. Whether this input will be swept immediately. When set to true,
	// the sweeper will sweep this input without waiting for the next block.
	Immediate bool `protobuf:"varint,6,opt,name=immediate,proto3" json:"immediate,omitempty"`
	// Optional. The max amount in sats that can be used as the fees. Setting this
	// value greater than the input's value may result in CPFP - one or more wallet
	// utxos will be used to pay the fees specified by the budget. If not set, for
	// new inputs, by default 50% of the input's value will be treated as the
	// budget for fee bumping; for existing inputs, their current budgets will be
	// retained.
	Budget uint64 `protobuf:"varint,7,opt,name=budget,proto3" json:"budget,omitempty"`
	// Optional. The deadline delta in number of blocks that the output
	// should be spent within. This translates internally to the width of the
	// fee function that the sweeper will use to bump the fee rate. When the
	// deadline is reached, ALL the budget will be spent as fees.
	DeadlineDelta uint32 `protobuf:"varint,8,opt,name=deadline_delta,json=deadlineDelta,proto3" json:"deadline_delta,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BumpFeeRequest) Reset() {
	*x = BumpFeeRequest{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[45]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BumpFeeRequest) ProtoMessage() {}

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

func (x *BumpFeeRequest) GetOutpoint() *lnrpc.OutPoint {
	if x != nil {
		return x.Outpoint
	}
	return nil
}

func (x *BumpFeeRequest) GetTargetConf() uint32 {
	if x != nil {
		return x.TargetConf
	}
	return 0
}

// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
func (x *BumpFeeRequest) GetSatPerByte() uint32 {
	if x != nil {
		return x.SatPerByte
	}
	return 0
}

// Deprecated: Marked as deprecated in walletrpc/walletkit.proto.
func (x *BumpFeeRequest) GetForce() bool {
	if x != nil {
		return x.Force
	}
	return false
}

func (x *BumpFeeRequest) GetSatPerVbyte() uint64 {
	if x != nil {
		return x.SatPerVbyte
	}
	return 0
}

func (x *BumpFeeRequest) GetImmediate() bool {
	if x != nil {
		return x.Immediate
	}
	return false
}

func (x *BumpFeeRequest) GetBudget() uint64 {
	if x != nil {
		return x.Budget
	}
	return 0
}

func (x *BumpFeeRequest) GetDeadlineDelta() uint32 {
	if x != nil {
		return x.DeadlineDelta
	}
	return 0
}

type BumpFeeResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The status of the bump fee operation.
	Status        string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BumpFeeResponse) Reset() {
	*x = BumpFeeResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[46]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BumpFeeResponse) ProtoMessage() {}

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

func (x *BumpFeeResponse) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

type BumpForceCloseFeeRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The channel point which force close transaction we are attempting to
	// bump the fee rate for.
	ChanPoint *lnrpc.ChannelPoint `protobuf:"bytes,1,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"`
	// Optional. The deadline delta in number of blocks that the anchor output
	// should be spent within to bump the closing transaction. When the
	// deadline is reached, ALL the budget will be spent as fees
	DeadlineDelta uint32 `protobuf:"varint,2,opt,name=deadline_delta,json=deadlineDelta,proto3" json:"deadline_delta,omitempty"`
	// Optional. The starting fee rate, expressed in sat/vbyte. This value will be
	// used by the sweeper's fee function as its starting fee rate. When not set,
	// the sweeper will use the estimated fee rate using the target_conf as the
	// starting fee rate.
	StartingFeerate uint64 `protobuf:"varint,3,opt,name=starting_feerate,json=startingFeerate,proto3" json:"starting_feerate,omitempty"`
	// Optional. Whether this cpfp transaction will be triggered immediately. When
	// set to true, the sweeper will consider all currently registered sweeps and
	// trigger new batch transactions including the sweeping of the anchor output
	// related to the selected force close transaction.
	Immediate bool `protobuf:"varint,4,opt,name=immediate,proto3" json:"immediate,omitempty"`
	// Optional. The max amount in sats that can be used as the fees. For already
	// registered anchor outputs if not set explicitly the old value will be used.
	// For channel force closes which have no HTLCs in their commitment transaction
	// this value has to be set to an appropriate amount to pay for the cpfp
	// transaction of the force closed channel otherwise the fee bumping will fail.
	Budget uint64 `protobuf:"varint,5,opt,name=budget,proto3" json:"budget,omitempty"`
	// Optional. The conf target the underlying fee estimator will use to
	// estimate the starting fee rate for the fee function.
	TargetConf    uint32 `protobuf:"varint,6,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BumpForceCloseFeeRequest) Reset() {
	*x = BumpForceCloseFeeRequest{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[47]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BumpForceCloseFeeRequest) ProtoMessage() {}

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

func (x *BumpForceCloseFeeRequest) GetChanPoint() *lnrpc.ChannelPoint {
	if x != nil {
		return x.ChanPoint
	}
	return nil
}

func (x *BumpForceCloseFeeRequest) GetDeadlineDelta() uint32 {
	if x != nil {
		return x.DeadlineDelta
	}
	return 0
}

func (x *BumpForceCloseFeeRequest) GetStartingFeerate() uint64 {
	if x != nil {
		return x.StartingFeerate
	}
	return 0
}

func (x *BumpForceCloseFeeRequest) GetImmediate() bool {
	if x != nil {
		return x.Immediate
	}
	return false
}

func (x *BumpForceCloseFeeRequest) GetBudget() uint64 {
	if x != nil {
		return x.Budget
	}
	return 0
}

func (x *BumpForceCloseFeeRequest) GetTargetConf() uint32 {
	if x != nil {
		return x.TargetConf
	}
	return 0
}

type BumpForceCloseFeeResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The status of the force close fee bump operation.
	Status        string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BumpForceCloseFeeResponse) Reset() {
	*x = BumpForceCloseFeeResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[48]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BumpForceCloseFeeResponse) ProtoMessage() {}

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

func (x *BumpForceCloseFeeResponse) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

type ListSweepsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Retrieve the full sweep transaction details. If false, only the sweep txids
	// will be returned. Note that some sweeps that LND publishes will have been
	// replaced-by-fee, so will not be included in this output.
	Verbose bool `protobuf:"varint,1,opt,name=verbose,proto3" json:"verbose,omitempty"`
	// The start height to use when fetching sweeps. If not specified (0), the
	// result will start from the earliest sweep. If set to -1 the result will
	// only include unconfirmed sweeps (at the time of the call).
	StartHeight   int32 `protobuf:"varint,2,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListSweepsRequest) Reset() {
	*x = ListSweepsRequest{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[49]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListSweepsRequest) ProtoMessage() {}

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

func (x *ListSweepsRequest) GetVerbose() bool {
	if x != nil {
		return x.Verbose
	}
	return false
}

func (x *ListSweepsRequest) GetStartHeight() int32 {
	if x != nil {
		return x.StartHeight
	}
	return 0
}

type ListSweepsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Sweeps:
	//
	//	*ListSweepsResponse_TransactionDetails
	//	*ListSweepsResponse_TransactionIds
	Sweeps        isListSweepsResponse_Sweeps `protobuf_oneof:"sweeps"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListSweepsResponse) Reset() {
	*x = ListSweepsResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[50]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListSweepsResponse) ProtoMessage() {}

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

func (x *ListSweepsResponse) GetSweeps() isListSweepsResponse_Sweeps {
	if x != nil {
		return x.Sweeps
	}
	return nil
}

func (x *ListSweepsResponse) GetTransactionDetails() *lnrpc.TransactionDetails {
	if x != nil {
		if x, ok := x.Sweeps.(*ListSweepsResponse_TransactionDetails); ok {
			return x.TransactionDetails
		}
	}
	return nil
}

func (x *ListSweepsResponse) GetTransactionIds() *ListSweepsResponse_TransactionIDs {
	if x != nil {
		if x, ok := x.Sweeps.(*ListSweepsResponse_TransactionIds); ok {
			return x.TransactionIds
		}
	}
	return nil
}

type isListSweepsResponse_Sweeps interface {
	isListSweepsResponse_Sweeps()
}

type ListSweepsResponse_TransactionDetails struct {
	TransactionDetails *lnrpc.TransactionDetails `protobuf:"bytes,1,opt,name=transaction_details,json=transactionDetails,proto3,oneof"`
}

type ListSweepsResponse_TransactionIds struct {
	TransactionIds *ListSweepsResponse_TransactionIDs `protobuf:"bytes,2,opt,name=transaction_ids,json=transactionIds,proto3,oneof"`
}

func (*ListSweepsResponse_TransactionDetails) isListSweepsResponse_Sweeps() {}

func (*ListSweepsResponse_TransactionIds) isListSweepsResponse_Sweeps() {}

type LabelTransactionRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The txid of the transaction to label. Note: When using gRPC, the bytes
	// must be in little-endian (reverse) order.
	Txid []byte `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"`
	// The label to add to the transaction, limited to 500 characters.
	Label string `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty"`
	// Whether to overwrite the existing label, if it is present.
	Overwrite     bool `protobuf:"varint,3,opt,name=overwrite,proto3" json:"overwrite,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *LabelTransactionRequest) Reset() {
	*x = LabelTransactionRequest{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[51]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*LabelTransactionRequest) ProtoMessage() {}

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

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

func (x *LabelTransactionRequest) GetLabel() string {
	if x != nil {
		return x.Label
	}
	return ""
}

func (x *LabelTransactionRequest) GetOverwrite() bool {
	if x != nil {
		return x.Overwrite
	}
	return false
}

type LabelTransactionResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The status of the label operation.
	Status        string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *LabelTransactionResponse) Reset() {
	*x = LabelTransactionResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[52]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*LabelTransactionResponse) ProtoMessage() {}

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

func (x *LabelTransactionResponse) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

type FundPsbtRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Template:
	//
	//	*FundPsbtRequest_Psbt
	//	*FundPsbtRequest_Raw
	//	*FundPsbtRequest_CoinSelect
	Template isFundPsbtRequest_Template `protobuf_oneof:"template"`
	// Types that are valid to be assigned to Fees:
	//
	//	*FundPsbtRequest_TargetConf
	//	*FundPsbtRequest_SatPerVbyte
	//	*FundPsbtRequest_SatPerKw
	Fees isFundPsbtRequest_Fees `protobuf_oneof:"fees"`
	// The name of the account to fund the PSBT with. If empty, the default wallet
	// account is used.
	Account string `protobuf:"bytes,5,opt,name=account,proto3" json:"account,omitempty"`
	// The minimum number of confirmations each one of your outputs used for
	// the transaction must satisfy.
	MinConfs int32 `protobuf:"varint,6,opt,name=min_confs,json=minConfs,proto3" json:"min_confs,omitempty"`
	// Whether unconfirmed outputs should be used as inputs for the transaction.
	SpendUnconfirmed bool `protobuf:"varint,7,opt,name=spend_unconfirmed,json=spendUnconfirmed,proto3" json:"spend_unconfirmed,omitempty"`
	// The address type for the change. If empty, P2WPKH addresses will be used
	// for default accounts and single imported public keys. For custom
	// accounts, no change type should be provided as the coin selection key
	// scope will always be used to generate the change address.
	ChangeType ChangeAddressType `protobuf:"varint,8,opt,name=change_type,json=changeType,proto3,enum=walletrpc.ChangeAddressType" json:"change_type,omitempty"`
	// The strategy to use for selecting coins during funding the PSBT.
	CoinSelectionStrategy lnrpc.CoinSelectionStrategy `protobuf:"varint,10,opt,name=coin_selection_strategy,json=coinSelectionStrategy,proto3,enum=lnrpc.CoinSelectionStrategy" json:"coin_selection_strategy,omitempty"`
	// The max fee to total output amount ratio that this psbt should adhere to.
	MaxFeeRatio float64 `protobuf:"fixed64,12,opt,name=max_fee_ratio,json=maxFeeRatio,proto3" json:"max_fee_ratio,omitempty"`
	// The custom lock ID to use for the inputs in the funded PSBT. The value
	// if set must be exactly 32 bytes long. If empty, the default lock ID will
	// be used.
	CustomLockId []byte `protobuf:"bytes,13,opt,name=custom_lock_id,json=customLockId,proto3" json:"custom_lock_id,omitempty"`
	// If set, then the inputs in the funded PSBT will be locked for the
	// specified duration. The lock duration is specified in seconds. If not
	// set, the default lock duration will be used.
	LockExpirationSeconds uint64 `protobuf:"varint,14,opt,name=lock_expiration_seconds,json=lockExpirationSeconds,proto3" json:"lock_expiration_seconds,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *FundPsbtRequest) Reset() {
	*x = FundPsbtRequest{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[53]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FundPsbtRequest) ProtoMessage() {}

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

func (x *FundPsbtRequest) GetTemplate() isFundPsbtRequest_Template {
	if x != nil {
		return x.Template
	}
	return nil
}

func (x *FundPsbtRequest) GetPsbt() []byte {
	if x != nil {
		if x, ok := x.Template.(*FundPsbtRequest_Psbt); ok {
			return x.Psbt
		}
	}
	return nil
}

func (x *FundPsbtRequest) GetRaw() *TxTemplate {
	if x != nil {
		if x, ok := x.Template.(*FundPsbtRequest_Raw); ok {
			return x.Raw
		}
	}
	return nil
}

func (x *FundPsbtRequest) GetCoinSelect() *PsbtCoinSelect {
	if x != nil {
		if x, ok := x.Template.(*FundPsbtRequest_CoinSelect); ok {
			return x.CoinSelect
		}
	}
	return nil
}

func (x *FundPsbtRequest) GetFees() isFundPsbtRequest_Fees {
	if x != nil {
		return x.Fees
	}
	return nil
}

func (x *FundPsbtRequest) GetTargetConf() uint32 {
	if x != nil {
		if x, ok := x.Fees.(*FundPsbtRequest_TargetConf); ok {
			return x.TargetConf
		}
	}
	return 0
}

func (x *FundPsbtRequest) GetSatPerVbyte() uint64 {
	if x != nil {
		if x, ok := x.Fees.(*FundPsbtRequest_SatPerVbyte); ok {
			return x.SatPerVbyte
		}
	}
	return 0
}

func (x *FundPsbtRequest) GetSatPerKw() uint64 {
	if x != nil {
		if x, ok := x.Fees.(*FundPsbtRequest_SatPerKw); ok {
			return x.SatPerKw
		}
	}
	return 0
}

func (x *FundPsbtRequest) GetAccount() string {
	if x != nil {
		return x.Account
	}
	return ""
}

func (x *FundPsbtRequest) GetMinConfs() int32 {
	if x != nil {
		return x.MinConfs
	}
	return 0
}

func (x *FundPsbtRequest) GetSpendUnconfirmed() bool {
	if x != nil {
		return x.SpendUnconfirmed
	}
	return false
}

func (x *FundPsbtRequest) GetChangeType() ChangeAddressType {
	if x != nil {
		return x.ChangeType
	}
	return ChangeAddressType_CHANGE_ADDRESS_TYPE_UNSPECIFIED
}

func (x *FundPsbtRequest) GetCoinSelectionStrategy() lnrpc.CoinSelectionStrategy {
	if x != nil {
		return x.CoinSelectionStrategy
	}
	return lnrpc.CoinSelectionStrategy(0)
}

func (x *FundPsbtRequest) GetMaxFeeRatio() float64 {
	if x != nil {
		return x.MaxFeeRatio
	}
	return 0
}

func (x *FundPsbtRequest) GetCustomLockId() []byte {
	if x != nil {
		return x.CustomLockId
	}
	return nil
}

func (x *FundPsbtRequest) GetLockExpirationSeconds() uint64 {
	if x != nil {
		return x.LockExpirationSeconds
	}
	return 0
}

type isFundPsbtRequest_Template interface {
	isFundPsbtRequest_Template()
}

type FundPsbtRequest_Psbt struct {
	// Use an existing PSBT packet as the template for the funded PSBT.
	//
	// The packet must contain at least one non-dust output. If one or more
	// inputs are specified, no coin selection is performed. In that case every
	// input must be an UTXO known to the wallet that has not been locked
	// before. The sum of all inputs must be sufficiently greater than the sum
	// of all outputs to pay a miner fee with the specified fee rate. A change
	// output is added to the PSBT if necessary.
	Psbt []byte `protobuf:"bytes,1,opt,name=psbt,proto3,oneof"`
}

type FundPsbtRequest_Raw struct {
	// Use the outputs and optional inputs from this raw template.
	Raw *TxTemplate `protobuf:"bytes,2,opt,name=raw,proto3,oneof"`
}

type FundPsbtRequest_CoinSelect struct {
	// Use an existing PSBT packet as the template for the funded PSBT.
	//
	// The difference to the pure PSBT template above is that coin selection is
	// performed even if inputs are specified. The output amounts are summed up
	// and used as the target amount for coin selection. A change output must
	// either already exist in the PSBT and be marked as such, otherwise a new
	// change output of the specified output type will be added. Any inputs
	// already specified in the PSBT must already be locked (if they belong to
	// this node), only newly added inputs will be locked by this RPC.
	//
	// In case the sum of the already provided inputs exceeds the required
	// output amount, no new coins are selected. Instead only the fee and
	// change amount calculation is performed (e.g. a change output is added if
	// requested or the change is added to the specified existing change
	// output, given there is any non-dust change). This can be identified by
	// the returned locked UTXOs being empty.
	CoinSelect *PsbtCoinSelect `protobuf:"bytes,9,opt,name=coin_select,json=coinSelect,proto3,oneof"`
}

func (*FundPsbtRequest_Psbt) isFundPsbtRequest_Template() {}

func (*FundPsbtRequest_Raw) isFundPsbtRequest_Template() {}

func (*FundPsbtRequest_CoinSelect) isFundPsbtRequest_Template() {}

type isFundPsbtRequest_Fees interface {
	isFundPsbtRequest_Fees()
}

type FundPsbtRequest_TargetConf struct {
	// The target number of blocks that the transaction should be confirmed in.
	TargetConf uint32 `protobuf:"varint,3,opt,name=target_conf,json=targetConf,proto3,oneof"`
}

type FundPsbtRequest_SatPerVbyte struct {
	// The fee rate, expressed in sat/vbyte, that should be used to spend the
	// input with.
	SatPerVbyte uint64 `protobuf:"varint,4,opt,name=sat_per_vbyte,json=satPerVbyte,proto3,oneof"`
}

type FundPsbtRequest_SatPerKw struct {
	// The fee rate, expressed in sat/kWU, that should be used to spend the
	// input with.
	SatPerKw uint64 `protobuf:"varint,11,opt,name=sat_per_kw,json=satPerKw,proto3,oneof"`
}

func (*FundPsbtRequest_TargetConf) isFundPsbtRequest_Fees() {}

func (*FundPsbtRequest_SatPerVbyte) isFundPsbtRequest_Fees() {}

func (*FundPsbtRequest_SatPerKw) isFundPsbtRequest_Fees() {}

type FundPsbtResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The funded but not yet signed PSBT packet.
	FundedPsbt []byte `protobuf:"bytes,1,opt,name=funded_psbt,json=fundedPsbt,proto3" json:"funded_psbt,omitempty"`
	// The index of the added change output or -1 if no change was left over.
	ChangeOutputIndex int32 `protobuf:"varint,2,opt,name=change_output_index,json=changeOutputIndex,proto3" json:"change_output_index,omitempty"`
	// The list of lock leases that were acquired for the inputs in the funded PSBT
	// packet. Only inputs added to the PSBT by this RPC are locked, inputs that
	// were already present in the PSBT are not locked.
	LockedUtxos   []*UtxoLease `protobuf:"bytes,3,rep,name=locked_utxos,json=lockedUtxos,proto3" json:"locked_utxos,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FundPsbtResponse) Reset() {
	*x = FundPsbtResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[54]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FundPsbtResponse) ProtoMessage() {}

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

func (x *FundPsbtResponse) GetFundedPsbt() []byte {
	if x != nil {
		return x.FundedPsbt
	}
	return nil
}

func (x *FundPsbtResponse) GetChangeOutputIndex() int32 {
	if x != nil {
		return x.ChangeOutputIndex
	}
	return 0
}

func (x *FundPsbtResponse) GetLockedUtxos() []*UtxoLease {
	if x != nil {
		return x.LockedUtxos
	}
	return nil
}

type TxTemplate struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// An optional list of inputs to use. Every input must be an UTXO known to the
	// wallet that has not been locked before. The sum of all inputs must be
	// sufficiently greater than the sum of all outputs to pay a miner fee with the
	// fee rate specified in the parent message.
	//
	// If no inputs are specified, coin selection will be performed instead and
	// inputs of sufficient value will be added to the resulting PSBT.
	Inputs []*lnrpc.OutPoint `protobuf:"bytes,1,rep,name=inputs,proto3" json:"inputs,omitempty"`
	// A map of all addresses and the amounts to send to in the funded PSBT.
	Outputs       map[string]uint64 `protobuf:"bytes,2,rep,name=outputs,proto3" json:"outputs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TxTemplate) Reset() {
	*x = TxTemplate{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[55]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TxTemplate) ProtoMessage() {}

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

func (x *TxTemplate) GetInputs() []*lnrpc.OutPoint {
	if x != nil {
		return x.Inputs
	}
	return nil
}

func (x *TxTemplate) GetOutputs() map[string]uint64 {
	if x != nil {
		return x.Outputs
	}
	return nil
}

type PsbtCoinSelect struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The template to use for the funded PSBT. The template must contain at least
	// one non-dust output. The amount to be funded is calculated by summing up the
	// amounts of all outputs in the template, subtracting all the input values of
	// the already specified inputs. The change value is added to the output that
	// is marked as such (or a new change output is added if none is marked). For
	// the input amount calculation to be correct, the template must have the
	// WitnessUtxo field set for all inputs. Any inputs already specified in the
	// PSBT must already be locked (if they belong to this node), only newly added
	// inputs will be locked by this RPC.
	Psbt []byte `protobuf:"bytes,1,opt,name=psbt,proto3" json:"psbt,omitempty"`
	// Types that are valid to be assigned to ChangeOutput:
	//
	//	*PsbtCoinSelect_ExistingOutputIndex
	//	*PsbtCoinSelect_Add
	ChangeOutput  isPsbtCoinSelect_ChangeOutput `protobuf_oneof:"change_output"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PsbtCoinSelect) Reset() {
	*x = PsbtCoinSelect{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[56]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PsbtCoinSelect) ProtoMessage() {}

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

func (x *PsbtCoinSelect) GetPsbt() []byte {
	if x != nil {
		return x.Psbt
	}
	return nil
}

func (x *PsbtCoinSelect) GetChangeOutput() isPsbtCoinSelect_ChangeOutput {
	if x != nil {
		return x.ChangeOutput
	}
	return nil
}

func (x *PsbtCoinSelect) GetExistingOutputIndex() int32 {
	if x != nil {
		if x, ok := x.ChangeOutput.(*PsbtCoinSelect_ExistingOutputIndex); ok {
			return x.ExistingOutputIndex
		}
	}
	return 0
}

func (x *PsbtCoinSelect) GetAdd() bool {
	if x != nil {
		if x, ok := x.ChangeOutput.(*PsbtCoinSelect_Add); ok {
			return x.Add
		}
	}
	return false
}

type isPsbtCoinSelect_ChangeOutput interface {
	isPsbtCoinSelect_ChangeOutput()
}

type PsbtCoinSelect_ExistingOutputIndex struct {
	// Use the existing output within the template PSBT with the specified
	// index as the change output. Any leftover change will be added to the
	// already specified amount of that output. To add a new change output to
	// the PSBT, set the "add" field below instead. The type of change output
	// added is defined by change_type in the parent message.
	ExistingOutputIndex int32 `protobuf:"varint,2,opt,name=existing_output_index,json=existingOutputIndex,proto3,oneof"`
}

type PsbtCoinSelect_Add struct {
	// Add a new change output to the PSBT using the change_type specified in
	// the parent message.
	Add bool `protobuf:"varint,3,opt,name=add,proto3,oneof"`
}

func (*PsbtCoinSelect_ExistingOutputIndex) isPsbtCoinSelect_ChangeOutput() {}

func (*PsbtCoinSelect_Add) isPsbtCoinSelect_ChangeOutput() {}

type UtxoLease struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A 32 byte random ID that identifies the lease.
	Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// The identifying outpoint of the output being leased.
	Outpoint *lnrpc.OutPoint `protobuf:"bytes,2,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	// The absolute expiration of the output lease represented as a unix timestamp.
	Expiration uint64 `protobuf:"varint,3,opt,name=expiration,proto3" json:"expiration,omitempty"`
	// The public key script of the leased output.
	PkScript []byte `protobuf:"bytes,4,opt,name=pk_script,json=pkScript,proto3" json:"pk_script,omitempty"`
	// The value of the leased output in satoshis.
	Value         uint64 `protobuf:"varint,5,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UtxoLease) Reset() {
	*x = UtxoLease{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[57]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UtxoLease) ProtoMessage() {}

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

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

func (x *UtxoLease) GetOutpoint() *lnrpc.OutPoint {
	if x != nil {
		return x.Outpoint
	}
	return nil
}

func (x *UtxoLease) GetExpiration() uint64 {
	if x != nil {
		return x.Expiration
	}
	return 0
}

func (x *UtxoLease) GetPkScript() []byte {
	if x != nil {
		return x.PkScript
	}
	return nil
}

func (x *UtxoLease) GetValue() uint64 {
	if x != nil {
		return x.Value
	}
	return 0
}

type SignPsbtRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The PSBT that should be signed. The PSBT must contain all required inputs,
	// outputs, UTXO data and custom fields required to identify the signing key.
	FundedPsbt    []byte `protobuf:"bytes,1,opt,name=funded_psbt,json=fundedPsbt,proto3" json:"funded_psbt,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SignPsbtRequest) Reset() {
	*x = SignPsbtRequest{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[58]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SignPsbtRequest) ProtoMessage() {}

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

func (x *SignPsbtRequest) GetFundedPsbt() []byte {
	if x != nil {
		return x.FundedPsbt
	}
	return nil
}

type SignPsbtResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The signed transaction in PSBT format.
	SignedPsbt []byte `protobuf:"bytes,1,opt,name=signed_psbt,json=signedPsbt,proto3" json:"signed_psbt,omitempty"`
	// The indices of signed inputs.
	SignedInputs  []uint32 `protobuf:"varint,2,rep,packed,name=signed_inputs,json=signedInputs,proto3" json:"signed_inputs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SignPsbtResponse) Reset() {
	*x = SignPsbtResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[59]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SignPsbtResponse) ProtoMessage() {}

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

func (x *SignPsbtResponse) GetSignedPsbt() []byte {
	if x != nil {
		return x.SignedPsbt
	}
	return nil
}

func (x *SignPsbtResponse) GetSignedInputs() []uint32 {
	if x != nil {
		return x.SignedInputs
	}
	return nil
}

type FinalizePsbtRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A PSBT that should be signed and finalized. The PSBT must contain all
	// required inputs, outputs, UTXO data and partial signatures of all other
	// signers.
	FundedPsbt []byte `protobuf:"bytes,1,opt,name=funded_psbt,json=fundedPsbt,proto3" json:"funded_psbt,omitempty"`
	// The name of the account to finalize the PSBT with. If empty, the default
	// wallet account is used.
	Account       string `protobuf:"bytes,5,opt,name=account,proto3" json:"account,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FinalizePsbtRequest) Reset() {
	*x = FinalizePsbtRequest{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[60]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FinalizePsbtRequest) ProtoMessage() {}

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

func (x *FinalizePsbtRequest) GetFundedPsbt() []byte {
	if x != nil {
		return x.FundedPsbt
	}
	return nil
}

func (x *FinalizePsbtRequest) GetAccount() string {
	if x != nil {
		return x.Account
	}
	return ""
}

type FinalizePsbtResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The fully signed and finalized transaction in PSBT format.
	SignedPsbt []byte `protobuf:"bytes,1,opt,name=signed_psbt,json=signedPsbt,proto3" json:"signed_psbt,omitempty"`
	// The fully signed and finalized transaction in the raw wire format.
	RawFinalTx    []byte `protobuf:"bytes,2,opt,name=raw_final_tx,json=rawFinalTx,proto3" json:"raw_final_tx,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FinalizePsbtResponse) Reset() {
	*x = FinalizePsbtResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[61]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FinalizePsbtResponse) ProtoMessage() {}

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

func (x *FinalizePsbtResponse) GetSignedPsbt() []byte {
	if x != nil {
		return x.SignedPsbt
	}
	return nil
}

func (x *FinalizePsbtResponse) GetRawFinalTx() []byte {
	if x != nil {
		return x.RawFinalTx
	}
	return nil
}

type ListLeasesRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListLeasesRequest) Reset() {
	*x = ListLeasesRequest{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[62]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListLeasesRequest) ProtoMessage() {}

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

type ListLeasesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The list of currently leased utxos.
	LockedUtxos   []*UtxoLease `protobuf:"bytes,1,rep,name=locked_utxos,json=lockedUtxos,proto3" json:"locked_utxos,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListLeasesResponse) Reset() {
	*x = ListLeasesResponse{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[63]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListLeasesResponse) ProtoMessage() {}

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

func (x *ListLeasesResponse) GetLockedUtxos() []*UtxoLease {
	if x != nil {
		return x.LockedUtxos
	}
	return nil
}

type ListSweepsResponse_TransactionIDs struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Reversed, hex-encoded string representing the transaction ids of the
	// sweeps that our node has broadcast. Note that these transactions may
	// not have confirmed yet, we record sweeps on broadcast, not confirmation.
	TransactionIds []string `protobuf:"bytes,1,rep,name=transaction_ids,json=transactionIds,proto3" json:"transaction_ids,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *ListSweepsResponse_TransactionIDs) Reset() {
	*x = ListSweepsResponse_TransactionIDs{}
	mi := &file_walletrpc_walletkit_proto_msgTypes[65]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListSweepsResponse_TransactionIDs) ProtoMessage() {}

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

func (x *ListSweepsResponse_TransactionIDs) GetTransactionIds() []string {
	if x != nil {
		return x.TransactionIds
	}
	return nil
}

var File_walletrpc_walletkit_proto protoreflect.FileDescriptor

const file_walletrpc_walletkit_proto_rawDesc = "" +
	"\n" +
	"\x19walletrpc/walletkit.proto\x12\twalletrpc\x1a\x0flightning.proto\x1a\x14signrpc/signer.proto\"\x93\x01\n" +
	"\x12ListUnspentRequest\x12\x1b\n" +
	"\tmin_confs\x18\x01 \x01(\x05R\bminConfs\x12\x1b\n" +
	"\tmax_confs\x18\x02 \x01(\x05R\bmaxConfs\x12\x18\n" +
	"\aaccount\x18\x03 \x01(\tR\aaccount\x12)\n" +
	"\x10unconfirmed_only\x18\x04 \x01(\bR\x0funconfirmedOnly\"8\n" +
	"\x13ListUnspentResponse\x12!\n" +
	"\x05utxos\x18\x01 \x03(\v2\v.lnrpc.UtxoR\x05utxos\"\x80\x01\n" +
	"\x12LeaseOutputRequest\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\fR\x02id\x12+\n" +
	"\boutpoint\x18\x02 \x01(\v2\x0f.lnrpc.OutPointR\boutpoint\x12-\n" +
	"\x12expiration_seconds\x18\x03 \x01(\x04R\x11expirationSeconds\"5\n" +
	"\x13LeaseOutputResponse\x12\x1e\n" +
	"\n" +
	"expiration\x18\x01 \x01(\x04R\n" +
	"expiration\"S\n" +
	"\x14ReleaseOutputRequest\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\fR\x02id\x12+\n" +
	"\boutpoint\x18\x02 \x01(\v2\x0f.lnrpc.OutPointR\boutpoint\"/\n" +
	"\x15ReleaseOutputResponse\x12\x16\n" +
	"\x06status\x18\x01 \x01(\tR\x06status\"Q\n" +
	"\x06KeyReq\x12(\n" +
	"\x10key_finger_print\x18\x01 \x01(\x05R\x0ekeyFingerPrint\x12\x1d\n" +
	"\n" +
	"key_family\x18\x02 \x01(\x05R\tkeyFamily\"k\n" +
	"\vAddrRequest\x12\x18\n" +
	"\aaccount\x18\x01 \x01(\tR\aaccount\x12*\n" +
	"\x04type\x18\x02 \x01(\x0e2\x16.walletrpc.AddressTypeR\x04type\x12\x16\n" +
	"\x06change\x18\x03 \x01(\bR\x06change\"\"\n" +
	"\fAddrResponse\x12\x12\n" +
	"\x04addr\x18\x01 \x01(\tR\x04addr\"\xe2\x02\n" +
	"\aAccount\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x129\n" +
	"\faddress_type\x18\x02 \x01(\x0e2\x16.walletrpc.AddressTypeR\vaddressType\x12.\n" +
	"\x13extended_public_key\x18\x03 \x01(\tR\x11extendedPublicKey\x124\n" +
	"\x16master_key_fingerprint\x18\x04 \x01(\fR\x14masterKeyFingerprint\x12'\n" +
	"\x0fderivation_path\x18\x05 \x01(\tR\x0ederivationPath\x12,\n" +
	"\x12external_key_count\x18\x06 \x01(\rR\x10externalKeyCount\x12,\n" +
	"\x12internal_key_count\x18\a \x01(\rR\x10internalKeyCount\x12\x1d\n" +
	"\n" +
	"watch_only\x18\b \x01(\bR\twatchOnly\"\xae\x01\n" +
	"\x0fAddressProperty\x12\x18\n" +
	"\aaddress\x18\x01 \x01(\tR\aaddress\x12\x1f\n" +
	"\vis_internal\x18\x02 \x01(\bR\n" +
	"isInternal\x12\x18\n" +
	"\abalance\x18\x03 \x01(\x03R\abalance\x12'\n" +
	"\x0fderivation_path\x18\x04 \x01(\tR\x0ederivationPath\x12\x1d\n" +
	"\n" +
	"public_key\x18\x05 \x01(\fR\tpublicKey\"\xc8\x01\n" +
	"\x14AccountWithAddresses\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x129\n" +
	"\faddress_type\x18\x02 \x01(\x0e2\x16.walletrpc.AddressTypeR\vaddressType\x12'\n" +
	"\x0fderivation_path\x18\x03 \x01(\tR\x0ederivationPath\x128\n" +
	"\taddresses\x18\x04 \x03(\v2\x1a.walletrpc.AddressPropertyR\taddresses\"d\n" +
	"\x13ListAccountsRequest\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x129\n" +
	"\faddress_type\x18\x02 \x01(\x0e2\x16.walletrpc.AddressTypeR\vaddressType\"F\n" +
	"\x14ListAccountsResponse\x12.\n" +
	"\baccounts\x18\x01 \x03(\v2\x12.walletrpc.AccountR\baccounts\"V\n" +
	"\x16RequiredReserveRequest\x12<\n" +
	"\x1aadditional_public_channels\x18\x01 \x01(\rR\x18additionalPublicChannels\"D\n" +
	"\x17RequiredReserveResponse\x12)\n" +
	"\x10required_reserve\x18\x01 \x01(\x03R\x0frequiredReserve\"k\n" +
	"\x14ListAddressesRequest\x12!\n" +
	"\faccount_name\x18\x01 \x01(\tR\vaccountName\x120\n" +
	"\x14show_custom_accounts\x18\x02 \x01(\bR\x12showCustomAccounts\"n\n" +
	"\x15ListAddressesResponse\x12U\n" +
	"\x16account_with_addresses\x18\x01 \x03(\v2\x1f.walletrpc.AccountWithAddressesR\x14accountWithAddresses\"+\n" +
	"\x15GetTransactionRequest\x12\x12\n" +
	"\x04txid\x18\x01 \x01(\tR\x04txid\"B\n" +
	"\x1aSignMessageWithAddrRequest\x12\x10\n" +
	"\x03msg\x18\x01 \x01(\fR\x03msg\x12\x12\n" +
	"\x04addr\x18\x02 \x01(\tR\x04addr\";\n" +
	"\x1bSignMessageWithAddrResponse\x12\x1c\n" +
	"\tsignature\x18\x01 \x01(\tR\tsignature\"b\n" +
	"\x1cVerifyMessageWithAddrRequest\x12\x10\n" +
	"\x03msg\x18\x01 \x01(\fR\x03msg\x12\x1c\n" +
	"\tsignature\x18\x02 \x01(\tR\tsignature\x12\x12\n" +
	"\x04addr\x18\x03 \x01(\tR\x04addr\"M\n" +
	"\x1dVerifyMessageWithAddrResponse\x12\x14\n" +
	"\x05valid\x18\x01 \x01(\bR\x05valid\x12\x16\n" +
	"\x06pubkey\x18\x02 \x01(\fR\x06pubkey\"\xe4\x01\n" +
	"\x14ImportAccountRequest\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12.\n" +
	"\x13extended_public_key\x18\x02 \x01(\tR\x11extendedPublicKey\x124\n" +
	"\x16master_key_fingerprint\x18\x03 \x01(\fR\x14masterKeyFingerprint\x129\n" +
	"\faddress_type\x18\x04 \x01(\x0e2\x16.walletrpc.AddressTypeR\vaddressType\x12\x17\n" +
	"\adry_run\x18\x05 \x01(\bR\x06dryRun\"\xaf\x01\n" +
	"\x15ImportAccountResponse\x12,\n" +
	"\aaccount\x18\x01 \x01(\v2\x12.walletrpc.AccountR\aaccount\x123\n" +
	"\x16dry_run_external_addrs\x18\x02 \x03(\tR\x13dryRunExternalAddrs\x123\n" +
	"\x16dry_run_internal_addrs\x18\x03 \x03(\tR\x13dryRunInternalAddrs\"r\n" +
	"\x16ImportPublicKeyRequest\x12\x1d\n" +
	"\n" +
	"public_key\x18\x01 \x01(\fR\tpublicKey\x129\n" +
	"\faddress_type\x18\x02 \x01(\x0e2\x16.walletrpc.AddressTypeR\vaddressType\"1\n" +
	"\x17ImportPublicKeyResponse\x12\x16\n" +
	"\x06status\x18\x01 \x01(\tR\x06status\"\xa9\x02\n" +
	"\x16ImportTapscriptRequest\x12.\n" +
	"\x13internal_public_key\x18\x01 \x01(\fR\x11internalPublicKey\x12;\n" +
	"\tfull_tree\x18\x02 \x01(\v2\x1c.walletrpc.TapscriptFullTreeH\x00R\bfullTree\x12J\n" +
	"\x0epartial_reveal\x18\x03 \x01(\v2!.walletrpc.TapscriptPartialRevealH\x00R\rpartialReveal\x12&\n" +
	"\x0eroot_hash_only\x18\x04 \x01(\fH\x00R\frootHashOnly\x12$\n" +
	"\rfull_key_only\x18\x05 \x01(\bH\x00R\vfullKeyOnlyB\b\n" +
	"\x06script\"F\n" +
	"\x11TapscriptFullTree\x121\n" +
	"\n" +
	"all_leaves\x18\x01 \x03(\v2\x12.walletrpc.TapLeafR\tallLeaves\"D\n" +
	"\aTapLeaf\x12!\n" +
	"\fleaf_version\x18\x01 \x01(\rR\vleafVersion\x12\x16\n" +
	"\x06script\x18\x02 \x01(\fR\x06script\"\x83\x01\n" +
	"\x16TapscriptPartialReveal\x127\n" +
	"\rrevealed_leaf\x18\x01 \x01(\v2\x12.walletrpc.TapLeafR\frevealedLeaf\x120\n" +
	"\x14full_inclusion_proof\x18\x02 \x01(\fR\x12fullInclusionProof\"<\n" +
	"\x17ImportTapscriptResponse\x12!\n" +
	"\fp2tr_address\x18\x01 \x01(\tR\vp2trAddress\":\n" +
	"\vTransaction\x12\x15\n" +
	"\x06tx_hex\x18\x01 \x01(\fR\x05txHex\x12\x14\n" +
	"\x05label\x18\x02 \x01(\tR\x05label\"6\n" +
	"\x0fPublishResponse\x12#\n" +
	"\rpublish_error\x18\x01 \x01(\tR\fpublishError\"j\n" +
	"\x14SubmitPackageRequest\x12\x17\n" +
	"\araw_txs\x18\x01 \x03(\fR\x06rawTxs\x12'\n" +
	"\rsat_per_vbyte\x18\x02 \x01(\x04H\x00R\vsatPerVbyte\x88\x01\x01B\x10\n" +
	"\x0e_sat_per_vbyte\"b\n" +
	"\x15SubmitPackageTxResult\x12\x12\n" +
	"\x04txid\x18\x01 \x01(\tR\x04txid\x12\x14\n" +
	"\x05error\x18\x02 \x01(\tR\x05error\x12\x1f\n" +
	"\vother_wtxid\x18\x03 \x01(\tR\n" +
	"otherWtxid\"\x9d\x02\n" +
	"\x15SubmitPackageResponse\x12\x1f\n" +
	"\vpackage_msg\x18\x01 \x01(\tR\n" +
	"packageMsg\x12N\n" +
	"\n" +
	"tx_results\x18\x02 \x03(\v2/.walletrpc.SubmitPackageResponse.TxResultsEntryR\ttxResults\x123\n" +
	"\x15replaced_transactions\x18\x03 \x03(\tR\x14replacedTransactions\x1a^\n" +
	"\x0eTxResultsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x126\n" +
	"\x05value\x18\x02 \x01(\v2 .walletrpc.SubmitPackageTxResultR\x05value:\x028\x01\"3\n" +
	"\x19RemoveTransactionResponse\x12\x16\n" +
	"\x06status\x18\x01 \x01(\tR\x06status\"\x92\x02\n" +
	"\x12SendOutputsRequest\x12\x1c\n" +
	"\n" +
	"sat_per_kw\x18\x01 \x01(\x03R\bsatPerKw\x12(\n" +
	"\aoutputs\x18\x02 \x03(\v2\x0e.signrpc.TxOutR\aoutputs\x12\x14\n" +
	"\x05label\x18\x03 \x01(\tR\x05label\x12\x1b\n" +
	"\tmin_confs\x18\x04 \x01(\x05R\bminConfs\x12+\n" +
	"\x11spend_unconfirmed\x18\x05 \x01(\bR\x10spendUnconfirmed\x12T\n" +
	"\x17coin_selection_strategy\x18\x06 \x01(\x0e2\x1c.lnrpc.CoinSelectionStrategyR\x15coinSelectionStrategy\",\n" +
	"\x13SendOutputsResponse\x12\x15\n" +
	"\x06raw_tx\x18\x01 \x01(\fR\x05rawTx\"5\n" +
	"\x12EstimateFeeRequest\x12\x1f\n" +
	"\vconf_target\x18\x01 \x01(\x05R\n" +
	"confTarget\"j\n" +
	"\x13EstimateFeeResponse\x12\x1c\n" +
	"\n" +
	"sat_per_kw\x18\x01 \x01(\x03R\bsatPerKw\x125\n" +
	"\x18min_relay_fee_sat_per_kw\x18\x02 \x01(\x03R\x13minRelayFeeSatPerKw\"\x90\x05\n" +
	"\fPendingSweep\x12+\n" +
	"\boutpoint\x18\x01 \x01(\v2\x0f.lnrpc.OutPointR\boutpoint\x129\n" +
	"\fwitness_type\x18\x02 \x01(\x0e2\x16.walletrpc.WitnessTypeR\vwitnessType\x12\x1d\n" +
	"\n" +
	"amount_sat\x18\x03 \x01(\rR\tamountSat\x12$\n" +
	"\fsat_per_byte\x18\x04 \x01(\rB\x02\x18\x01R\n" +
	"satPerByte\x12-\n" +
	"\x12broadcast_attempts\x18\x05 \x01(\rR\x11broadcastAttempts\x126\n" +
	"\x15next_broadcast_height\x18\x06 \x01(\rB\x02\x18\x01R\x13nextBroadcastHeight\x12\x18\n" +
	"\x05force\x18\a \x01(\bB\x02\x18\x01R\x05force\x126\n" +
	"\x15requested_conf_target\x18\b \x01(\rB\x02\x18\x01R\x13requestedConfTarget\x127\n" +
	"\x16requested_sat_per_byte\x18\t \x01(\rB\x02\x18\x01R\x13requestedSatPerByte\x12\"\n" +
	"\rsat_per_vbyte\x18\n" +
	" \x01(\x04R\vsatPerVbyte\x125\n" +
	"\x17requested_sat_per_vbyte\x18\v \x01(\x04R\x14requestedSatPerVbyte\x12\x1c\n" +
	"\timmediate\x18\f \x01(\bR\timmediate\x12\x16\n" +
	"\x06budget\x18\r \x01(\x04R\x06budget\x12'\n" +
	"\x0fdeadline_height\x18\x0e \x01(\rR\x0edeadlineHeight\x12'\n" +
	"\x0fmaturity_height\x18\x0f \x01(\rR\x0ematurityHeight\"\x16\n" +
	"\x14PendingSweepsRequest\"W\n" +
	"\x15PendingSweepsResponse\x12>\n" +
	"\x0epending_sweeps\x18\x01 \x03(\v2\x17.walletrpc.PendingSweepR\rpendingSweeps\"\x9f\x02\n" +
	"\x0eBumpFeeRequest\x12+\n" +
	"\boutpoint\x18\x01 \x01(\v2\x0f.lnrpc.OutPointR\boutpoint\x12\x1f\n" +
	"\vtarget_conf\x18\x02 \x01(\rR\n" +
	"targetConf\x12$\n" +
	"\fsat_per_byte\x18\x03 \x01(\rB\x02\x18\x01R\n" +
	"satPerByte\x12\x18\n" +
	"\x05force\x18\x04 \x01(\bB\x02\x18\x01R\x05force\x12\"\n" +
	"\rsat_per_vbyte\x18\x05 \x01(\x04R\vsatPerVbyte\x12\x1c\n" +
	"\timmediate\x18\x06 \x01(\bR\timmediate\x12\x16\n" +
	"\x06budget\x18\a \x01(\x04R\x06budget\x12%\n" +
	"\x0edeadline_delta\x18\b \x01(\rR\rdeadlineDelta\")\n" +
	"\x0fBumpFeeResponse\x12\x16\n" +
	"\x06status\x18\x01 \x01(\tR\x06status\"\xf7\x01\n" +
	"\x18BumpForceCloseFeeRequest\x122\n" +
	"\n" +
	"chan_point\x18\x01 \x01(\v2\x13.lnrpc.ChannelPointR\tchanPoint\x12%\n" +
	"\x0edeadline_delta\x18\x02 \x01(\rR\rdeadlineDelta\x12)\n" +
	"\x10starting_feerate\x18\x03 \x01(\x04R\x0fstartingFeerate\x12\x1c\n" +
	"\timmediate\x18\x04 \x01(\bR\timmediate\x12\x16\n" +
	"\x06budget\x18\x05 \x01(\x04R\x06budget\x12\x1f\n" +
	"\vtarget_conf\x18\x06 \x01(\rR\n" +
	"targetConf\"3\n" +
	"\x19BumpForceCloseFeeResponse\x12\x16\n" +
	"\x06status\x18\x01 \x01(\tR\x06status\"P\n" +
	"\x11ListSweepsRequest\x12\x18\n" +
	"\averbose\x18\x01 \x01(\bR\averbose\x12!\n" +
	"\fstart_height\x18\x02 \x01(\x05R\vstartHeight\"\x80\x02\n" +
	"\x12ListSweepsResponse\x12L\n" +
	"\x13transaction_details\x18\x01 \x01(\v2\x19.lnrpc.TransactionDetailsH\x00R\x12transactionDetails\x12W\n" +
	"\x0ftransaction_ids\x18\x02 \x01(\v2,.walletrpc.ListSweepsResponse.TransactionIDsH\x00R\x0etransactionIds\x1a9\n" +
	"\x0eTransactionIDs\x12'\n" +
	"\x0ftransaction_ids\x18\x01 \x03(\tR\x0etransactionIdsB\b\n" +
	"\x06sweeps\"a\n" +
	"\x17LabelTransactionRequest\x12\x12\n" +
	"\x04txid\x18\x01 \x01(\fR\x04txid\x12\x14\n" +
	"\x05label\x18\x02 \x01(\tR\x05label\x12\x1c\n" +
	"\toverwrite\x18\x03 \x01(\bR\toverwrite\"2\n" +
	"\x18LabelTransactionResponse\x12\x16\n" +
	"\x06status\x18\x01 \x01(\tR\x06status\"\x88\x05\n" +
	"\x0fFundPsbtRequest\x12\x14\n" +
	"\x04psbt\x18\x01 \x01(\fH\x00R\x04psbt\x12)\n" +
	"\x03raw\x18\x02 \x01(\v2\x15.walletrpc.TxTemplateH\x00R\x03raw\x12<\n" +
	"\vcoin_select\x18\t \x01(\v2\x19.walletrpc.PsbtCoinSelectH\x00R\n" +
	"coinSelect\x12!\n" +
	"\vtarget_conf\x18\x03 \x01(\rH\x01R\n" +
	"targetConf\x12$\n" +
	"\rsat_per_vbyte\x18\x04 \x01(\x04H\x01R\vsatPerVbyte\x12\x1e\n" +
	"\n" +
	"sat_per_kw\x18\v \x01(\x04H\x01R\bsatPerKw\x12\x18\n" +
	"\aaccount\x18\x05 \x01(\tR\aaccount\x12\x1b\n" +
	"\tmin_confs\x18\x06 \x01(\x05R\bminConfs\x12+\n" +
	"\x11spend_unconfirmed\x18\a \x01(\bR\x10spendUnconfirmed\x12=\n" +
	"\vchange_type\x18\b \x01(\x0e2\x1c.walletrpc.ChangeAddressTypeR\n" +
	"changeType\x12T\n" +
	"\x17coin_selection_strategy\x18\n" +
	" \x01(\x0e2\x1c.lnrpc.CoinSelectionStrategyR\x15coinSelectionStrategy\x12\"\n" +
	"\rmax_fee_ratio\x18\f \x01(\x01R\vmaxFeeRatio\x12$\n" +
	"\x0ecustom_lock_id\x18\r \x01(\fR\fcustomLockId\x126\n" +
	"\x17lock_expiration_seconds\x18\x0e \x01(\x04R\x15lockExpirationSecondsB\n" +
	"\n" +
	"\btemplateB\x06\n" +
	"\x04fees\"\x9c\x01\n" +
	"\x10FundPsbtResponse\x12\x1f\n" +
	"\vfunded_psbt\x18\x01 \x01(\fR\n" +
	"fundedPsbt\x12.\n" +
	"\x13change_output_index\x18\x02 \x01(\x05R\x11changeOutputIndex\x127\n" +
	"\flocked_utxos\x18\x03 \x03(\v2\x14.walletrpc.UtxoLeaseR\vlockedUtxos\"\xaf\x01\n" +
	"\n" +
	"TxTemplate\x12'\n" +
	"\x06inputs\x18\x01 \x03(\v2\x0f.lnrpc.OutPointR\x06inputs\x12<\n" +
	"\aoutputs\x18\x02 \x03(\v2\".walletrpc.TxTemplate.OutputsEntryR\aoutputs\x1a:\n" +
	"\fOutputsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x04R\x05value:\x028\x01\"\x7f\n" +
	"\x0ePsbtCoinSelect\x12\x12\n" +
	"\x04psbt\x18\x01 \x01(\fR\x04psbt\x124\n" +
	"\x15existing_output_index\x18\x02 \x01(\x05H\x00R\x13existingOutputIndex\x12\x12\n" +
	"\x03add\x18\x03 \x01(\bH\x00R\x03addB\x0f\n" +
	"\rchange_output\"\x9b\x01\n" +
	"\tUtxoLease\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\fR\x02id\x12+\n" +
	"\boutpoint\x18\x02 \x01(\v2\x0f.lnrpc.OutPointR\boutpoint\x12\x1e\n" +
	"\n" +
	"expiration\x18\x03 \x01(\x04R\n" +
	"expiration\x12\x1b\n" +
	"\tpk_script\x18\x04 \x01(\fR\bpkScript\x12\x14\n" +
	"\x05value\x18\x05 \x01(\x04R\x05value\"2\n" +
	"\x0fSignPsbtRequest\x12\x1f\n" +
	"\vfunded_psbt\x18\x01 \x01(\fR\n" +
	"fundedPsbt\"X\n" +
	"\x10SignPsbtResponse\x12\x1f\n" +
	"\vsigned_psbt\x18\x01 \x01(\fR\n" +
	"signedPsbt\x12#\n" +
	"\rsigned_inputs\x18\x02 \x03(\rR\fsignedInputs\"P\n" +
	"\x13FinalizePsbtRequest\x12\x1f\n" +
	"\vfunded_psbt\x18\x01 \x01(\fR\n" +
	"fundedPsbt\x12\x18\n" +
	"\aaccount\x18\x05 \x01(\tR\aaccount\"Y\n" +
	"\x14FinalizePsbtResponse\x12\x1f\n" +
	"\vsigned_psbt\x18\x01 \x01(\fR\n" +
	"signedPsbt\x12 \n" +
	"\fraw_final_tx\x18\x02 \x01(\fR\n" +
	"rawFinalTx\"\x13\n" +
	"\x11ListLeasesRequest\"M\n" +
	"\x12ListLeasesResponse\x127\n" +
	"\flocked_utxos\x18\x01 \x03(\v2\x14.walletrpc.UtxoLeaseR\vlockedUtxos*\x8e\x01\n" +
	"\vAddressType\x12\v\n" +
	"\aUNKNOWN\x10\x00\x12\x17\n" +
	"\x13WITNESS_PUBKEY_HASH\x10\x01\x12\x1e\n" +
	"\x1aNESTED_WITNESS_PUBKEY_HASH\x10\x02\x12%\n" +
	"!HYBRID_NESTED_WITNESS_PUBKEY_HASH\x10\x03\x12\x12\n" +
	"\x0eTAPROOT_PUBKEY\x10\x04*\xb7\f\n" +
	"\vWitnessType\x12\x13\n" +
	"\x0fUNKNOWN_WITNESS\x10\x00\x12\x18\n" +
	"\x14COMMITMENT_TIME_LOCK\x10\x01\x12\x17\n" +
	"\x13COMMITMENT_NO_DELAY\x10\x02\x12\x15\n" +
	"\x11COMMITMENT_REVOKE\x10\x03\x12\x17\n" +
	"\x13HTLC_OFFERED_REVOKE\x10\x04\x12\x18\n" +
	"\x14HTLC_ACCEPTED_REVOKE\x10\x05\x12%\n" +
	"!HTLC_OFFERED_TIMEOUT_SECOND_LEVEL\x10\x06\x12&\n" +
	"\"HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL\x10\a\x12\x1f\n" +
	"\x1bHTLC_OFFERED_REMOTE_TIMEOUT\x10\b\x12 \n" +
	"\x1cHTLC_ACCEPTED_REMOTE_SUCCESS\x10\t\x12\x1c\n" +
	"\x18HTLC_SECOND_LEVEL_REVOKE\x10\n" +
	"\x12\x14\n" +
	"\x10WITNESS_KEY_HASH\x10\v\x12\x1b\n" +
	"\x17NESTED_WITNESS_KEY_HASH\x10\f\x12\x15\n" +
	"\x11COMMITMENT_ANCHOR\x10\r\x12!\n" +
	"\x1dCOMMITMENT_NO_DELAY_TWEAKLESS\x10\x0e\x12\"\n" +
	"\x1eCOMMITMENT_TO_REMOTE_CONFIRMED\x10\x0f\x125\n" +
	"1HTLC_OFFERED_TIMEOUT_SECOND_LEVEL_INPUT_CONFIRMED\x10\x10\x126\n" +
	"2HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL_INPUT_CONFIRMED\x10\x11\x12\x1e\n" +
	"\x1aLEASE_COMMITMENT_TIME_LOCK\x10\x12\x12(\n" +
	"$LEASE_COMMITMENT_TO_REMOTE_CONFIRMED\x10\x13\x12+\n" +
	"'LEASE_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL\x10\x14\x12,\n" +
	"(LEASE_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL\x10\x15\x12\x19\n" +
	"\x15TAPROOT_PUB_KEY_SPEND\x10\x16\x12\x1e\n" +
	"\x1aTAPROOT_LOCAL_COMMIT_SPEND\x10\x17\x12\x1f\n" +
	"\x1bTAPROOT_REMOTE_COMMIT_SPEND\x10\x18\x12\x1e\n" +
	"\x1aTAPROOT_ANCHOR_SWEEP_SPEND\x10\x19\x12-\n" +
	")TAPROOT_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL\x10\x1a\x12.\n" +
	"*TAPROOT_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL\x10\x1b\x12$\n" +
	" TAPROOT_HTLC_SECOND_LEVEL_REVOKE\x10\x1c\x12 \n" +
	"\x1cTAPROOT_HTLC_ACCEPTED_REVOKE\x10\x1d\x12\x1f\n" +
	"\x1bTAPROOT_HTLC_OFFERED_REVOKE\x10\x1e\x12'\n" +
	"#TAPROOT_HTLC_OFFERED_REMOTE_TIMEOUT\x10\x1f\x12&\n" +
	"\"TAPROOT_HTLC_LOCAL_OFFERED_TIMEOUT\x10 \x12(\n" +
	"$TAPROOT_HTLC_ACCEPTED_REMOTE_SUCCESS\x10!\x12'\n" +
	"#TAPROOT_HTLC_ACCEPTED_LOCAL_SUCCESS\x10\"\x12\x1d\n" +
	"\x19TAPROOT_COMMITMENT_REVOKE\x10#\x12$\n" +
	" TAPROOT_LOCAL_COMMIT_SPEND_FINAL\x10$\x12%\n" +
	"!TAPROOT_REMOTE_COMMIT_SPEND_FINAL\x10%\x123\n" +
	"/TAPROOT_HTLC_OFFERED_TIMEOUT_SECOND_LEVEL_FINAL\x10&\x124\n" +
	"0TAPROOT_HTLC_ACCEPTED_SUCCESS_SECOND_LEVEL_FINAL\x10'\x12-\n" +
	")TAPROOT_HTLC_OFFERED_REMOTE_TIMEOUT_FINAL\x10(\x12.\n" +
	"*TAPROOT_HTLC_ACCEPTED_REMOTE_SUCCESS_FINAL\x10)\x12#\n" +
	"\x1fTAPROOT_COMMITMENT_REVOKE_FINAL\x10**V\n" +
	"\x11ChangeAddressType\x12#\n" +
	"\x1fCHANGE_ADDRESS_TYPE_UNSPECIFIED\x10\x00\x12\x1c\n" +
	"\x18CHANGE_ADDRESS_TYPE_P2TR\x10\x012\xaa\x12\n" +
	"\tWalletKit\x12L\n" +
	"\vListUnspent\x12\x1d.walletrpc.ListUnspentRequest\x1a\x1e.walletrpc.ListUnspentResponse\x12L\n" +
	"\vLeaseOutput\x12\x1d.walletrpc.LeaseOutputRequest\x1a\x1e.walletrpc.LeaseOutputResponse\x12R\n" +
	"\rReleaseOutput\x12\x1f.walletrpc.ReleaseOutputRequest\x1a .walletrpc.ReleaseOutputResponse\x12I\n" +
	"\n" +
	"ListLeases\x12\x1c.walletrpc.ListLeasesRequest\x1a\x1d.walletrpc.ListLeasesResponse\x12:\n" +
	"\rDeriveNextKey\x12\x11.walletrpc.KeyReq\x1a\x16.signrpc.KeyDescriptor\x128\n" +
	"\tDeriveKey\x12\x13.signrpc.KeyLocator\x1a\x16.signrpc.KeyDescriptor\x12;\n" +
	"\bNextAddr\x12\x16.walletrpc.AddrRequest\x1a\x17.walletrpc.AddrResponse\x12F\n" +
	"\x0eGetTransaction\x12 .walletrpc.GetTransactionRequest\x1a\x12.lnrpc.Transaction\x12O\n" +
	"\fListAccounts\x12\x1e.walletrpc.ListAccountsRequest\x1a\x1f.walletrpc.ListAccountsResponse\x12X\n" +
	"\x0fRequiredReserve\x12!.walletrpc.RequiredReserveRequest\x1a\".walletrpc.RequiredReserveResponse\x12R\n" +
	"\rListAddresses\x12\x1f.walletrpc.ListAddressesRequest\x1a .walletrpc.ListAddressesResponse\x12d\n" +
	"\x13SignMessageWithAddr\x12%.walletrpc.SignMessageWithAddrRequest\x1a&.walletrpc.SignMessageWithAddrResponse\x12j\n" +
	"\x15VerifyMessageWithAddr\x12'.walletrpc.VerifyMessageWithAddrRequest\x1a(.walletrpc.VerifyMessageWithAddrResponse\x12R\n" +
	"\rImportAccount\x12\x1f.walletrpc.ImportAccountRequest\x1a .walletrpc.ImportAccountResponse\x12X\n" +
	"\x0fImportPublicKey\x12!.walletrpc.ImportPublicKeyRequest\x1a\".walletrpc.ImportPublicKeyResponse\x12X\n" +
	"\x0fImportTapscript\x12!.walletrpc.ImportTapscriptRequest\x1a\".walletrpc.ImportTapscriptResponse\x12H\n" +
	"\x12PublishTransaction\x12\x16.walletrpc.Transaction\x1a\x1a.walletrpc.PublishResponse\x12R\n" +
	"\rSubmitPackage\x12\x1f.walletrpc.SubmitPackageRequest\x1a .walletrpc.SubmitPackageResponse\x12[\n" +
	"\x11RemoveTransaction\x12 .walletrpc.GetTransactionRequest\x1a$.walletrpc.RemoveTransactionResponse\x12L\n" +
	"\vSendOutputs\x12\x1d.walletrpc.SendOutputsRequest\x1a\x1e.walletrpc.SendOutputsResponse\x12L\n" +
	"\vEstimateFee\x12\x1d.walletrpc.EstimateFeeRequest\x1a\x1e.walletrpc.EstimateFeeResponse\x12R\n" +
	"\rPendingSweeps\x12\x1f.walletrpc.PendingSweepsRequest\x1a .walletrpc.PendingSweepsResponse\x12@\n" +
	"\aBumpFee\x12\x19.walletrpc.BumpFeeRequest\x1a\x1a.walletrpc.BumpFeeResponse\x12^\n" +
	"\x11BumpForceCloseFee\x12#.walletrpc.BumpForceCloseFeeRequest\x1a$.walletrpc.BumpForceCloseFeeResponse\x12I\n" +
	"\n" +
	"ListSweeps\x12\x1c.walletrpc.ListSweepsRequest\x1a\x1d.walletrpc.ListSweepsResponse\x12[\n" +
	"\x10LabelTransaction\x12\".walletrpc.LabelTransactionRequest\x1a#.walletrpc.LabelTransactionResponse\x12C\n" +
	"\bFundPsbt\x12\x1a.walletrpc.FundPsbtRequest\x1a\x1b.walletrpc.FundPsbtResponse\x12C\n" +
	"\bSignPsbt\x12\x1a.walletrpc.SignPsbtRequest\x1a\x1b.walletrpc.SignPsbtResponse\x12O\n" +
	"\fFinalizePsbt\x12\x1e.walletrpc.FinalizePsbtRequest\x1a\x1f.walletrpc.FinalizePsbtResponseB1Z/github.com/lightningnetwork/lnd/lnrpc/walletrpcb\x06proto3"

var (
	file_walletrpc_walletkit_proto_rawDescOnce sync.Once
	file_walletrpc_walletkit_proto_rawDescData []byte
)

func file_walletrpc_walletkit_proto_rawDescGZIP() []byte {
	file_walletrpc_walletkit_proto_rawDescOnce.Do(func() {
		file_walletrpc_walletkit_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_walletrpc_walletkit_proto_rawDesc), len(file_walletrpc_walletkit_proto_rawDesc)))
	})
	return file_walletrpc_walletkit_proto_rawDescData
}

var file_walletrpc_walletkit_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_walletrpc_walletkit_proto_msgTypes = make([]protoimpl.MessageInfo, 67)
var file_walletrpc_walletkit_proto_goTypes = []any{
	(AddressType)(0),                          // 0: walletrpc.AddressType
	(WitnessType)(0),                          // 1: walletrpc.WitnessType
	(ChangeAddressType)(0),                    // 2: walletrpc.ChangeAddressType
	(*ListUnspentRequest)(nil),                // 3: walletrpc.ListUnspentRequest
	(*ListUnspentResponse)(nil),               // 4: walletrpc.ListUnspentResponse
	(*LeaseOutputRequest)(nil),                // 5: walletrpc.LeaseOutputRequest
	(*LeaseOutputResponse)(nil),               // 6: walletrpc.LeaseOutputResponse
	(*ReleaseOutputRequest)(nil),              // 7: walletrpc.ReleaseOutputRequest
	(*ReleaseOutputResponse)(nil),             // 8: walletrpc.ReleaseOutputResponse
	(*KeyReq)(nil),                            // 9: walletrpc.KeyReq
	(*AddrRequest)(nil),                       // 10: walletrpc.AddrRequest
	(*AddrResponse)(nil),                      // 11: walletrpc.AddrResponse
	(*Account)(nil),                           // 12: walletrpc.Account
	(*AddressProperty)(nil),                   // 13: walletrpc.AddressProperty
	(*AccountWithAddresses)(nil),              // 14: walletrpc.AccountWithAddresses
	(*ListAccountsRequest)(nil),               // 15: walletrpc.ListAccountsRequest
	(*ListAccountsResponse)(nil),              // 16: walletrpc.ListAccountsResponse
	(*RequiredReserveRequest)(nil),            // 17: walletrpc.RequiredReserveRequest
	(*RequiredReserveResponse)(nil),           // 18: walletrpc.RequiredReserveResponse
	(*ListAddressesRequest)(nil),              // 19: walletrpc.ListAddressesRequest
	(*ListAddressesResponse)(nil),             // 20: walletrpc.ListAddressesResponse
	(*GetTransactionRequest)(nil),             // 21: walletrpc.GetTransactionRequest
	(*SignMessageWithAddrRequest)(nil),        // 22: walletrpc.SignMessageWithAddrRequest
	(*SignMessageWithAddrResponse)(nil),       // 23: walletrpc.SignMessageWithAddrResponse
	(*VerifyMessageWithAddrRequest)(nil),      // 24: walletrpc.VerifyMessageWithAddrRequest
	(*VerifyMessageWithAddrResponse)(nil),     // 25: walletrpc.VerifyMessageWithAddrResponse
	(*ImportAccountRequest)(nil),              // 26: walletrpc.ImportAccountRequest
	(*ImportAccountResponse)(nil),             // 27: walletrpc.ImportAccountResponse
	(*ImportPublicKeyRequest)(nil),            // 28: walletrpc.ImportPublicKeyRequest
	(*ImportPublicKeyResponse)(nil),           // 29: walletrpc.ImportPublicKeyResponse
	(*ImportTapscriptRequest)(nil),            // 30: walletrpc.ImportTapscriptRequest
	(*TapscriptFullTree)(nil),                 // 31: walletrpc.TapscriptFullTree
	(*TapLeaf)(nil),                           // 32: walletrpc.TapLeaf
	(*TapscriptPartialReveal)(nil),            // 33: walletrpc.TapscriptPartialReveal
	(*ImportTapscriptResponse)(nil),           // 34: walletrpc.ImportTapscriptResponse
	(*Transaction)(nil),                       // 35: walletrpc.Transaction
	(*PublishResponse)(nil),                   // 36: walletrpc.PublishResponse
	(*SubmitPackageRequest)(nil),              // 37: walletrpc.SubmitPackageRequest
	(*SubmitPackageTxResult)(nil),             // 38: walletrpc.SubmitPackageTxResult
	(*SubmitPackageResponse)(nil),             // 39: walletrpc.SubmitPackageResponse
	(*RemoveTransactionResponse)(nil),         // 40: walletrpc.RemoveTransactionResponse
	(*SendOutputsRequest)(nil),                // 41: walletrpc.SendOutputsRequest
	(*SendOutputsResponse)(nil),               // 42: walletrpc.SendOutputsResponse
	(*EstimateFeeRequest)(nil),                // 43: walletrpc.EstimateFeeRequest
	(*EstimateFeeResponse)(nil),               // 44: walletrpc.EstimateFeeResponse
	(*PendingSweep)(nil),                      // 45: walletrpc.PendingSweep
	(*PendingSweepsRequest)(nil),              // 46: walletrpc.PendingSweepsRequest
	(*PendingSweepsResponse)(nil),             // 47: walletrpc.PendingSweepsResponse
	(*BumpFeeRequest)(nil),                    // 48: walletrpc.BumpFeeRequest
	(*BumpFeeResponse)(nil),                   // 49: walletrpc.BumpFeeResponse
	(*BumpForceCloseFeeRequest)(nil),          // 50: walletrpc.BumpForceCloseFeeRequest
	(*BumpForceCloseFeeResponse)(nil),         // 51: walletrpc.BumpForceCloseFeeResponse
	(*ListSweepsRequest)(nil),                 // 52: walletrpc.ListSweepsRequest
	(*ListSweepsResponse)(nil),                // 53: walletrpc.ListSweepsResponse
	(*LabelTransactionRequest)(nil),           // 54: walletrpc.LabelTransactionRequest
	(*LabelTransactionResponse)(nil),          // 55: walletrpc.LabelTransactionResponse
	(*FundPsbtRequest)(nil),                   // 56: walletrpc.FundPsbtRequest
	(*FundPsbtResponse)(nil),                  // 57: walletrpc.FundPsbtResponse
	(*TxTemplate)(nil),                        // 58: walletrpc.TxTemplate
	(*PsbtCoinSelect)(nil),                    // 59: walletrpc.PsbtCoinSelect
	(*UtxoLease)(nil),                         // 60: walletrpc.UtxoLease
	(*SignPsbtRequest)(nil),                   // 61: walletrpc.SignPsbtRequest
	(*SignPsbtResponse)(nil),                  // 62: walletrpc.SignPsbtResponse
	(*FinalizePsbtRequest)(nil),               // 63: walletrpc.FinalizePsbtRequest
	(*FinalizePsbtResponse)(nil),              // 64: walletrpc.FinalizePsbtResponse
	(*ListLeasesRequest)(nil),                 // 65: walletrpc.ListLeasesRequest
	(*ListLeasesResponse)(nil),                // 66: walletrpc.ListLeasesResponse
	nil,                                       // 67: walletrpc.SubmitPackageResponse.TxResultsEntry
	(*ListSweepsResponse_TransactionIDs)(nil), // 68: walletrpc.ListSweepsResponse.TransactionIDs
	nil,                              // 69: walletrpc.TxTemplate.OutputsEntry
	(*lnrpc.Utxo)(nil),               // 70: lnrpc.Utxo
	(*lnrpc.OutPoint)(nil),           // 71: lnrpc.OutPoint
	(*signrpc.TxOut)(nil),            // 72: signrpc.TxOut
	(lnrpc.CoinSelectionStrategy)(0), // 73: lnrpc.CoinSelectionStrategy
	(*lnrpc.ChannelPoint)(nil),       // 74: lnrpc.ChannelPoint
	(*lnrpc.TransactionDetails)(nil), // 75: lnrpc.TransactionDetails
	(*signrpc.KeyLocator)(nil),       // 76: signrpc.KeyLocator
	(*signrpc.KeyDescriptor)(nil),    // 77: signrpc.KeyDescriptor
	(*lnrpc.Transaction)(nil),        // 78: lnrpc.Transaction
}
var file_walletrpc_walletkit_proto_depIdxs = []int32{
	70, // 0: walletrpc.ListUnspentResponse.utxos:type_name -> lnrpc.Utxo
	71, // 1: walletrpc.LeaseOutputRequest.outpoint:type_name -> lnrpc.OutPoint
	71, // 2: walletrpc.ReleaseOutputRequest.outpoint:type_name -> lnrpc.OutPoint
	0,  // 3: walletrpc.AddrRequest.type:type_name -> walletrpc.AddressType
	0,  // 4: walletrpc.Account.address_type:type_name -> walletrpc.AddressType
	0,  // 5: walletrpc.AccountWithAddresses.address_type:type_name -> walletrpc.AddressType
	13, // 6: walletrpc.AccountWithAddresses.addresses:type_name -> walletrpc.AddressProperty
	0,  // 7: walletrpc.ListAccountsRequest.address_type:type_name -> walletrpc.AddressType
	12, // 8: walletrpc.ListAccountsResponse.accounts:type_name -> walletrpc.Account
	14, // 9: walletrpc.ListAddressesResponse.account_with_addresses:type_name -> walletrpc.AccountWithAddresses
	0,  // 10: walletrpc.ImportAccountRequest.address_type:type_name -> walletrpc.AddressType
	12, // 11: walletrpc.ImportAccountResponse.account:type_name -> walletrpc.Account
	0,  // 12: walletrpc.ImportPublicKeyRequest.address_type:type_name -> walletrpc.AddressType
	31, // 13: walletrpc.ImportTapscriptRequest.full_tree:type_name -> walletrpc.TapscriptFullTree
	33, // 14: walletrpc.ImportTapscriptRequest.partial_reveal:type_name -> walletrpc.TapscriptPartialReveal
	32, // 15: walletrpc.TapscriptFullTree.all_leaves:type_name -> walletrpc.TapLeaf
	32, // 16: walletrpc.TapscriptPartialReveal.revealed_leaf:type_name -> walletrpc.TapLeaf
	67, // 17: walletrpc.SubmitPackageResponse.tx_results:type_name -> walletrpc.SubmitPackageResponse.TxResultsEntry
	72, // 18: walletrpc.SendOutputsRequest.outputs:type_name -> signrpc.TxOut
	73, // 19: walletrpc.SendOutputsRequest.coin_selection_strategy:type_name -> lnrpc.CoinSelectionStrategy
	71, // 20: walletrpc.PendingSweep.outpoint:type_name -> lnrpc.OutPoint
	1,  // 21: walletrpc.PendingSweep.witness_type:type_name -> walletrpc.WitnessType
	45, // 22: walletrpc.PendingSweepsResponse.pending_sweeps:type_name -> walletrpc.PendingSweep
	71, // 23: walletrpc.BumpFeeRequest.outpoint:type_name -> lnrpc.OutPoint
	74, // 24: walletrpc.BumpForceCloseFeeRequest.chan_point:type_name -> lnrpc.ChannelPoint
	75, // 25: walletrpc.ListSweepsResponse.transaction_details:type_name -> lnrpc.TransactionDetails
	68, // 26: walletrpc.ListSweepsResponse.transaction_ids:type_name -> walletrpc.ListSweepsResponse.TransactionIDs
	58, // 27: walletrpc.FundPsbtRequest.raw:type_name -> walletrpc.TxTemplate
	59, // 28: walletrpc.FundPsbtRequest.coin_select:type_name -> walletrpc.PsbtCoinSelect
	2,  // 29: walletrpc.FundPsbtRequest.change_type:type_name -> walletrpc.ChangeAddressType
	73, // 30: walletrpc.FundPsbtRequest.coin_selection_strategy:type_name -> lnrpc.CoinSelectionStrategy
	60, // 31: walletrpc.FundPsbtResponse.locked_utxos:type_name -> walletrpc.UtxoLease
	71, // 32: walletrpc.TxTemplate.inputs:type_name -> lnrpc.OutPoint
	69, // 33: walletrpc.TxTemplate.outputs:type_name -> walletrpc.TxTemplate.OutputsEntry
	71, // 34: walletrpc.UtxoLease.outpoint:type_name -> lnrpc.OutPoint
	60, // 35: walletrpc.ListLeasesResponse.locked_utxos:type_name -> walletrpc.UtxoLease
	38, // 36: walletrpc.SubmitPackageResponse.TxResultsEntry.value:type_name -> walletrpc.SubmitPackageTxResult
	3,  // 37: walletrpc.WalletKit.ListUnspent:input_type -> walletrpc.ListUnspentRequest
	5,  // 38: walletrpc.WalletKit.LeaseOutput:input_type -> walletrpc.LeaseOutputRequest
	7,  // 39: walletrpc.WalletKit.ReleaseOutput:input_type -> walletrpc.ReleaseOutputRequest
	65, // 40: walletrpc.WalletKit.ListLeases:input_type -> walletrpc.ListLeasesRequest
	9,  // 41: walletrpc.WalletKit.DeriveNextKey:input_type -> walletrpc.KeyReq
	76, // 42: walletrpc.WalletKit.DeriveKey:input_type -> signrpc.KeyLocator
	10, // 43: walletrpc.WalletKit.NextAddr:input_type -> walletrpc.AddrRequest
	21, // 44: walletrpc.WalletKit.GetTransaction:input_type -> walletrpc.GetTransactionRequest
	15, // 45: walletrpc.WalletKit.ListAccounts:input_type -> walletrpc.ListAccountsRequest
	17, // 46: walletrpc.WalletKit.RequiredReserve:input_type -> walletrpc.RequiredReserveRequest
	19, // 47: walletrpc.WalletKit.ListAddresses:input_type -> walletrpc.ListAddressesRequest
	22, // 48: walletrpc.WalletKit.SignMessageWithAddr:input_type -> walletrpc.SignMessageWithAddrRequest
	24, // 49: walletrpc.WalletKit.VerifyMessageWithAddr:input_type -> walletrpc.VerifyMessageWithAddrRequest
	26, // 50: walletrpc.WalletKit.ImportAccount:input_type -> walletrpc.ImportAccountRequest
	28, // 51: walletrpc.WalletKit.ImportPublicKey:input_type -> walletrpc.ImportPublicKeyRequest
	30, // 52: walletrpc.WalletKit.ImportTapscript:input_type -> walletrpc.ImportTapscriptRequest
	35, // 53: walletrpc.WalletKit.PublishTransaction:input_type -> walletrpc.Transaction
	37, // 54: walletrpc.WalletKit.SubmitPackage:input_type -> walletrpc.SubmitPackageRequest
	21, // 55: walletrpc.WalletKit.RemoveTransaction:input_type -> walletrpc.GetTransactionRequest
	41, // 56: walletrpc.WalletKit.SendOutputs:input_type -> walletrpc.SendOutputsRequest
	43, // 57: walletrpc.WalletKit.EstimateFee:input_type -> walletrpc.EstimateFeeRequest
	46, // 58: walletrpc.WalletKit.PendingSweeps:input_type -> walletrpc.PendingSweepsRequest
	48, // 59: walletrpc.WalletKit.BumpFee:input_type -> walletrpc.BumpFeeRequest
	50, // 60: walletrpc.WalletKit.BumpForceCloseFee:input_type -> walletrpc.BumpForceCloseFeeRequest
	52, // 61: walletrpc.WalletKit.ListSweeps:input_type -> walletrpc.ListSweepsRequest
	54, // 62: walletrpc.WalletKit.LabelTransaction:input_type -> walletrpc.LabelTransactionRequest
	56, // 63: walletrpc.WalletKit.FundPsbt:input_type -> walletrpc.FundPsbtRequest
	61, // 64: walletrpc.WalletKit.SignPsbt:input_type -> walletrpc.SignPsbtRequest
	63, // 65: walletrpc.WalletKit.FinalizePsbt:input_type -> walletrpc.FinalizePsbtRequest
	4,  // 66: walletrpc.WalletKit.ListUnspent:output_type -> walletrpc.ListUnspentResponse
	6,  // 67: walletrpc.WalletKit.LeaseOutput:output_type -> walletrpc.LeaseOutputResponse
	8,  // 68: walletrpc.WalletKit.ReleaseOutput:output_type -> walletrpc.ReleaseOutputResponse
	66, // 69: walletrpc.WalletKit.ListLeases:output_type -> walletrpc.ListLeasesResponse
	77, // 70: walletrpc.WalletKit.DeriveNextKey:output_type -> signrpc.KeyDescriptor
	77, // 71: walletrpc.WalletKit.DeriveKey:output_type -> signrpc.KeyDescriptor
	11, // 72: walletrpc.WalletKit.NextAddr:output_type -> walletrpc.AddrResponse
	78, // 73: walletrpc.WalletKit.GetTransaction:output_type -> lnrpc.Transaction
	16, // 74: walletrpc.WalletKit.ListAccounts:output_type -> walletrpc.ListAccountsResponse
	18, // 75: walletrpc.WalletKit.RequiredReserve:output_type -> walletrpc.RequiredReserveResponse
	20, // 76: walletrpc.WalletKit.ListAddresses:output_type -> walletrpc.ListAddressesResponse
	23, // 77: walletrpc.WalletKit.SignMessageWithAddr:output_type -> walletrpc.SignMessageWithAddrResponse
	25, // 78: walletrpc.WalletKit.VerifyMessageWithAddr:output_type -> walletrpc.VerifyMessageWithAddrResponse
	27, // 79: walletrpc.WalletKit.ImportAccount:output_type -> walletrpc.ImportAccountResponse
	29, // 80: walletrpc.WalletKit.ImportPublicKey:output_type -> walletrpc.ImportPublicKeyResponse
	34, // 81: walletrpc.WalletKit.ImportTapscript:output_type -> walletrpc.ImportTapscriptResponse
	36, // 82: walletrpc.WalletKit.PublishTransaction:output_type -> walletrpc.PublishResponse
	39, // 83: walletrpc.WalletKit.SubmitPackage:output_type -> walletrpc.SubmitPackageResponse
	40, // 84: walletrpc.WalletKit.RemoveTransaction:output_type -> walletrpc.RemoveTransactionResponse
	42, // 85: walletrpc.WalletKit.SendOutputs:output_type -> walletrpc.SendOutputsResponse
	44, // 86: walletrpc.WalletKit.EstimateFee:output_type -> walletrpc.EstimateFeeResponse
	47, // 87: walletrpc.WalletKit.PendingSweeps:output_type -> walletrpc.PendingSweepsResponse
	49, // 88: walletrpc.WalletKit.BumpFee:output_type -> walletrpc.BumpFeeResponse
	51, // 89: walletrpc.WalletKit.BumpForceCloseFee:output_type -> walletrpc.BumpForceCloseFeeResponse
	53, // 90: walletrpc.WalletKit.ListSweeps:output_type -> walletrpc.ListSweepsResponse
	55, // 91: walletrpc.WalletKit.LabelTransaction:output_type -> walletrpc.LabelTransactionResponse
	57, // 92: walletrpc.WalletKit.FundPsbt:output_type -> walletrpc.FundPsbtResponse
	62, // 93: walletrpc.WalletKit.SignPsbt:output_type -> walletrpc.SignPsbtResponse
	64, // 94: walletrpc.WalletKit.FinalizePsbt:output_type -> walletrpc.FinalizePsbtResponse
	66, // [66:95] is the sub-list for method output_type
	37, // [37:66] is the sub-list for method input_type
	37, // [37:37] is the sub-list for extension type_name
	37, // [37:37] is the sub-list for extension extendee
	0,  // [0:37] is the sub-list for field type_name
}

func init() { file_walletrpc_walletkit_proto_init() }
func file_walletrpc_walletkit_proto_init() {
	if File_walletrpc_walletkit_proto != nil {
		return
	}
	file_walletrpc_walletkit_proto_msgTypes[27].OneofWrappers = []any{
		(*ImportTapscriptRequest_FullTree)(nil),
		(*ImportTapscriptRequest_PartialReveal)(nil),
		(*ImportTapscriptRequest_RootHashOnly)(nil),
		(*ImportTapscriptRequest_FullKeyOnly)(nil),
	}
	file_walletrpc_walletkit_proto_msgTypes[34].OneofWrappers = []any{}
	file_walletrpc_walletkit_proto_msgTypes[50].OneofWrappers = []any{
		(*ListSweepsResponse_TransactionDetails)(nil),
		(*ListSweepsResponse_TransactionIds)(nil),
	}
	file_walletrpc_walletkit_proto_msgTypes[53].OneofWrappers = []any{
		(*FundPsbtRequest_Psbt)(nil),
		(*FundPsbtRequest_Raw)(nil),
		(*FundPsbtRequest_CoinSelect)(nil),
		(*FundPsbtRequest_TargetConf)(nil),
		(*FundPsbtRequest_SatPerVbyte)(nil),
		(*FundPsbtRequest_SatPerKw)(nil),
	}
	file_walletrpc_walletkit_proto_msgTypes[56].OneofWrappers = []any{
		(*PsbtCoinSelect_ExistingOutputIndex)(nil),
		(*PsbtCoinSelect_Add)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_walletrpc_walletkit_proto_rawDesc), len(file_walletrpc_walletkit_proto_rawDesc)),
			NumEnums:      3,
			NumMessages:   67,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_walletrpc_walletkit_proto_goTypes,
		DependencyIndexes: file_walletrpc_walletkit_proto_depIdxs,
		EnumInfos:         file_walletrpc_walletkit_proto_enumTypes,
		MessageInfos:      file_walletrpc_walletkit_proto_msgTypes,
	}.Build()
	File_walletrpc_walletkit_proto = out.File
	file_walletrpc_walletkit_proto_goTypes = nil
	file_walletrpc_walletkit_proto_depIdxs = nil
}
