github.com/hyperledger/fabric-protos-go@v0.3.3/gateway/gateway.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: gateway/gateway.proto

package gateway

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	common "github.com/hyperledger/fabric-protos-go/common"
	orderer "github.com/hyperledger/fabric-protos-go/orderer"
	peer "github.com/hyperledger/fabric-protos-go/peer"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

// EndorseRequest contains the details required to obtain sufficient endorsements for a
// transaction to be committed to the ledger.
type EndorseRequest struct {
	// The unique identifier for the transaction.
	TransactionId string `protobuf:"bytes,1,opt,name=transaction_id,json=transactionId,proto3" json:"transaction_id,omitempty"`
	// Identifier of the channel this request is bound for.
	ChannelId string `protobuf:"bytes,2,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	// The signed proposal ready for endorsement.
	ProposedTransaction *peer.SignedProposal `protobuf:"bytes,3,opt,name=proposed_transaction,json=proposedTransaction,proto3" json:"proposed_transaction,omitempty"`
	// If targeting the peers of specific organizations (e.g. for private data scenarios),
	// the list of organizations' MSPIDs should be supplied here.
	EndorsingOrganizations []string `protobuf:"bytes,4,rep,name=endorsing_organizations,json=endorsingOrganizations,proto3" json:"endorsing_organizations,omitempty"`
	XXX_NoUnkeyedLiteral   struct{} `json:"-"`
	XXX_unrecognized       []byte   `json:"-"`
	XXX_sizecache          int32    `json:"-"`
}

func (m *EndorseRequest) Reset()         { *m = EndorseRequest{} }
func (m *EndorseRequest) String() string { return proto.CompactTextString(m) }
func (*EndorseRequest) ProtoMessage()    {}
func (*EndorseRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{0}
}

func (m *EndorseRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EndorseRequest.Unmarshal(m, b)
}
func (m *EndorseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EndorseRequest.Marshal(b, m, deterministic)
}
func (m *EndorseRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EndorseRequest.Merge(m, src)
}
func (m *EndorseRequest) XXX_Size() int {
	return xxx_messageInfo_EndorseRequest.Size(m)
}
func (m *EndorseRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_EndorseRequest.DiscardUnknown(m)
}

var xxx_messageInfo_EndorseRequest proto.InternalMessageInfo

func (m *EndorseRequest) GetTransactionId() string {
	if m != nil {
		return m.TransactionId
	}
	return ""
}

func (m *EndorseRequest) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

func (m *EndorseRequest) GetProposedTransaction() *peer.SignedProposal {
	if m != nil {
		return m.ProposedTransaction
	}
	return nil
}

func (m *EndorseRequest) GetEndorsingOrganizations() []string {
	if m != nil {
		return m.EndorsingOrganizations
	}
	return nil
}

// EndorseResponse returns the result of endorsing a transaction.
type EndorseResponse struct {
	// The unsigned set of transaction responses from the endorsing peers for signing by the client
	// before submitting to ordering service (via gateway).
	PreparedTransaction  *common.Envelope `protobuf:"bytes,1,opt,name=prepared_transaction,json=preparedTransaction,proto3" json:"prepared_transaction,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *EndorseResponse) Reset()         { *m = EndorseResponse{} }
func (m *EndorseResponse) String() string { return proto.CompactTextString(m) }
func (*EndorseResponse) ProtoMessage()    {}
func (*EndorseResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{1}
}

func (m *EndorseResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EndorseResponse.Unmarshal(m, b)
}
func (m *EndorseResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EndorseResponse.Marshal(b, m, deterministic)
}
func (m *EndorseResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EndorseResponse.Merge(m, src)
}
func (m *EndorseResponse) XXX_Size() int {
	return xxx_messageInfo_EndorseResponse.Size(m)
}
func (m *EndorseResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_EndorseResponse.DiscardUnknown(m)
}

var xxx_messageInfo_EndorseResponse proto.InternalMessageInfo

func (m *EndorseResponse) GetPreparedTransaction() *common.Envelope {
	if m != nil {
		return m.PreparedTransaction
	}
	return nil
}

// SubmitRequest contains the details required to submit a transaction (update the ledger).
type SubmitRequest struct {
	// Identifier of the transaction to submit.
	TransactionId string `protobuf:"bytes,1,opt,name=transaction_id,json=transactionId,proto3" json:"transaction_id,omitempty"`
	// Identifier of the channel this request is bound for.
	ChannelId string `protobuf:"bytes,2,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	// The signed set of endorsed transaction responses to submit.
	PreparedTransaction  *common.Envelope `protobuf:"bytes,3,opt,name=prepared_transaction,json=preparedTransaction,proto3" json:"prepared_transaction,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *SubmitRequest) Reset()         { *m = SubmitRequest{} }
func (m *SubmitRequest) String() string { return proto.CompactTextString(m) }
func (*SubmitRequest) ProtoMessage()    {}
func (*SubmitRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{2}
}

func (m *SubmitRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SubmitRequest.Unmarshal(m, b)
}
func (m *SubmitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SubmitRequest.Marshal(b, m, deterministic)
}
func (m *SubmitRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubmitRequest.Merge(m, src)
}
func (m *SubmitRequest) XXX_Size() int {
	return xxx_messageInfo_SubmitRequest.Size(m)
}
func (m *SubmitRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SubmitRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SubmitRequest proto.InternalMessageInfo

func (m *SubmitRequest) GetTransactionId() string {
	if m != nil {
		return m.TransactionId
	}
	return ""
}

func (m *SubmitRequest) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

func (m *SubmitRequest) GetPreparedTransaction() *common.Envelope {
	if m != nil {
		return m.PreparedTransaction
	}
	return nil
}

// SubmitResponse returns the result of submitting a transaction.
type SubmitResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SubmitResponse) Reset()         { *m = SubmitResponse{} }
func (m *SubmitResponse) String() string { return proto.CompactTextString(m) }
func (*SubmitResponse) ProtoMessage()    {}
func (*SubmitResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{3}
}

func (m *SubmitResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SubmitResponse.Unmarshal(m, b)
}
func (m *SubmitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SubmitResponse.Marshal(b, m, deterministic)
}
func (m *SubmitResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubmitResponse.Merge(m, src)
}
func (m *SubmitResponse) XXX_Size() int {
	return xxx_messageInfo_SubmitResponse.Size(m)
}
func (m *SubmitResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SubmitResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SubmitResponse proto.InternalMessageInfo

// SignedCommitStatusRequest contains a serialized CommitStatusRequest message, and a digital signature for the
// serialized request message.
type SignedCommitStatusRequest struct {
	// Serialized CommitStatusRequest message.
	Request []byte `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
	// Signature for request message.
	Signature            []byte   `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SignedCommitStatusRequest) Reset()         { *m = SignedCommitStatusRequest{} }
func (m *SignedCommitStatusRequest) String() string { return proto.CompactTextString(m) }
func (*SignedCommitStatusRequest) ProtoMessage()    {}
func (*SignedCommitStatusRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{4}
}

func (m *SignedCommitStatusRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SignedCommitStatusRequest.Unmarshal(m, b)
}
func (m *SignedCommitStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SignedCommitStatusRequest.Marshal(b, m, deterministic)
}
func (m *SignedCommitStatusRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignedCommitStatusRequest.Merge(m, src)
}
func (m *SignedCommitStatusRequest) XXX_Size() int {
	return xxx_messageInfo_SignedCommitStatusRequest.Size(m)
}
func (m *SignedCommitStatusRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SignedCommitStatusRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SignedCommitStatusRequest proto.InternalMessageInfo

func (m *SignedCommitStatusRequest) GetRequest() []byte {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *SignedCommitStatusRequest) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

// CommitStatusRequest contains the details required to check whether a transaction has been
// successfully committed.
type CommitStatusRequest struct {
	// Identifier of the transaction to check.
	TransactionId string `protobuf:"bytes,1,opt,name=transaction_id,json=transactionId,proto3" json:"transaction_id,omitempty"`
	// Identifier of the channel this request is bound for.
	ChannelId string `protobuf:"bytes,2,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	// Client requestor identity.
	Identity             []byte   `protobuf:"bytes,3,opt,name=identity,proto3" json:"identity,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CommitStatusRequest) Reset()         { *m = CommitStatusRequest{} }
func (m *CommitStatusRequest) String() string { return proto.CompactTextString(m) }
func (*CommitStatusRequest) ProtoMessage()    {}
func (*CommitStatusRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{5}
}

func (m *CommitStatusRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitStatusRequest.Unmarshal(m, b)
}
func (m *CommitStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitStatusRequest.Marshal(b, m, deterministic)
}
func (m *CommitStatusRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitStatusRequest.Merge(m, src)
}
func (m *CommitStatusRequest) XXX_Size() int {
	return xxx_messageInfo_CommitStatusRequest.Size(m)
}
func (m *CommitStatusRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitStatusRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CommitStatusRequest proto.InternalMessageInfo

func (m *CommitStatusRequest) GetTransactionId() string {
	if m != nil {
		return m.TransactionId
	}
	return ""
}

func (m *CommitStatusRequest) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

func (m *CommitStatusRequest) GetIdentity() []byte {
	if m != nil {
		return m.Identity
	}
	return nil
}

// CommitStatusResponse returns the result of committing a transaction.
type CommitStatusResponse struct {
	// The result of the transaction commit, as defined in peer/transaction.proto.
	Result peer.TxValidationCode `protobuf:"varint,1,opt,name=result,proto3,enum=protos.TxValidationCode" json:"result,omitempty"`
	// Block number that contains the transaction.
	BlockNumber          uint64   `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CommitStatusResponse) Reset()         { *m = CommitStatusResponse{} }
func (m *CommitStatusResponse) String() string { return proto.CompactTextString(m) }
func (*CommitStatusResponse) ProtoMessage()    {}
func (*CommitStatusResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{6}
}

func (m *CommitStatusResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CommitStatusResponse.Unmarshal(m, b)
}
func (m *CommitStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CommitStatusResponse.Marshal(b, m, deterministic)
}
func (m *CommitStatusResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitStatusResponse.Merge(m, src)
}
func (m *CommitStatusResponse) XXX_Size() int {
	return xxx_messageInfo_CommitStatusResponse.Size(m)
}
func (m *CommitStatusResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitStatusResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CommitStatusResponse proto.InternalMessageInfo

func (m *CommitStatusResponse) GetResult() peer.TxValidationCode {
	if m != nil {
		return m.Result
	}
	return peer.TxValidationCode_VALID
}

func (m *CommitStatusResponse) GetBlockNumber() uint64 {
	if m != nil {
		return m.BlockNumber
	}
	return 0
}

// EvaluateRequest contains the details required to evaluate a transaction (query the ledger).
type EvaluateRequest struct {
	// Identifier of the transaction to evaluate.
	TransactionId string `protobuf:"bytes,1,opt,name=transaction_id,json=transactionId,proto3" json:"transaction_id,omitempty"`
	// Identifier of the channel this request is bound for.
	ChannelId string `protobuf:"bytes,2,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	// The signed proposal ready for evaluation.
	ProposedTransaction *peer.SignedProposal `protobuf:"bytes,3,opt,name=proposed_transaction,json=proposedTransaction,proto3" json:"proposed_transaction,omitempty"`
	// If targeting the peers of specific organizations (e.g. for private data scenarios),
	// the list of organizations' MSPIDs should be supplied here.
	TargetOrganizations  []string `protobuf:"bytes,4,rep,name=target_organizations,json=targetOrganizations,proto3" json:"target_organizations,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EvaluateRequest) Reset()         { *m = EvaluateRequest{} }
func (m *EvaluateRequest) String() string { return proto.CompactTextString(m) }
func (*EvaluateRequest) ProtoMessage()    {}
func (*EvaluateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{7}
}

func (m *EvaluateRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EvaluateRequest.Unmarshal(m, b)
}
func (m *EvaluateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EvaluateRequest.Marshal(b, m, deterministic)
}
func (m *EvaluateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EvaluateRequest.Merge(m, src)
}
func (m *EvaluateRequest) XXX_Size() int {
	return xxx_messageInfo_EvaluateRequest.Size(m)
}
func (m *EvaluateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_EvaluateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_EvaluateRequest proto.InternalMessageInfo

func (m *EvaluateRequest) GetTransactionId() string {
	if m != nil {
		return m.TransactionId
	}
	return ""
}

func (m *EvaluateRequest) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

func (m *EvaluateRequest) GetProposedTransaction() *peer.SignedProposal {
	if m != nil {
		return m.ProposedTransaction
	}
	return nil
}

func (m *EvaluateRequest) GetTargetOrganizations() []string {
	if m != nil {
		return m.TargetOrganizations
	}
	return nil
}

// EvaluateResponse returns the result of evaluating a transaction.
type EvaluateResponse struct {
	// The response that is returned by the transaction function, as defined
	// in peer/proposal_response.proto.
	Result               *peer.Response `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *EvaluateResponse) Reset()         { *m = EvaluateResponse{} }
func (m *EvaluateResponse) String() string { return proto.CompactTextString(m) }
func (*EvaluateResponse) ProtoMessage()    {}
func (*EvaluateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{8}
}

func (m *EvaluateResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EvaluateResponse.Unmarshal(m, b)
}
func (m *EvaluateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EvaluateResponse.Marshal(b, m, deterministic)
}
func (m *EvaluateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EvaluateResponse.Merge(m, src)
}
func (m *EvaluateResponse) XXX_Size() int {
	return xxx_messageInfo_EvaluateResponse.Size(m)
}
func (m *EvaluateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_EvaluateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_EvaluateResponse proto.InternalMessageInfo

func (m *EvaluateResponse) GetResult() *peer.Response {
	if m != nil {
		return m.Result
	}
	return nil
}

// SignedChaincodeEventsRequest contains a serialized ChaincodeEventsRequest message, and a digital signature for the
// serialized request message.
type SignedChaincodeEventsRequest struct {
	// Serialized ChaincodeEventsRequest message.
	Request []byte `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
	// Signature for request message.
	Signature            []byte   `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SignedChaincodeEventsRequest) Reset()         { *m = SignedChaincodeEventsRequest{} }
func (m *SignedChaincodeEventsRequest) String() string { return proto.CompactTextString(m) }
func (*SignedChaincodeEventsRequest) ProtoMessage()    {}
func (*SignedChaincodeEventsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{9}
}

func (m *SignedChaincodeEventsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SignedChaincodeEventsRequest.Unmarshal(m, b)
}
func (m *SignedChaincodeEventsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SignedChaincodeEventsRequest.Marshal(b, m, deterministic)
}
func (m *SignedChaincodeEventsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignedChaincodeEventsRequest.Merge(m, src)
}
func (m *SignedChaincodeEventsRequest) XXX_Size() int {
	return xxx_messageInfo_SignedChaincodeEventsRequest.Size(m)
}
func (m *SignedChaincodeEventsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SignedChaincodeEventsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SignedChaincodeEventsRequest proto.InternalMessageInfo

func (m *SignedChaincodeEventsRequest) GetRequest() []byte {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *SignedChaincodeEventsRequest) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

// ChaincodeEventsRequest contains details of the chaincode events that the caller wants to receive.
type ChaincodeEventsRequest struct {
	// Identifier of the channel this request is bound for.
	ChannelId string `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	// Name of the chaincode for which events are requested.
	ChaincodeId string `protobuf:"bytes,2,opt,name=chaincode_id,json=chaincodeId,proto3" json:"chaincode_id,omitempty"`
	// Client requestor identity.
	Identity []byte `protobuf:"bytes,3,opt,name=identity,proto3" json:"identity,omitempty"`
	// Position within the ledger at which to start reading events.
	StartPosition *orderer.SeekPosition `protobuf:"bytes,4,opt,name=start_position,json=startPosition,proto3" json:"start_position,omitempty"`
	// Only returns events after this transaction ID. Transactions up to and including this one should be ignored. This
	// is used to allow resume of event listening from a certain position within a start block specified by
	// start_position.
	AfterTransactionId   string   `protobuf:"bytes,5,opt,name=after_transaction_id,json=afterTransactionId,proto3" json:"after_transaction_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ChaincodeEventsRequest) Reset()         { *m = ChaincodeEventsRequest{} }
func (m *ChaincodeEventsRequest) String() string { return proto.CompactTextString(m) }
func (*ChaincodeEventsRequest) ProtoMessage()    {}
func (*ChaincodeEventsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{10}
}

func (m *ChaincodeEventsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChaincodeEventsRequest.Unmarshal(m, b)
}
func (m *ChaincodeEventsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChaincodeEventsRequest.Marshal(b, m, deterministic)
}
func (m *ChaincodeEventsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChaincodeEventsRequest.Merge(m, src)
}
func (m *ChaincodeEventsRequest) XXX_Size() int {
	return xxx_messageInfo_ChaincodeEventsRequest.Size(m)
}
func (m *ChaincodeEventsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ChaincodeEventsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ChaincodeEventsRequest proto.InternalMessageInfo

func (m *ChaincodeEventsRequest) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

func (m *ChaincodeEventsRequest) GetChaincodeId() string {
	if m != nil {
		return m.ChaincodeId
	}
	return ""
}

func (m *ChaincodeEventsRequest) GetIdentity() []byte {
	if m != nil {
		return m.Identity
	}
	return nil
}

func (m *ChaincodeEventsRequest) GetStartPosition() *orderer.SeekPosition {
	if m != nil {
		return m.StartPosition
	}
	return nil
}

func (m *ChaincodeEventsRequest) GetAfterTransactionId() string {
	if m != nil {
		return m.AfterTransactionId
	}
	return ""
}

// ChaincodeEventsResponse returns chaincode events emitted from a specific block.
type ChaincodeEventsResponse struct {
	// Chaincode events emitted by the requested chaincode. The events are presented in the same order that the
	// transactions that emitted them appear within the block.
	Events []*peer.ChaincodeEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
	// Block number in which the chaincode events were emitted.
	BlockNumber          uint64   `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ChaincodeEventsResponse) Reset()         { *m = ChaincodeEventsResponse{} }
func (m *ChaincodeEventsResponse) String() string { return proto.CompactTextString(m) }
func (*ChaincodeEventsResponse) ProtoMessage()    {}
func (*ChaincodeEventsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{11}
}

func (m *ChaincodeEventsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChaincodeEventsResponse.Unmarshal(m, b)
}
func (m *ChaincodeEventsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChaincodeEventsResponse.Marshal(b, m, deterministic)
}
func (m *ChaincodeEventsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChaincodeEventsResponse.Merge(m, src)
}
func (m *ChaincodeEventsResponse) XXX_Size() int {
	return xxx_messageInfo_ChaincodeEventsResponse.Size(m)
}
func (m *ChaincodeEventsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ChaincodeEventsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ChaincodeEventsResponse proto.InternalMessageInfo

func (m *ChaincodeEventsResponse) GetEvents() []*peer.ChaincodeEvent {
	if m != nil {
		return m.Events
	}
	return nil
}

func (m *ChaincodeEventsResponse) GetBlockNumber() uint64 {
	if m != nil {
		return m.BlockNumber
	}
	return 0
}

// If any of the functions in the Gateway service returns an error, then it will be in the format of
// a google.rpc.Status message. The 'details' field of this message will be populated with extra
// information if the error is a result of one or more failed requests to remote peers or orderer nodes.
// ErrorDetail contains details of errors that are received by any of the endorsing peers
// as a result of processing the Evaluate or Endorse services, or from the ordering node(s) as a result of
// processing the Submit service.
type ErrorDetail struct {
	// The address of the endorsing peer or ordering node that returned an error.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// The MSP Identifier of this node.
	MspId string `protobuf:"bytes,2,opt,name=msp_id,json=mspId,proto3" json:"msp_id,omitempty"`
	// The error message returned by this node.
	Message              string   `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ErrorDetail) Reset()         { *m = ErrorDetail{} }
func (m *ErrorDetail) String() string { return proto.CompactTextString(m) }
func (*ErrorDetail) ProtoMessage()    {}
func (*ErrorDetail) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{12}
}

func (m *ErrorDetail) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ErrorDetail.Unmarshal(m, b)
}
func (m *ErrorDetail) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ErrorDetail.Marshal(b, m, deterministic)
}
func (m *ErrorDetail) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ErrorDetail.Merge(m, src)
}
func (m *ErrorDetail) XXX_Size() int {
	return xxx_messageInfo_ErrorDetail.Size(m)
}
func (m *ErrorDetail) XXX_DiscardUnknown() {
	xxx_messageInfo_ErrorDetail.DiscardUnknown(m)
}

var xxx_messageInfo_ErrorDetail proto.InternalMessageInfo

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

func (m *ErrorDetail) GetMspId() string {
	if m != nil {
		return m.MspId
	}
	return ""
}

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

// ProposedTransaction contains the details required for offline signing prior to evaluating or endorsing
// a transaction.
type ProposedTransaction struct {
	// Identifier of the proposed transaction.
	TransactionId string `protobuf:"bytes,1,opt,name=transaction_id,json=transactionId,proto3" json:"transaction_id,omitempty"`
	// The signed proposal.
	Proposal *peer.SignedProposal `protobuf:"bytes,2,opt,name=proposal,proto3" json:"proposal,omitempty"`
	// The list of endorsing organizations.
	EndorsingOrganizations []string `protobuf:"bytes,3,rep,name=endorsing_organizations,json=endorsingOrganizations,proto3" json:"endorsing_organizations,omitempty"`
	XXX_NoUnkeyedLiteral   struct{} `json:"-"`
	XXX_unrecognized       []byte   `json:"-"`
	XXX_sizecache          int32    `json:"-"`
}

func (m *ProposedTransaction) Reset()         { *m = ProposedTransaction{} }
func (m *ProposedTransaction) String() string { return proto.CompactTextString(m) }
func (*ProposedTransaction) ProtoMessage()    {}
func (*ProposedTransaction) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{13}
}

func (m *ProposedTransaction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProposedTransaction.Unmarshal(m, b)
}
func (m *ProposedTransaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProposedTransaction.Marshal(b, m, deterministic)
}
func (m *ProposedTransaction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProposedTransaction.Merge(m, src)
}
func (m *ProposedTransaction) XXX_Size() int {
	return xxx_messageInfo_ProposedTransaction.Size(m)
}
func (m *ProposedTransaction) XXX_DiscardUnknown() {
	xxx_messageInfo_ProposedTransaction.DiscardUnknown(m)
}

var xxx_messageInfo_ProposedTransaction proto.InternalMessageInfo

func (m *ProposedTransaction) GetTransactionId() string {
	if m != nil {
		return m.TransactionId
	}
	return ""
}

func (m *ProposedTransaction) GetProposal() *peer.SignedProposal {
	if m != nil {
		return m.Proposal
	}
	return nil
}

func (m *ProposedTransaction) GetEndorsingOrganizations() []string {
	if m != nil {
		return m.EndorsingOrganizations
	}
	return nil
}

// PreparedTransaction contains the details required for offline signing prior to submitting a transaction.
type PreparedTransaction struct {
	// Identifier of the prepared transaction.
	TransactionId string `protobuf:"bytes,1,opt,name=transaction_id,json=transactionId,proto3" json:"transaction_id,omitempty"`
	// The transaction envelope.
	Envelope             *common.Envelope `protobuf:"bytes,2,opt,name=envelope,proto3" json:"envelope,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *PreparedTransaction) Reset()         { *m = PreparedTransaction{} }
func (m *PreparedTransaction) String() string { return proto.CompactTextString(m) }
func (*PreparedTransaction) ProtoMessage()    {}
func (*PreparedTransaction) Descriptor() ([]byte, []int) {
	return fileDescriptor_285396c8df15061f, []int{14}
}

func (m *PreparedTransaction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PreparedTransaction.Unmarshal(m, b)
}
func (m *PreparedTransaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PreparedTransaction.Marshal(b, m, deterministic)
}
func (m *PreparedTransaction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PreparedTransaction.Merge(m, src)
}
func (m *PreparedTransaction) XXX_Size() int {
	return xxx_messageInfo_PreparedTransaction.Size(m)
}
func (m *PreparedTransaction) XXX_DiscardUnknown() {
	xxx_messageInfo_PreparedTransaction.DiscardUnknown(m)
}

var xxx_messageInfo_PreparedTransaction proto.InternalMessageInfo

func (m *PreparedTransaction) GetTransactionId() string {
	if m != nil {
		return m.TransactionId
	}
	return ""
}

func (m *PreparedTransaction) GetEnvelope() *common.Envelope {
	if m != nil {
		return m.Envelope
	}
	return nil
}

func init() {
	proto.RegisterType((*EndorseRequest)(nil), "gateway.EndorseRequest")
	proto.RegisterType((*EndorseResponse)(nil), "gateway.EndorseResponse")
	proto.RegisterType((*SubmitRequest)(nil), "gateway.SubmitRequest")
	proto.RegisterType((*SubmitResponse)(nil), "gateway.SubmitResponse")
	proto.RegisterType((*SignedCommitStatusRequest)(nil), "gateway.SignedCommitStatusRequest")
	proto.RegisterType((*CommitStatusRequest)(nil), "gateway.CommitStatusRequest")
	proto.RegisterType((*CommitStatusResponse)(nil), "gateway.CommitStatusResponse")
	proto.RegisterType((*EvaluateRequest)(nil), "gateway.EvaluateRequest")
	proto.RegisterType((*EvaluateResponse)(nil), "gateway.EvaluateResponse")
	proto.RegisterType((*SignedChaincodeEventsRequest)(nil), "gateway.SignedChaincodeEventsRequest")
	proto.RegisterType((*ChaincodeEventsRequest)(nil), "gateway.ChaincodeEventsRequest")
	proto.RegisterType((*ChaincodeEventsResponse)(nil), "gateway.ChaincodeEventsResponse")
	proto.RegisterType((*ErrorDetail)(nil), "gateway.ErrorDetail")
	proto.RegisterType((*ProposedTransaction)(nil), "gateway.ProposedTransaction")
	proto.RegisterType((*PreparedTransaction)(nil), "gateway.PreparedTransaction")
}

func init() { proto.RegisterFile("gateway/gateway.proto", fileDescriptor_285396c8df15061f) }

var fileDescriptor_285396c8df15061f = []byte{
	// 875 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xdd, 0x6e, 0xe3, 0x44,
	0x14, 0x96, 0x37, 0xdd, 0xb4, 0x39, 0x4d, 0xd3, 0x6a, 0xd2, 0xa6, 0x59, 0xab, 0x2b, 0x65, 0x2d,
	0x55, 0xea, 0x05, 0xeb, 0x94, 0x72, 0x81, 0x90, 0x2a, 0x21, 0x6d, 0x89, 0x50, 0x6f, 0x20, 0x38,
	0x55, 0x85, 0x10, 0x52, 0x34, 0x89, 0xcf, 0x3a, 0xa6, 0xb6, 0xc7, 0xcc, 0x8c, 0xbb, 0x94, 0x47,
	0xe1, 0x0d, 0x78, 0x20, 0x6e, 0x78, 0x00, 0x9e, 0x80, 0x07, 0x40, 0x1e, 0xcf, 0x38, 0x76, 0x92,
	0x56, 0x45, 0xec, 0x05, 0x57, 0xc9, 0x9c, 0x9f, 0x99, 0xef, 0x7c, 0xf3, 0xcd, 0x39, 0x86, 0xa3,
	0x80, 0x4a, 0xfc, 0x40, 0x1f, 0x86, 0xfa, 0xd7, 0x4d, 0x39, 0x93, 0x8c, 0x6c, 0xeb, 0xa5, 0x6d,
	0xa7, 0x88, 0x7c, 0x38, 0x5f, 0xd0, 0x30, 0x99, 0x33, 0x1f, 0xa7, 0x78, 0x8f, 0x89, 0x2c, 0x82,
	0xec, 0xae, 0xf2, 0xa5, 0x9c, 0xa5, 0x4c, 0xd0, 0x48, 0x1b, 0x4f, 0x6a, 0xc6, 0x29, 0x47, 0x91,
	0xb2, 0x44, 0xa0, 0xf6, 0xf6, 0x94, 0x57, 0x72, 0x9a, 0x08, 0x3a, 0x97, 0x21, 0x4b, 0xcc, 0x56,
	0x73, 0x16, 0xc7, 0x2c, 0x19, 0x16, 0x3f, 0xda, 0x78, 0xc0, 0xb8, 0x8f, 0x1c, 0xf9, 0x90, 0xce,
	0x0a, 0x8b, 0xf3, 0xa7, 0x05, 0x9d, 0x51, 0xe2, 0x33, 0x2e, 0xd0, 0xc3, 0x9f, 0x33, 0x14, 0x92,
	0x9c, 0x42, 0xa7, 0xb2, 0xdd, 0x34, 0xf4, 0xfb, 0xd6, 0xc0, 0x3a, 0x6b, 0x79, 0x7b, 0x15, 0xeb,
	0xb5, 0x4f, 0x5e, 0x03, 0xcc, 0x17, 0x34, 0x49, 0x30, 0xca, 0x43, 0x5e, 0xa8, 0x90, 0x96, 0xb6,
	0x5c, 0xfb, 0xe4, 0x1a, 0x0e, 0x0b, 0xc8, 0xe8, 0x4f, 0x2b, 0x89, 0xfd, 0xc6, 0xc0, 0x3a, 0xdb,
	0xbd, 0xe8, 0x15, 0xc7, 0x0b, 0x77, 0x12, 0x06, 0x09, 0xfa, 0x63, 0x5d, 0x9c, 0xd7, 0x35, 0x39,
	0x37, 0xcb, 0x14, 0xf2, 0x39, 0x1c, 0xa3, 0x82, 0x18, 0x26, 0xc1, 0x94, 0xf1, 0x80, 0x26, 0xe1,
	0xaf, 0x34, 0xf7, 0x88, 0xfe, 0xd6, 0xa0, 0x71, 0xd6, 0xf2, 0x7a, 0xa5, 0xfb, 0xdb, 0xaa, 0xd7,
	0xb9, 0x85, 0xfd, 0xb2, 0xb6, 0x82, 0x34, 0x72, 0x95, 0xc3, 0xc2, 0x94, 0xf2, 0x15, 0x58, 0x96,
	0x82, 0x75, 0xe0, 0x6a, 0xba, 0x46, 0xc9, 0x3d, 0x46, 0x2c, 0xc5, 0x1c, 0x50, 0x11, 0x5d, 0x01,
	0xe4, 0xfc, 0x66, 0xc1, 0xde, 0x24, 0x9b, 0xc5, 0xa1, 0xfc, 0xb8, 0x9c, 0x3d, 0x06, 0xae, 0xf1,
	0x6f, 0xc0, 0x1d, 0x40, 0xc7, 0x60, 0x2b, 0x6a, 0x76, 0x26, 0xf0, 0xaa, 0xa0, 0xf9, 0x8a, 0xc5,
	0x71, 0x28, 0x27, 0x92, 0xca, 0x4c, 0x18, 0xe4, 0x7d, 0xd8, 0xe6, 0xc5, 0x5f, 0x05, 0xb9, 0xed,
	0x99, 0x25, 0x39, 0x81, 0x96, 0x08, 0x83, 0x84, 0xca, 0x8c, 0xa3, 0xc2, 0xda, 0xf6, 0x96, 0x06,
	0xe7, 0x03, 0x74, 0x37, 0x6d, 0xf7, 0x71, 0x88, 0xb0, 0x61, 0x27, 0xf4, 0x31, 0x91, 0xa1, 0x7c,
	0x50, 0xc5, 0xb7, 0xbd, 0x72, 0xed, 0xdc, 0xc1, 0x61, 0xfd, 0x60, 0x7d, 0xb3, 0xe7, 0xd0, 0xe4,
	0x28, 0xb2, 0xa8, 0xa8, 0xa3, 0x73, 0xd1, 0x37, 0x12, 0xbb, 0xf9, 0xe5, 0x96, 0x46, 0xa1, 0xaf,
	0x34, 0x71, 0xc5, 0x7c, 0xf4, 0x74, 0x1c, 0x79, 0x03, 0xed, 0x59, 0xc4, 0xe6, 0x77, 0xd3, 0x24,
	0x8b, 0x67, 0xc8, 0x15, 0x8c, 0x2d, 0x6f, 0x57, 0xd9, 0xbe, 0x51, 0x26, 0xe7, 0x0f, 0x0b, 0xf6,
	0x47, 0xf7, 0x34, 0xca, 0xa8, 0xfc, 0xff, 0xbe, 0x8f, 0x4f, 0xe1, 0x50, 0x52, 0x1e, 0xa0, 0xdc,
	0xf8, 0x38, 0xba, 0x85, 0xaf, 0xfe, 0x32, 0x2e, 0xe1, 0x60, 0x59, 0x96, 0x26, 0xf0, 0xac, 0x46,
	0x60, 0xae, 0x37, 0x8d, 0xc1, 0x44, 0x18, 0xe2, 0x9c, 0x5b, 0x38, 0xd1, 0x82, 0x32, 0x5d, 0x6c,
	0x94, 0x37, 0xb1, 0xff, 0xac, 0xa9, 0xbf, 0x2c, 0xe8, 0x3d, 0xb2, 0x65, 0x9d, 0x4d, 0x6b, 0x95,
	0xcd, 0x37, 0xd0, 0x5e, 0x76, 0xd4, 0x92, 0xee, 0xdd, 0xd2, 0xf6, 0xb4, 0xa6, 0xc8, 0x25, 0x74,
	0x84, 0xa4, 0x5c, 0x4e, 0x53, 0x26, 0x42, 0x75, 0x0d, 0x5b, 0x8a, 0x82, 0x23, 0x57, 0x37, 0x4c,
	0x77, 0x82, 0x78, 0x37, 0xd6, 0x4e, 0x6f, 0x4f, 0x05, 0x9b, 0x25, 0x39, 0x87, 0x43, 0xfa, 0x5e,
	0x22, 0x9f, 0xae, 0xc8, 0xe2, 0xa5, 0x02, 0x41, 0x94, 0xef, 0xa6, 0xaa, 0x0d, 0x27, 0x82, 0xe3,
	0xb5, 0x3a, 0xf5, 0x2d, 0xb8, 0xd0, 0x54, 0x13, 0x41, 0xf4, 0xad, 0x41, 0xa3, 0xaa, 0x84, 0x7a,
	0x82, 0xa7, 0xa3, 0x9e, 0x23, 0xe2, 0xef, 0x61, 0x77, 0xc4, 0x39, 0xe3, 0x5f, 0xa1, 0xa4, 0x61,
	0x94, 0xdf, 0x0e, 0xf5, 0x7d, 0x8e, 0x42, 0x68, 0x1e, 0xcd, 0x92, 0x1c, 0x41, 0x33, 0x16, 0xe9,
	0x92, 0xbf, 0x97, 0xb1, 0x48, 0xaf, 0xfd, 0x3c, 0x21, 0x46, 0x21, 0x68, 0x80, 0x8a, 0xb8, 0x96,
	0x67, 0x96, 0xce, 0xef, 0x16, 0x74, 0xc7, 0x1b, 0x14, 0xf9, 0xcc, 0x27, 0x72, 0x01, 0x3b, 0x66,
	0xac, 0xa9, 0x13, 0x1f, 0xd7, 0x7d, 0x19, 0xf7, 0xd4, 0x30, 0x68, 0x3c, 0x39, 0x0c, 0x7e, 0xca,
	0xa1, 0xae, 0xb5, 0xcb, 0xe7, 0x42, 0xfd, 0x04, 0x76, 0x50, 0xb7, 0x5d, 0x0d, 0x75, 0xbd, 0x1d,
	0x97, 0x11, 0x17, 0x7f, 0xbf, 0x80, 0xed, 0xaf, 0x8b, 0x79, 0x4f, 0x2e, 0x61, 0x5b, 0x0f, 0x21,
	0x72, 0xec, 0x9a, 0x6f, 0x82, 0xfa, 0xc8, 0xb5, 0xfb, 0xeb, 0x0e, 0x2d, 0x87, 0x2f, 0xa0, 0x59,
	0x74, 0x73, 0xd2, 0x2b, 0x63, 0x6a, 0xa3, 0xc7, 0x3e, 0x5e, 0xb3, 0xeb, 0xd4, 0xef, 0xa0, 0x5d,
	0x6d, 0x94, 0xc4, 0x59, 0x06, 0x3e, 0x36, 0x0d, 0xec, 0xd7, 0x65, 0xcc, 0xc6, 0x1e, 0xfb, 0x25,
	0xec, 0x98, 0xb6, 0x41, 0x2a, 0x98, 0xeb, 0x0d, 0xd2, 0x7e, 0xb5, 0xc1, 0xa3, 0x37, 0xf8, 0x11,
	0xf6, 0x57, 0x84, 0x4f, 0x4e, 0x57, 0x61, 0x6d, 0x6c, 0x00, 0xf6, 0x60, 0x89, 0x6c, 0xf3, 0xcb,
	0x39, 0xb7, 0xde, 0x2d, 0xe0, 0x94, 0xf1, 0xc0, 0x5d, 0x3c, 0xa4, 0xc8, 0x23, 0xf4, 0x03, 0xe4,
	0xee, 0x7b, 0x3a, 0xe3, 0xe1, 0xdc, 0xa8, 0x4a, 0x6f, 0xf1, 0xae, 0xad, 0x2f, 0x67, 0x9c, 0x9b,
	0xc7, 0xd6, 0x0f, 0xc3, 0x20, 0x94, 0x8b, 0x6c, 0x96, 0xdf, 0xe8, 0xb0, 0x92, 0x3d, 0x2c, 0xb2,
	0xdf, 0x16, 0xd9, 0x6f, 0x03, 0x66, 0xbe, 0xe9, 0x66, 0x4d, 0x65, 0xfa, 0xec, 0x9f, 0x00, 0x00,
	0x00, 0xff, 0xff, 0x41, 0xfb, 0x4e, 0xca, 0xed, 0x09, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// GatewayClient is the client API for Gateway service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type GatewayClient interface {
	// The Endorse service passes a proposed transaction to the gateway in order to
	// obtain sufficient endorsement.
	// The gateway will determine the endorsement plan for the requested chaincode and
	// forward to the appropriate peers for endorsement. It will return to the client a
	// prepared transaction in the form of an Envelope message as defined
	// in common/common.proto. The client must sign the contents of this envelope
	// before invoking the Submit service.
	Endorse(ctx context.Context, in *EndorseRequest, opts ...grpc.CallOption) (*EndorseResponse, error)
	// The Submit service will process the prepared transaction returned from Endorse service
	// once it has been signed by the client. It will wait for the transaction to be submitted to the
	// ordering service but the client must invoke the CommitStatus service to wait for the transaction
	// to be committed.
	Submit(ctx context.Context, in *SubmitRequest, opts ...grpc.CallOption) (*SubmitResponse, error)
	// The CommitStatus service will indicate whether a prepared transaction previously submitted to
	// the Submit service has been committed. It will wait for the commit to occur if it hasn’t already
	// committed.
	CommitStatus(ctx context.Context, in *SignedCommitStatusRequest, opts ...grpc.CallOption) (*CommitStatusResponse, error)
	// The Evaluate service passes a proposed transaction to the gateway in order to invoke the
	// transaction function and return the result to the client. No ledger updates are made.
	// The gateway will select an appropriate peer to query based on block height and load.
	Evaluate(ctx context.Context, in *EvaluateRequest, opts ...grpc.CallOption) (*EvaluateResponse, error)
	// The ChaincodeEvents service supplies a stream of responses, each containing all the events emitted by the
	// requested chaincode for a specific block. The streamed responses are ordered by ascending block number. Responses
	// are only returned for blocks that contain the requested events, while blocks not containing any of the requested
	// events are skipped.
	ChaincodeEvents(ctx context.Context, in *SignedChaincodeEventsRequest, opts ...grpc.CallOption) (Gateway_ChaincodeEventsClient, error)
}

type gatewayClient struct {
	cc *grpc.ClientConn
}

func NewGatewayClient(cc *grpc.ClientConn) GatewayClient {
	return &gatewayClient{cc}
}

func (c *gatewayClient) Endorse(ctx context.Context, in *EndorseRequest, opts ...grpc.CallOption) (*EndorseResponse, error) {
	out := new(EndorseResponse)
	err := c.cc.Invoke(ctx, "/gateway.Gateway/Endorse", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gatewayClient) Submit(ctx context.Context, in *SubmitRequest, opts ...grpc.CallOption) (*SubmitResponse, error) {
	out := new(SubmitResponse)
	err := c.cc.Invoke(ctx, "/gateway.Gateway/Submit", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gatewayClient) CommitStatus(ctx context.Context, in *SignedCommitStatusRequest, opts ...grpc.CallOption) (*CommitStatusResponse, error) {
	out := new(CommitStatusResponse)
	err := c.cc.Invoke(ctx, "/gateway.Gateway/CommitStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gatewayClient) Evaluate(ctx context.Context, in *EvaluateRequest, opts ...grpc.CallOption) (*EvaluateResponse, error) {
	out := new(EvaluateResponse)
	err := c.cc.Invoke(ctx, "/gateway.Gateway/Evaluate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gatewayClient) ChaincodeEvents(ctx context.Context, in *SignedChaincodeEventsRequest, opts ...grpc.CallOption) (Gateway_ChaincodeEventsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Gateway_serviceDesc.Streams[0], "/gateway.Gateway/ChaincodeEvents", opts...)
	if err != nil {
		return nil, err
	}
	x := &gatewayChaincodeEventsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Gateway_ChaincodeEventsClient interface {
	Recv() (*ChaincodeEventsResponse, error)
	grpc.ClientStream
}

type gatewayChaincodeEventsClient struct {
	grpc.ClientStream
}

func (x *gatewayChaincodeEventsClient) Recv() (*ChaincodeEventsResponse, error) {
	m := new(ChaincodeEventsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// GatewayServer is the server API for Gateway service.
type GatewayServer interface {
	// The Endorse service passes a proposed transaction to the gateway in order to
	// obtain sufficient endorsement.
	// The gateway will determine the endorsement plan for the requested chaincode and
	// forward to the appropriate peers for endorsement. It will return to the client a
	// prepared transaction in the form of an Envelope message as defined
	// in common/common.proto. The client must sign the contents of this envelope
	// before invoking the Submit service.
	Endorse(context.Context, *EndorseRequest) (*EndorseResponse, error)
	// The Submit service will process the prepared transaction returned from Endorse service
	// once it has been signed by the client. It will wait for the transaction to be submitted to the
	// ordering service but the client must invoke the CommitStatus service to wait for the transaction
	// to be committed.
	Submit(context.Context, *SubmitRequest) (*SubmitResponse, error)
	// The CommitStatus service will indicate whether a prepared transaction previously submitted to
	// the Submit service has been committed. It will wait for the commit to occur if it hasn’t already
	// committed.
	CommitStatus(context.Context, *SignedCommitStatusRequest) (*CommitStatusResponse, error)
	// The Evaluate service passes a proposed transaction to the gateway in order to invoke the
	// transaction function and return the result to the client. No ledger updates are made.
	// The gateway will select an appropriate peer to query based on block height and load.
	Evaluate(context.Context, *EvaluateRequest) (*EvaluateResponse, error)
	// The ChaincodeEvents service supplies a stream of responses, each containing all the events emitted by the
	// requested chaincode for a specific block. The streamed responses are ordered by ascending block number. Responses
	// are only returned for blocks that contain the requested events, while blocks not containing any of the requested
	// events are skipped.
	ChaincodeEvents(*SignedChaincodeEventsRequest, Gateway_ChaincodeEventsServer) error
}

// UnimplementedGatewayServer can be embedded to have forward compatible implementations.
type UnimplementedGatewayServer struct {
}

func (*UnimplementedGatewayServer) Endorse(ctx context.Context, req *EndorseRequest) (*EndorseResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Endorse not implemented")
}
func (*UnimplementedGatewayServer) Submit(ctx context.Context, req *SubmitRequest) (*SubmitResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Submit not implemented")
}
func (*UnimplementedGatewayServer) CommitStatus(ctx context.Context, req *SignedCommitStatusRequest) (*CommitStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CommitStatus not implemented")
}
func (*UnimplementedGatewayServer) Evaluate(ctx context.Context, req *EvaluateRequest) (*EvaluateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Evaluate not implemented")
}
func (*UnimplementedGatewayServer) ChaincodeEvents(req *SignedChaincodeEventsRequest, srv Gateway_ChaincodeEventsServer) error {
	return status.Errorf(codes.Unimplemented, "method ChaincodeEvents not implemented")
}

func RegisterGatewayServer(s *grpc.Server, srv GatewayServer) {
	s.RegisterService(&_Gateway_serviceDesc, srv)
}

func _Gateway_Endorse_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EndorseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GatewayServer).Endorse(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gateway.Gateway/Endorse",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GatewayServer).Endorse(ctx, req.(*EndorseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Gateway_Submit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubmitRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GatewayServer).Submit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gateway.Gateway/Submit",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GatewayServer).Submit(ctx, req.(*SubmitRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Gateway_CommitStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedCommitStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GatewayServer).CommitStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gateway.Gateway/CommitStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GatewayServer).CommitStatus(ctx, req.(*SignedCommitStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Gateway_Evaluate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EvaluateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GatewayServer).Evaluate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gateway.Gateway/Evaluate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GatewayServer).Evaluate(ctx, req.(*EvaluateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Gateway_ChaincodeEvents_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SignedChaincodeEventsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GatewayServer).ChaincodeEvents(m, &gatewayChaincodeEventsServer{stream})
}

type Gateway_ChaincodeEventsServer interface {
	Send(*ChaincodeEventsResponse) error
	grpc.ServerStream
}

type gatewayChaincodeEventsServer struct {
	grpc.ServerStream
}

func (x *gatewayChaincodeEventsServer) Send(m *ChaincodeEventsResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _Gateway_serviceDesc = grpc.ServiceDesc{
	ServiceName: "gateway.Gateway",
	HandlerType: (*GatewayServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Endorse",
			Handler:    _Gateway_Endorse_Handler,
		},
		{
			MethodName: "Submit",
			Handler:    _Gateway_Submit_Handler,
		},
		{
			MethodName: "CommitStatus",
			Handler:    _Gateway_CommitStatus_Handler,
		},
		{
			MethodName: "Evaluate",
			Handler:    _Gateway_Evaluate_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ChaincodeEvents",
			Handler:       _Gateway_ChaincodeEvents_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "gateway/gateway.proto",
}