// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v6.32.1
// source: services/propagation/propagation_api/propagation_api.proto

package propagation_api

import (
	errors "github.com/bsv-blockchain/teranode/errors"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	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)
)

// EmptyMessage represents an empty request or response.
// Used when no additional data needs to be transmitted.
// swagger:model EmptyMessage
type EmptyMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EmptyMessage) ProtoMessage() {}

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

// HealthResponse provides information about the service's health status.
// swagger:model HealthResponse
type HealthResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// ok indicates whether the service is healthy
	Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"`
	// details provides additional information about the health status
	Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"`
	// timestamp indicates when the health check was performed
	Timestamp     *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HealthResponse) ProtoMessage() {}

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

func (x *HealthResponse) GetOk() bool {
	if x != nil {
		return x.Ok
	}
	return false
}

func (x *HealthResponse) GetDetails() string {
	if x != nil {
		return x.Details
	}
	return ""
}

func (x *HealthResponse) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

// GetRequest represents a request to retrieve a transaction by its ID.
// swagger:model GetRequest
type GetRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// txid is the transaction ID in bytes
	Txid          []byte `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetRequest) ProtoMessage() {}

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

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

// GetResponse contains the retrieved transaction data.
// swagger:model GetResponse
type GetResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// tx contains the raw transaction bytes
	Tx            []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetResponse) ProtoMessage() {}

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

func (x *GetResponse) GetTx() []byte {
	if x != nil {
		return x.Tx
	}
	return nil
}

// ProcessTransactionRequest represents a request to process a single transaction.
// swagger:model ProcessTransactionRequest
type ProcessTransactionRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// tx contains the raw transaction bytes to process
	Tx            []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ProcessTransactionRequest) ProtoMessage() {}

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

func (x *ProcessTransactionRequest) GetTx() []byte {
	if x != nil {
		return x.Tx
	}
	return nil
}

type BatchTransactionItem struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// tx contains the raw transaction bytes to process
	Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
	// trace_context contains the serialized OpenTelemetry trace context as key-value pairs
	// This allows proper span propagation for each transaction in the batch
	TraceContext  map[string]string `protobuf:"bytes,2,rep,name=trace_context,json=traceContext,proto3" json:"trace_context,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BatchTransactionItem) ProtoMessage() {}

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

func (x *BatchTransactionItem) GetTx() []byte {
	if x != nil {
		return x.Tx
	}
	return nil
}

func (x *BatchTransactionItem) GetTraceContext() map[string]string {
	if x != nil {
		return x.TraceContext
	}
	return nil
}

// ProcessTransactionBatchRequest represents a request to process multiple transactions.
// swagger:model ProcessTransactionRequest
type ProcessTransactionBatchRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// tx contains an array of raw transaction bytes to process
	Items         []*BatchTransactionItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ProcessTransactionBatchRequest) ProtoMessage() {}

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

func (x *ProcessTransactionBatchRequest) GetItems() []*BatchTransactionItem {
	if x != nil {
		return x.Items
	}
	return nil
}

// ProcessTransactionBatchResponse contains the results of batch transaction processing.
// swagger:model ProcessTransactionBatchResponse
type ProcessTransactionBatchResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// error contains error messages for each transaction in the batch
	// empty string indicates success for that transaction
	Errors        []*errors.TError `protobuf:"bytes,1,rep,name=errors,proto3" json:"errors,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ProcessTransactionBatchResponse) ProtoMessage() {}

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

func (x *ProcessTransactionBatchResponse) GetErrors() []*errors.TError {
	if x != nil {
		return x.Errors
	}
	return nil
}

var File_services_propagation_propagation_api_propagation_api_proto protoreflect.FileDescriptor

const file_services_propagation_propagation_api_propagation_api_proto_rawDesc = "" +
	"\n" +
	":services/propagation/propagation_api/propagation_api.proto\x12\x0fpropagation_api\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x12errors/error.proto\"\x0e\n" +
	"\fEmptyMessage\"t\n" +
	"\x0eHealthResponse\x12\x0e\n" +
	"\x02ok\x18\x01 \x01(\bR\x02ok\x12\x18\n" +
	"\adetails\x18\x02 \x01(\tR\adetails\x128\n" +
	"\ttimestamp\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\" \n" +
	"\n" +
	"GetRequest\x12\x12\n" +
	"\x04txid\x18\x01 \x01(\fR\x04txid\"\x1d\n" +
	"\vGetResponse\x12\x0e\n" +
	"\x02tx\x18\x01 \x01(\fR\x02tx\"+\n" +
	"\x19ProcessTransactionRequest\x12\x0e\n" +
	"\x02tx\x18\x01 \x01(\fR\x02tx\"\xc5\x01\n" +
	"\x14BatchTransactionItem\x12\x0e\n" +
	"\x02tx\x18\x01 \x01(\fR\x02tx\x12\\\n" +
	"\rtrace_context\x18\x02 \x03(\v27.propagation_api.BatchTransactionItem.TraceContextEntryR\ftraceContext\x1a?\n" +
	"\x11TraceContextEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"]\n" +
	"\x1eProcessTransactionBatchRequest\x12;\n" +
	"\x05items\x18\x01 \x03(\v2%.propagation_api.BatchTransactionItemR\x05items\"I\n" +
	"\x1fProcessTransactionBatchResponse\x12&\n" +
	"\x06errors\x18\x01 \x03(\v2\x0e.errors.TErrorR\x06errors2\xc3\x02\n" +
	"\x0ePropagationAPI\x12N\n" +
	"\n" +
	"HealthGRPC\x12\x1d.propagation_api.EmptyMessage\x1a\x1f.propagation_api.HealthResponse\"\x00\x12a\n" +
	"\x12ProcessTransaction\x12*.propagation_api.ProcessTransactionRequest\x1a\x1d.propagation_api.EmptyMessage\"\x00\x12~\n" +
	"\x17ProcessTransactionBatch\x12/.propagation_api.ProcessTransactionBatchRequest\x1a0.propagation_api.ProcessTransactionBatchResponse\"\x00B\x14Z\x12./;propagation_apib\x06proto3"

var (
	file_services_propagation_propagation_api_propagation_api_proto_rawDescOnce sync.Once
	file_services_propagation_propagation_api_propagation_api_proto_rawDescData []byte
)

func file_services_propagation_propagation_api_propagation_api_proto_rawDescGZIP() []byte {
	file_services_propagation_propagation_api_propagation_api_proto_rawDescOnce.Do(func() {
		file_services_propagation_propagation_api_propagation_api_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_services_propagation_propagation_api_propagation_api_proto_rawDesc), len(file_services_propagation_propagation_api_propagation_api_proto_rawDesc)))
	})
	return file_services_propagation_propagation_api_propagation_api_proto_rawDescData
}

var file_services_propagation_propagation_api_propagation_api_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
var file_services_propagation_propagation_api_propagation_api_proto_goTypes = []any{
	(*EmptyMessage)(nil),                    // 0: propagation_api.EmptyMessage
	(*HealthResponse)(nil),                  // 1: propagation_api.HealthResponse
	(*GetRequest)(nil),                      // 2: propagation_api.GetRequest
	(*GetResponse)(nil),                     // 3: propagation_api.GetResponse
	(*ProcessTransactionRequest)(nil),       // 4: propagation_api.ProcessTransactionRequest
	(*BatchTransactionItem)(nil),            // 5: propagation_api.BatchTransactionItem
	(*ProcessTransactionBatchRequest)(nil),  // 6: propagation_api.ProcessTransactionBatchRequest
	(*ProcessTransactionBatchResponse)(nil), // 7: propagation_api.ProcessTransactionBatchResponse
	nil,                                     // 8: propagation_api.BatchTransactionItem.TraceContextEntry
	(*timestamppb.Timestamp)(nil),           // 9: google.protobuf.Timestamp
	(*errors.TError)(nil),                   // 10: errors.TError
}
var file_services_propagation_propagation_api_propagation_api_proto_depIdxs = []int32{
	9,  // 0: propagation_api.HealthResponse.timestamp:type_name -> google.protobuf.Timestamp
	8,  // 1: propagation_api.BatchTransactionItem.trace_context:type_name -> propagation_api.BatchTransactionItem.TraceContextEntry
	5,  // 2: propagation_api.ProcessTransactionBatchRequest.items:type_name -> propagation_api.BatchTransactionItem
	10, // 3: propagation_api.ProcessTransactionBatchResponse.errors:type_name -> errors.TError
	0,  // 4: propagation_api.PropagationAPI.HealthGRPC:input_type -> propagation_api.EmptyMessage
	4,  // 5: propagation_api.PropagationAPI.ProcessTransaction:input_type -> propagation_api.ProcessTransactionRequest
	6,  // 6: propagation_api.PropagationAPI.ProcessTransactionBatch:input_type -> propagation_api.ProcessTransactionBatchRequest
	1,  // 7: propagation_api.PropagationAPI.HealthGRPC:output_type -> propagation_api.HealthResponse
	0,  // 8: propagation_api.PropagationAPI.ProcessTransaction:output_type -> propagation_api.EmptyMessage
	7,  // 9: propagation_api.PropagationAPI.ProcessTransactionBatch:output_type -> propagation_api.ProcessTransactionBatchResponse
	7,  // [7:10] is the sub-list for method output_type
	4,  // [4:7] is the sub-list for method input_type
	4,  // [4:4] is the sub-list for extension type_name
	4,  // [4:4] is the sub-list for extension extendee
	0,  // [0:4] is the sub-list for field type_name
}

func init() { file_services_propagation_propagation_api_propagation_api_proto_init() }
func file_services_propagation_propagation_api_propagation_api_proto_init() {
	if File_services_propagation_propagation_api_propagation_api_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_services_propagation_propagation_api_propagation_api_proto_rawDesc), len(file_services_propagation_propagation_api_propagation_api_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   9,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_services_propagation_propagation_api_propagation_api_proto_goTypes,
		DependencyIndexes: file_services_propagation_propagation_api_propagation_api_proto_depIdxs,
		MessageInfos:      file_services_propagation_propagation_api_propagation_api_proto_msgTypes,
	}.Build()
	File_services_propagation_propagation_api_propagation_api_proto = out.File
	file_services_propagation_propagation_api_propagation_api_proto_goTypes = nil
	file_services_propagation_propagation_api_propagation_api_proto_depIdxs = nil
}
