query.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: fury/strategicreserve/query.proto

package types

import (
	context "context"
	fmt "fmt"
	query "github.com/cosmos/cosmos-sdk/types/query"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// QueryParamsRequest is the request type for the Query/Params RPC method
// Query/Params RPC method.
type QueryParamsRequest struct {
}

func (m *QueryParamsRequest) Reset()         { *m = QueryParamsRequest{} }
func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryParamsRequest) ProtoMessage()    {}
func (*QueryParamsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{0}
}
func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParamsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParamsRequest.Merge(m, src)
}
func (m *QueryParamsRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryParamsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo

// QueryParamsResponse is the response type for the Query/Params RPC method
// Query/Params RPC method.
type QueryParamsResponse struct {
	// params holds all the parameters of this module.
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

func (m *QueryParamsResponse) Reset()         { *m = QueryParamsResponse{} }
func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryParamsResponse) ProtoMessage()    {}
func (*QueryParamsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{1}
}
func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParamsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParamsResponse.Merge(m, src)
}
func (m *QueryParamsResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryParamsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo

func (m *QueryParamsResponse) GetParams() Params {
	if m != nil {
		return m.Params
	}
	return Params{}
}

// QueryOrderBooksRequest is the request type for the Query/OrderBooks RPC
// method.
type QueryOrderBooksRequest struct {
	// status enables query for order books matching a given status.
	Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	// pagination defines optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryOrderBooksRequest) Reset()         { *m = QueryOrderBooksRequest{} }
func (m *QueryOrderBooksRequest) String() string { return proto.CompactTextString(m) }
func (*QueryOrderBooksRequest) ProtoMessage()    {}
func (*QueryOrderBooksRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{2}
}
func (m *QueryOrderBooksRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryOrderBooksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryOrderBooksRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryOrderBooksRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryOrderBooksRequest.Merge(m, src)
}
func (m *QueryOrderBooksRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryOrderBooksRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryOrderBooksRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryOrderBooksRequest proto.InternalMessageInfo

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

func (m *QueryOrderBooksRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryOrderBooksResponse is the response type for the Query/OrderBooks RPC
// method.
type QueryOrderBooksResponse struct {
	// orderbooks contains all the queried order books.
	Orderbooks []OrderBook `protobuf:"bytes,1,rep,name=orderbooks,proto3" json:"orderbooks"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryOrderBooksResponse) Reset()         { *m = QueryOrderBooksResponse{} }
func (m *QueryOrderBooksResponse) String() string { return proto.CompactTextString(m) }
func (*QueryOrderBooksResponse) ProtoMessage()    {}
func (*QueryOrderBooksResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{3}
}
func (m *QueryOrderBooksResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryOrderBooksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryOrderBooksResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryOrderBooksResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryOrderBooksResponse.Merge(m, src)
}
func (m *QueryOrderBooksResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryOrderBooksResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryOrderBooksResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryOrderBooksResponse proto.InternalMessageInfo

func (m *QueryOrderBooksResponse) GetOrderbooks() []OrderBook {
	if m != nil {
		return m.Orderbooks
	}
	return nil
}

func (m *QueryOrderBooksResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryOrderBookRequest is the request type for the Query/OrderBook RPC method.
type QueryOrderBookRequest struct {
	// order_book_uid defines the order book uid to query for.
	OrderBookUid string `protobuf:"bytes,1,opt,name=order_book_uid,json=orderBookUid,proto3" json:"order_book_uid,omitempty"`
}

func (m *QueryOrderBookRequest) Reset()         { *m = QueryOrderBookRequest{} }
func (m *QueryOrderBookRequest) String() string { return proto.CompactTextString(m) }
func (*QueryOrderBookRequest) ProtoMessage()    {}
func (*QueryOrderBookRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{4}
}
func (m *QueryOrderBookRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryOrderBookRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryOrderBookRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryOrderBookRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryOrderBookRequest.Merge(m, src)
}
func (m *QueryOrderBookRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryOrderBookRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryOrderBookRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryOrderBookRequest proto.InternalMessageInfo

func (m *QueryOrderBookRequest) GetOrderBookUid() string {
	if m != nil {
		return m.OrderBookUid
	}
	return ""
}

// QueryOrderBookResponse is the response type for the Query/OrderBook RPC
// method.
type QueryOrderBookResponse struct {
	// orderBook defines the order book info.
	OrderBook OrderBook `protobuf:"bytes,1,opt,name=order_book,json=orderBook,proto3" json:"order_book"`
}

func (m *QueryOrderBookResponse) Reset()         { *m = QueryOrderBookResponse{} }
func (m *QueryOrderBookResponse) String() string { return proto.CompactTextString(m) }
func (*QueryOrderBookResponse) ProtoMessage()    {}
func (*QueryOrderBookResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{5}
}
func (m *QueryOrderBookResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryOrderBookResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryOrderBookResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryOrderBookResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryOrderBookResponse.Merge(m, src)
}
func (m *QueryOrderBookResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryOrderBookResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryOrderBookResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryOrderBookResponse proto.InternalMessageInfo

func (m *QueryOrderBookResponse) GetOrderBook() OrderBook {
	if m != nil {
		return m.OrderBook
	}
	return OrderBook{}
}

// QueryOrderBookParticipationsRequest is the request type for the
// Query/OrderBookParticipations RPC method
type QueryOrderBookParticipationsRequest struct {
	// order_book_uid defines the order book universal unique identifier to query for.
	OrderBookUid string `protobuf:"bytes,1,opt,name=order_book_uid,json=orderBookUid,proto3" json:"order_book_uid,omitempty"`
	// pagination defines optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryOrderBookParticipationsRequest) Reset()         { *m = QueryOrderBookParticipationsRequest{} }
func (m *QueryOrderBookParticipationsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryOrderBookParticipationsRequest) ProtoMessage()    {}
func (*QueryOrderBookParticipationsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{6}
}
func (m *QueryOrderBookParticipationsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryOrderBookParticipationsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryOrderBookParticipationsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryOrderBookParticipationsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryOrderBookParticipationsRequest.Merge(m, src)
}
func (m *QueryOrderBookParticipationsRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryOrderBookParticipationsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryOrderBookParticipationsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryOrderBookParticipationsRequest proto.InternalMessageInfo

func (m *QueryOrderBookParticipationsRequest) GetOrderBookUid() string {
	if m != nil {
		return m.OrderBookUid
	}
	return ""
}

func (m *QueryOrderBookParticipationsRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryOrderBookParticipationsResponse is the response type for the
// Query/OrderBookParticipations RPC method
type QueryOrderBookParticipationsResponse struct {
	OrderBookParticipations []OrderBookParticipation `protobuf:"bytes,1,rep,name=order_book_participations,json=orderBookParticipations,proto3" json:"order_book_participations"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryOrderBookParticipationsResponse) Reset()         { *m = QueryOrderBookParticipationsResponse{} }
func (m *QueryOrderBookParticipationsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryOrderBookParticipationsResponse) ProtoMessage()    {}
func (*QueryOrderBookParticipationsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{7}
}
func (m *QueryOrderBookParticipationsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryOrderBookParticipationsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryOrderBookParticipationsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryOrderBookParticipationsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryOrderBookParticipationsResponse.Merge(m, src)
}
func (m *QueryOrderBookParticipationsResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryOrderBookParticipationsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryOrderBookParticipationsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryOrderBookParticipationsResponse proto.InternalMessageInfo

func (m *QueryOrderBookParticipationsResponse) GetOrderBookParticipations() []OrderBookParticipation {
	if m != nil {
		return m.OrderBookParticipations
	}
	return nil
}

func (m *QueryOrderBookParticipationsResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryOrderBookParticipationRequest is the request type for the
// Query/OrderBookParticipation RPC method.
type QueryOrderBookParticipationRequest struct {
	// order_book_uid defines the order book universal unique identifier to query for.
	OrderBookUid string `protobuf:"bytes,1,opt,name=order_book_uid,json=orderBookUid,proto3" json:"order_book_uid,omitempty"`
	// participation_index defines the participation index to query for.
	ParticipationIndex uint64 `protobuf:"varint,2,opt,name=participation_index,json=participationIndex,proto3" json:"participation_index,omitempty"`
}

func (m *QueryOrderBookParticipationRequest) Reset()         { *m = QueryOrderBookParticipationRequest{} }
func (m *QueryOrderBookParticipationRequest) String() string { return proto.CompactTextString(m) }
func (*QueryOrderBookParticipationRequest) ProtoMessage()    {}
func (*QueryOrderBookParticipationRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{8}
}
func (m *QueryOrderBookParticipationRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryOrderBookParticipationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryOrderBookParticipationRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryOrderBookParticipationRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryOrderBookParticipationRequest.Merge(m, src)
}
func (m *QueryOrderBookParticipationRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryOrderBookParticipationRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryOrderBookParticipationRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryOrderBookParticipationRequest proto.InternalMessageInfo

func (m *QueryOrderBookParticipationRequest) GetOrderBookUid() string {
	if m != nil {
		return m.OrderBookUid
	}
	return ""
}

func (m *QueryOrderBookParticipationRequest) GetParticipationIndex() uint64 {
	if m != nil {
		return m.ParticipationIndex
	}
	return 0
}

// QueryOrderBookParticipationResponse is the response type for the
// Query/OrderBookParticipation RPC method.
type QueryOrderBookParticipationResponse struct {
	// order_book_participation defines the book participation info.
	OrderBookParticipation OrderBookParticipation `protobuf:"bytes,1,opt,name=order_book_participation,json=orderBookParticipation,proto3" json:"order_book_participation"`
}

func (m *QueryOrderBookParticipationResponse) Reset()         { *m = QueryOrderBookParticipationResponse{} }
func (m *QueryOrderBookParticipationResponse) String() string { return proto.CompactTextString(m) }
func (*QueryOrderBookParticipationResponse) ProtoMessage()    {}
func (*QueryOrderBookParticipationResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{9}
}
func (m *QueryOrderBookParticipationResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryOrderBookParticipationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryOrderBookParticipationResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryOrderBookParticipationResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryOrderBookParticipationResponse.Merge(m, src)
}
func (m *QueryOrderBookParticipationResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryOrderBookParticipationResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryOrderBookParticipationResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryOrderBookParticipationResponse proto.InternalMessageInfo

func (m *QueryOrderBookParticipationResponse) GetOrderBookParticipation() OrderBookParticipation {
	if m != nil {
		return m.OrderBookParticipation
	}
	return OrderBookParticipation{}
}

// QueryOrderBookExposuresRequest is the request type for the Query/OrderBookExposures RPC
// method
type QueryOrderBookExposuresRequest struct {
	// order_book_uid defines the order book uid to query for.
	OrderBookUid string `protobuf:"bytes,1,opt,name=order_book_uid,json=orderBookUid,proto3" json:"order_book_uid,omitempty"`
	// pagination defines optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryOrderBookExposuresRequest) Reset()         { *m = QueryOrderBookExposuresRequest{} }
func (m *QueryOrderBookExposuresRequest) String() string { return proto.CompactTextString(m) }
func (*QueryOrderBookExposuresRequest) ProtoMessage()    {}
func (*QueryOrderBookExposuresRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{10}
}
func (m *QueryOrderBookExposuresRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryOrderBookExposuresRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryOrderBookExposuresRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryOrderBookExposuresRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryOrderBookExposuresRequest.Merge(m, src)
}
func (m *QueryOrderBookExposuresRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryOrderBookExposuresRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryOrderBookExposuresRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryOrderBookExposuresRequest proto.InternalMessageInfo

func (m *QueryOrderBookExposuresRequest) GetOrderBookUid() string {
	if m != nil {
		return m.OrderBookUid
	}
	return ""
}

func (m *QueryOrderBookExposuresRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryOrderBookExposuresResponse is the response type for the Query/OrderBookExposures
// RPC method.
type QueryOrderBookExposuresResponse struct {
	OrderBookExposures []OrderBookOddsExposure `protobuf:"bytes,1,rep,name=order_book_exposures,json=orderBookExposures,proto3" json:"order_book_exposures"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryOrderBookExposuresResponse) Reset()         { *m = QueryOrderBookExposuresResponse{} }
func (m *QueryOrderBookExposuresResponse) String() string { return proto.CompactTextString(m) }
func (*QueryOrderBookExposuresResponse) ProtoMessage()    {}
func (*QueryOrderBookExposuresResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{11}
}
func (m *QueryOrderBookExposuresResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryOrderBookExposuresResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryOrderBookExposuresResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryOrderBookExposuresResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryOrderBookExposuresResponse.Merge(m, src)
}
func (m *QueryOrderBookExposuresResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryOrderBookExposuresResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryOrderBookExposuresResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryOrderBookExposuresResponse proto.InternalMessageInfo

func (m *QueryOrderBookExposuresResponse) GetOrderBookExposures() []OrderBookOddsExposure {
	if m != nil {
		return m.OrderBookExposures
	}
	return nil
}

func (m *QueryOrderBookExposuresResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryOrderBookExposureRequest is the request type for the Query/OrderBookExposure RPC
// method.
type QueryOrderBookExposureRequest struct {
	// order_book_uid defines the order book uid to query for.
	OrderBookUid string `protobuf:"bytes,1,opt,name=order_book_uid,json=orderBookUid,proto3" json:"order_book_uid,omitempty"`
	// odds_uid defines the odds id to query for.
	OddsUid string `protobuf:"bytes,2,opt,name=odds_uid,json=oddsUid,proto3" json:"odds_uid,omitempty"`
}

func (m *QueryOrderBookExposureRequest) Reset()         { *m = QueryOrderBookExposureRequest{} }
func (m *QueryOrderBookExposureRequest) String() string { return proto.CompactTextString(m) }
func (*QueryOrderBookExposureRequest) ProtoMessage()    {}
func (*QueryOrderBookExposureRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{12}
}
func (m *QueryOrderBookExposureRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryOrderBookExposureRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryOrderBookExposureRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryOrderBookExposureRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryOrderBookExposureRequest.Merge(m, src)
}
func (m *QueryOrderBookExposureRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryOrderBookExposureRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryOrderBookExposureRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryOrderBookExposureRequest proto.InternalMessageInfo

func (m *QueryOrderBookExposureRequest) GetOrderBookUid() string {
	if m != nil {
		return m.OrderBookUid
	}
	return ""
}

func (m *QueryOrderBookExposureRequest) GetOddsUid() string {
	if m != nil {
		return m.OddsUid
	}
	return ""
}

// QueryOrderBookExposureResponse is the response type for the Query/OrderBookExposure RPC
// method.
type QueryOrderBookExposureResponse struct {
	// order_book_exposure defines the order book exposure info.
	OrderBookExposure OrderBookOddsExposure `protobuf:"bytes,1,opt,name=order_book_exposure,json=orderBookExposure,proto3" json:"order_book_exposure"`
}

func (m *QueryOrderBookExposureResponse) Reset()         { *m = QueryOrderBookExposureResponse{} }
func (m *QueryOrderBookExposureResponse) String() string { return proto.CompactTextString(m) }
func (*QueryOrderBookExposureResponse) ProtoMessage()    {}
func (*QueryOrderBookExposureResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{13}
}
func (m *QueryOrderBookExposureResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryOrderBookExposureResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryOrderBookExposureResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryOrderBookExposureResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryOrderBookExposureResponse.Merge(m, src)
}
func (m *QueryOrderBookExposureResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryOrderBookExposureResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryOrderBookExposureResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryOrderBookExposureResponse proto.InternalMessageInfo

func (m *QueryOrderBookExposureResponse) GetOrderBookExposure() OrderBookOddsExposure {
	if m != nil {
		return m.OrderBookExposure
	}
	return OrderBookOddsExposure{}
}

// QueryParticipationExposuresRequest is the request type for the
// Query/ParticipationExposures RPC method
type QueryParticipationExposuresRequest struct {
	// order_book_uid defines the order book uid to query for.
	OrderBookUid string `protobuf:"bytes,1,opt,name=order_book_uid,json=orderBookUid,proto3" json:"order_book_uid,omitempty"`
	// pagination defines optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryParticipationExposuresRequest) Reset()         { *m = QueryParticipationExposuresRequest{} }
func (m *QueryParticipationExposuresRequest) String() string { return proto.CompactTextString(m) }
func (*QueryParticipationExposuresRequest) ProtoMessage()    {}
func (*QueryParticipationExposuresRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{14}
}
func (m *QueryParticipationExposuresRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParticipationExposuresRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParticipationExposuresRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParticipationExposuresRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParticipationExposuresRequest.Merge(m, src)
}
func (m *QueryParticipationExposuresRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryParticipationExposuresRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParticipationExposuresRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParticipationExposuresRequest proto.InternalMessageInfo

func (m *QueryParticipationExposuresRequest) GetOrderBookUid() string {
	if m != nil {
		return m.OrderBookUid
	}
	return ""
}

func (m *QueryParticipationExposuresRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryParticipationExposuresResponse is the response type for the
// Query/ParticipationExposures RPC method.
type QueryParticipationExposuresResponse struct {
	ParticipationExposures []ParticipationExposure `protobuf:"bytes,1,rep,name=participation_exposures,json=participationExposures,proto3" json:"participation_exposures"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryParticipationExposuresResponse) Reset()         { *m = QueryParticipationExposuresResponse{} }
func (m *QueryParticipationExposuresResponse) String() string { return proto.CompactTextString(m) }
func (*QueryParticipationExposuresResponse) ProtoMessage()    {}
func (*QueryParticipationExposuresResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{15}
}
func (m *QueryParticipationExposuresResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParticipationExposuresResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParticipationExposuresResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParticipationExposuresResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParticipationExposuresResponse.Merge(m, src)
}
func (m *QueryParticipationExposuresResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryParticipationExposuresResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParticipationExposuresResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParticipationExposuresResponse proto.InternalMessageInfo

func (m *QueryParticipationExposuresResponse) GetParticipationExposures() []ParticipationExposure {
	if m != nil {
		return m.ParticipationExposures
	}
	return nil
}

func (m *QueryParticipationExposuresResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryParticipationExposureRequest is the request type for the
// Query/ParticipationExposure RPC method.
type QueryParticipationExposureRequest struct {
	// order_book_uid defines the order book id to query for.
	OrderBookUid string `protobuf:"bytes,1,opt,name=order_book_uid,json=orderBookUid,proto3" json:"order_book_uid,omitempty"`
	// participation_index is the index of participation to query for.
	ParticipationIndex uint64 `protobuf:"varint,2,opt,name=participation_index,json=participationIndex,proto3" json:"participation_index,omitempty"`
	// pagination defines the pagination in the response.
	Pagination *query.PageRequest `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryParticipationExposureRequest) Reset()         { *m = QueryParticipationExposureRequest{} }
func (m *QueryParticipationExposureRequest) String() string { return proto.CompactTextString(m) }
func (*QueryParticipationExposureRequest) ProtoMessage()    {}
func (*QueryParticipationExposureRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{16}
}
func (m *QueryParticipationExposureRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParticipationExposureRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParticipationExposureRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParticipationExposureRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParticipationExposureRequest.Merge(m, src)
}
func (m *QueryParticipationExposureRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryParticipationExposureRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParticipationExposureRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParticipationExposureRequest proto.InternalMessageInfo

func (m *QueryParticipationExposureRequest) GetOrderBookUid() string {
	if m != nil {
		return m.OrderBookUid
	}
	return ""
}

func (m *QueryParticipationExposureRequest) GetParticipationIndex() uint64 {
	if m != nil {
		return m.ParticipationIndex
	}
	return 0
}

func (m *QueryParticipationExposureRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryParticipationExposureResponse is the response type for the
// Query/ParticipationExposure RPC method.
type QueryParticipationExposureResponse struct {
	// participation_exposure defines the participation exposure info.
	ParticipationExposure []ParticipationExposure `protobuf:"bytes,1,rep,name=participation_exposure,json=participationExposure,proto3" json:"participation_exposure"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryParticipationExposureResponse) Reset()         { *m = QueryParticipationExposureResponse{} }
func (m *QueryParticipationExposureResponse) String() string { return proto.CompactTextString(m) }
func (*QueryParticipationExposureResponse) ProtoMessage()    {}
func (*QueryParticipationExposureResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{17}
}
func (m *QueryParticipationExposureResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParticipationExposureResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParticipationExposureResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParticipationExposureResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParticipationExposureResponse.Merge(m, src)
}
func (m *QueryParticipationExposureResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryParticipationExposureResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParticipationExposureResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParticipationExposureResponse proto.InternalMessageInfo

func (m *QueryParticipationExposureResponse) GetParticipationExposure() []ParticipationExposure {
	if m != nil {
		return m.ParticipationExposure
	}
	return nil
}

func (m *QueryParticipationExposureResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryHistoricalParticipationExposuresRequest is the request type for the
// Query/HistoricalParticipationExposures RPC method
type QueryHistoricalParticipationExposuresRequest struct {
	// order_book_uid defines the order book uid to query for.
	OrderBookUid string `protobuf:"bytes,1,opt,name=order_book_uid,json=orderBookUid,proto3" json:"order_book_uid,omitempty"`
	// pagination defines optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryHistoricalParticipationExposuresRequest) Reset() {
	*m = QueryHistoricalParticipationExposuresRequest{}
}
func (m *QueryHistoricalParticipationExposuresRequest) String() string {
	return proto.CompactTextString(m)
}
func (*QueryHistoricalParticipationExposuresRequest) ProtoMessage() {}
func (*QueryHistoricalParticipationExposuresRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{18}
}
func (m *QueryHistoricalParticipationExposuresRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryHistoricalParticipationExposuresRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryHistoricalParticipationExposuresRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryHistoricalParticipationExposuresRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryHistoricalParticipationExposuresRequest.Merge(m, src)
}
func (m *QueryHistoricalParticipationExposuresRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryHistoricalParticipationExposuresRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryHistoricalParticipationExposuresRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryHistoricalParticipationExposuresRequest proto.InternalMessageInfo

func (m *QueryHistoricalParticipationExposuresRequest) GetOrderBookUid() string {
	if m != nil {
		return m.OrderBookUid
	}
	return ""
}

func (m *QueryHistoricalParticipationExposuresRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryHistoricalParticipationExposuresResponse is the response type for the
// Query/HistoricalParticipationExposures RPC method.
type QueryHistoricalParticipationExposuresResponse struct {
	ParticipationExposures []ParticipationExposure `protobuf:"bytes,1,rep,name=participation_exposures,json=participationExposures,proto3" json:"participation_exposures"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryHistoricalParticipationExposuresResponse) Reset() {
	*m = QueryHistoricalParticipationExposuresResponse{}
}
func (m *QueryHistoricalParticipationExposuresResponse) String() string {
	return proto.CompactTextString(m)
}
func (*QueryHistoricalParticipationExposuresResponse) ProtoMessage() {}
func (*QueryHistoricalParticipationExposuresResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{19}
}
func (m *QueryHistoricalParticipationExposuresResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryHistoricalParticipationExposuresResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryHistoricalParticipationExposuresResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryHistoricalParticipationExposuresResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryHistoricalParticipationExposuresResponse.Merge(m, src)
}
func (m *QueryHistoricalParticipationExposuresResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryHistoricalParticipationExposuresResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryHistoricalParticipationExposuresResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryHistoricalParticipationExposuresResponse proto.InternalMessageInfo

func (m *QueryHistoricalParticipationExposuresResponse) GetParticipationExposures() []ParticipationExposure {
	if m != nil {
		return m.ParticipationExposures
	}
	return nil
}

func (m *QueryHistoricalParticipationExposuresResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryParticipationFulfilledBetsRequest is the request type for the
// Query/ParticipationFulfilledBets RPC method.
type QueryParticipationFulfilledBetsRequest struct {
	// order_book_uid defines the order book uid to query for.
	OrderBookUid string `protobuf:"bytes,1,opt,name=order_book_uid,json=orderBookUid,proto3" json:"order_book_uid,omitempty"`
	// participation_index is the index of participation to query for.
	ParticipationIndex uint64 `protobuf:"varint,2,opt,name=participation_index,json=participationIndex,proto3" json:"participation_index,omitempty"`
	// pagination defines the pagination in the response.
	Pagination *query.PageRequest `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryParticipationFulfilledBetsRequest) Reset() {
	*m = QueryParticipationFulfilledBetsRequest{}
}
func (m *QueryParticipationFulfilledBetsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryParticipationFulfilledBetsRequest) ProtoMessage()    {}
func (*QueryParticipationFulfilledBetsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{20}
}
func (m *QueryParticipationFulfilledBetsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParticipationFulfilledBetsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParticipationFulfilledBetsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParticipationFulfilledBetsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParticipationFulfilledBetsRequest.Merge(m, src)
}
func (m *QueryParticipationFulfilledBetsRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryParticipationFulfilledBetsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParticipationFulfilledBetsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParticipationFulfilledBetsRequest proto.InternalMessageInfo

func (m *QueryParticipationFulfilledBetsRequest) GetOrderBookUid() string {
	if m != nil {
		return m.OrderBookUid
	}
	return ""
}

func (m *QueryParticipationFulfilledBetsRequest) GetParticipationIndex() uint64 {
	if m != nil {
		return m.ParticipationIndex
	}
	return 0
}

func (m *QueryParticipationFulfilledBetsRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryParticipationFulfilledBetsResponse is the response type for the
// Query/ParticipationFulfilledBets RPC method.
type QueryParticipationFulfilledBetsResponse struct {
	// participation_bets is the bets of the participation.
	ParticipationBets []ParticipationBetPair `protobuf:"bytes,1,rep,name=participation_bets,json=participationBets,proto3" json:"participation_bets"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryParticipationFulfilledBetsResponse) Reset() {
	*m = QueryParticipationFulfilledBetsResponse{}
}
func (m *QueryParticipationFulfilledBetsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryParticipationFulfilledBetsResponse) ProtoMessage()    {}
func (*QueryParticipationFulfilledBetsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6b5d7d659eddd962, []int{21}
}
func (m *QueryParticipationFulfilledBetsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParticipationFulfilledBetsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParticipationFulfilledBetsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParticipationFulfilledBetsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParticipationFulfilledBetsResponse.Merge(m, src)
}
func (m *QueryParticipationFulfilledBetsResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryParticipationFulfilledBetsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParticipationFulfilledBetsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParticipationFulfilledBetsResponse proto.InternalMessageInfo

func (m *QueryParticipationFulfilledBetsResponse) GetParticipationBets() []ParticipationBetPair {
	if m != nil {
		return m.ParticipationBets
	}
	return nil
}

func (m *QueryParticipationFulfilledBetsResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

func init() {
	proto.RegisterType((*QueryParamsRequest)(nil), "furynetwork.fury.strategicreserve.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "furynetwork.fury.strategicreserve.QueryParamsResponse")
	proto.RegisterType((*QueryOrderBooksRequest)(nil), "furynetwork.fury.strategicreserve.QueryOrderBooksRequest")
	proto.RegisterType((*QueryOrderBooksResponse)(nil), "furynetwork.fury.strategicreserve.QueryOrderBooksResponse")
	proto.RegisterType((*QueryOrderBookRequest)(nil), "furynetwork.fury.strategicreserve.QueryOrderBookRequest")
	proto.RegisterType((*QueryOrderBookResponse)(nil), "furynetwork.fury.strategicreserve.QueryOrderBookResponse")
	proto.RegisterType((*QueryOrderBookParticipationsRequest)(nil), "furynetwork.fury.strategicreserve.QueryOrderBookParticipationsRequest")
	proto.RegisterType((*QueryOrderBookParticipationsResponse)(nil), "furynetwork.fury.strategicreserve.QueryOrderBookParticipationsResponse")
	proto.RegisterType((*QueryOrderBookParticipationRequest)(nil), "furynetwork.fury.strategicreserve.QueryOrderBookParticipationRequest")
	proto.RegisterType((*QueryOrderBookParticipationResponse)(nil), "furynetwork.fury.strategicreserve.QueryOrderBookParticipationResponse")
	proto.RegisterType((*QueryOrderBookExposuresRequest)(nil), "furynetwork.fury.strategicreserve.QueryOrderBookExposuresRequest")
	proto.RegisterType((*QueryOrderBookExposuresResponse)(nil), "furynetwork.fury.strategicreserve.QueryOrderBookExposuresResponse")
	proto.RegisterType((*QueryOrderBookExposureRequest)(nil), "furynetwork.fury.strategicreserve.QueryOrderBookExposureRequest")
	proto.RegisterType((*QueryOrderBookExposureResponse)(nil), "furynetwork.fury.strategicreserve.QueryOrderBookExposureResponse")
	proto.RegisterType((*QueryParticipationExposuresRequest)(nil), "furynetwork.fury.strategicreserve.QueryParticipationExposuresRequest")
	proto.RegisterType((*QueryParticipationExposuresResponse)(nil), "furynetwork.fury.strategicreserve.QueryParticipationExposuresResponse")
	proto.RegisterType((*QueryParticipationExposureRequest)(nil), "furynetwork.fury.strategicreserve.QueryParticipationExposureRequest")
	proto.RegisterType((*QueryParticipationExposureResponse)(nil), "furynetwork.fury.strategicreserve.QueryParticipationExposureResponse")
	proto.RegisterType((*QueryHistoricalParticipationExposuresRequest)(nil), "furynetwork.fury.strategicreserve.QueryHistoricalParticipationExposuresRequest")
	proto.RegisterType((*QueryHistoricalParticipationExposuresResponse)(nil), "furynetwork.fury.strategicreserve.QueryHistoricalParticipationExposuresResponse")
	proto.RegisterType((*QueryParticipationFulfilledBetsRequest)(nil), "furynetwork.fury.strategicreserve.QueryParticipationFulfilledBetsRequest")
	proto.RegisterType((*QueryParticipationFulfilledBetsResponse)(nil), "furynetwork.fury.strategicreserve.QueryParticipationFulfilledBetsResponse")
}

func init() { proto.RegisterFile("fury/strategicreserve/query.proto", fileDescriptor_6b5d7d659eddd962) }

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

// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryClient interface {
	// Params queries the parameters of the module.
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
	// OrderBooks queries all order books that match the given status.
	OrderBooks(ctx context.Context, in *QueryOrderBooksRequest, opts ...grpc.CallOption) (*QueryOrderBooksResponse, error)
	// OrderBook queries order book info for given order book universal unique
	// identifier.
	OrderBook(ctx context.Context, in *QueryOrderBookRequest, opts ...grpc.CallOption) (*QueryOrderBookResponse, error)
	// OrderBookParticipations queries participation info for given order book.
	OrderBookParticipations(ctx context.Context, in *QueryOrderBookParticipationsRequest, opts ...grpc.CallOption) (*QueryOrderBookParticipationsResponse, error)
	// OrderBookParticipation queries participation info for given order book and
	// participation index.
	OrderBookParticipation(ctx context.Context, in *QueryOrderBookParticipationRequest, opts ...grpc.CallOption) (*QueryOrderBookParticipationResponse, error)
	// OrderBookExposures queries exposures info for the given order book.
	OrderBookExposures(ctx context.Context, in *QueryOrderBookExposuresRequest, opts ...grpc.CallOption) (*QueryOrderBookExposuresResponse, error)
	// OrderBookExposure queries exposure info for the given order book and odds
	// universal unique identifier.
	OrderBookExposure(ctx context.Context, in *QueryOrderBookExposureRequest, opts ...grpc.CallOption) (*QueryOrderBookExposureResponse, error)
	// ParticipationExposures queries exposures info for given order book
	// participations.
	ParticipationExposures(ctx context.Context, in *QueryParticipationExposuresRequest, opts ...grpc.CallOption) (*QueryParticipationExposuresResponse, error)
	// ParticipationExposure queries exposure info for given order book
	// participation.
	ParticipationExposure(ctx context.Context, in *QueryParticipationExposureRequest, opts ...grpc.CallOption) (*QueryParticipationExposureResponse, error)
	// HistoricalParticipationExposures queries historical exposures info for
	// the given order book participation.
	HistoricalParticipationExposures(ctx context.Context, in *QueryHistoricalParticipationExposuresRequest, opts ...grpc.CallOption) (*QueryHistoricalParticipationExposuresResponse, error)
	// ParticipationFulfilledBets queries fulfilled bets for given order book
	// participation.
	ParticipationFulfilledBets(ctx context.Context, in *QueryParticipationFulfilledBetsRequest, opts ...grpc.CallOption) (*QueryParticipationFulfilledBetsResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

func NewQueryClient(cc grpc1.ClientConn) QueryClient {
	return &queryClient{cc}
}

func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
	out := new(QueryParamsResponse)
	err := c.cc.Invoke(ctx, "/furynetwork.fury.strategicreserve.Query/Params", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) OrderBooks(ctx context.Context, in *QueryOrderBooksRequest, opts ...grpc.CallOption) (*QueryOrderBooksResponse, error) {
	out := new(QueryOrderBooksResponse)
	err := c.cc.Invoke(ctx, "/furynetwork.fury.strategicreserve.Query/OrderBooks", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) OrderBook(ctx context.Context, in *QueryOrderBookRequest, opts ...grpc.CallOption) (*QueryOrderBookResponse, error) {
	out := new(QueryOrderBookResponse)
	err := c.cc.Invoke(ctx, "/furynetwork.fury.strategicreserve.Query/OrderBook", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) OrderBookParticipations(ctx context.Context, in *QueryOrderBookParticipationsRequest, opts ...grpc.CallOption) (*QueryOrderBookParticipationsResponse, error) {
	out := new(QueryOrderBookParticipationsResponse)
	err := c.cc.Invoke(ctx, "/furynetwork.fury.strategicreserve.Query/OrderBookParticipations", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) OrderBookParticipation(ctx context.Context, in *QueryOrderBookParticipationRequest, opts ...grpc.CallOption) (*QueryOrderBookParticipationResponse, error) {
	out := new(QueryOrderBookParticipationResponse)
	err := c.cc.Invoke(ctx, "/furynetwork.fury.strategicreserve.Query/OrderBookParticipation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) OrderBookExposures(ctx context.Context, in *QueryOrderBookExposuresRequest, opts ...grpc.CallOption) (*QueryOrderBookExposuresResponse, error) {
	out := new(QueryOrderBookExposuresResponse)
	err := c.cc.Invoke(ctx, "/furynetwork.fury.strategicreserve.Query/OrderBookExposures", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) OrderBookExposure(ctx context.Context, in *QueryOrderBookExposureRequest, opts ...grpc.CallOption) (*QueryOrderBookExposureResponse, error) {
	out := new(QueryOrderBookExposureResponse)
	err := c.cc.Invoke(ctx, "/furynetwork.fury.strategicreserve.Query/OrderBookExposure", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ParticipationExposures(ctx context.Context, in *QueryParticipationExposuresRequest, opts ...grpc.CallOption) (*QueryParticipationExposuresResponse, error) {
	out := new(QueryParticipationExposuresResponse)
	err := c.cc.Invoke(ctx, "/furynetwork.fury.strategicreserve.Query/ParticipationExposures", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ParticipationExposure(ctx context.Context, in *QueryParticipationExposureRequest, opts ...grpc.CallOption) (*QueryParticipationExposureResponse, error) {
	out := new(QueryParticipationExposureResponse)
	err := c.cc.Invoke(ctx, "/furynetwork.fury.strategicreserve.Query/ParticipationExposure", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) HistoricalParticipationExposures(ctx context.Context, in *QueryHistoricalParticipationExposuresRequest, opts ...grpc.CallOption) (*QueryHistoricalParticipationExposuresResponse, error) {
	out := new(QueryHistoricalParticipationExposuresResponse)
	err := c.cc.Invoke(ctx, "/furynetwork.fury.strategicreserve.Query/HistoricalParticipationExposures", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ParticipationFulfilledBets(ctx context.Context, in *QueryParticipationFulfilledBetsRequest, opts ...grpc.CallOption) (*QueryParticipationFulfilledBetsResponse, error) {
	out := new(QueryParticipationFulfilledBetsResponse)
	err := c.cc.Invoke(ctx, "/furynetwork.fury.strategicreserve.Query/ParticipationFulfilledBets", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Params queries the parameters of the module.
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
	// OrderBooks queries all order books that match the given status.
	OrderBooks(context.Context, *QueryOrderBooksRequest) (*QueryOrderBooksResponse, error)
	// OrderBook queries order book info for given order book universal unique
	// identifier.
	OrderBook(context.Context, *QueryOrderBookRequest) (*QueryOrderBookResponse, error)
	// OrderBookParticipations queries participation info for given order book.
	OrderBookParticipations(context.Context, *QueryOrderBookParticipationsRequest) (*QueryOrderBookParticipationsResponse, error)
	// OrderBookParticipation queries participation info for given order book and
	// participation index.
	OrderBookParticipation(context.Context, *QueryOrderBookParticipationRequest) (*QueryOrderBookParticipationResponse, error)
	// OrderBookExposures queries exposures info for the given order book.
	OrderBookExposures(context.Context, *QueryOrderBookExposuresRequest) (*QueryOrderBookExposuresResponse, error)
	// OrderBookExposure queries exposure info for the given order book and odds
	// universal unique identifier.
	OrderBookExposure(context.Context, *QueryOrderBookExposureRequest) (*QueryOrderBookExposureResponse, error)
	// ParticipationExposures queries exposures info for given order book
	// participations.
	ParticipationExposures(context.Context, *QueryParticipationExposuresRequest) (*QueryParticipationExposuresResponse, error)
	// ParticipationExposure queries exposure info for given order book
	// participation.
	ParticipationExposure(context.Context, *QueryParticipationExposureRequest) (*QueryParticipationExposureResponse, error)
	// HistoricalParticipationExposures queries historical exposures info for
	// the given order book participation.
	HistoricalParticipationExposures(context.Context, *QueryHistoricalParticipationExposuresRequest) (*QueryHistoricalParticipationExposuresResponse, error)
	// ParticipationFulfilledBets queries fulfilled bets for given order book
	// participation.
	ParticipationFulfilledBets(context.Context, *QueryParticipationFulfilledBetsRequest) (*QueryParticipationFulfilledBetsResponse, error)
}

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

func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}
func (*UnimplementedQueryServer) OrderBooks(ctx context.Context, req *QueryOrderBooksRequest) (*QueryOrderBooksResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OrderBooks not implemented")
}
func (*UnimplementedQueryServer) OrderBook(ctx context.Context, req *QueryOrderBookRequest) (*QueryOrderBookResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OrderBook not implemented")
}
func (*UnimplementedQueryServer) OrderBookParticipations(ctx context.Context, req *QueryOrderBookParticipationsRequest) (*QueryOrderBookParticipationsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OrderBookParticipations not implemented")
}
func (*UnimplementedQueryServer) OrderBookParticipation(ctx context.Context, req *QueryOrderBookParticipationRequest) (*QueryOrderBookParticipationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OrderBookParticipation not implemented")
}
func (*UnimplementedQueryServer) OrderBookExposures(ctx context.Context, req *QueryOrderBookExposuresRequest) (*QueryOrderBookExposuresResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OrderBookExposures not implemented")
}
func (*UnimplementedQueryServer) OrderBookExposure(ctx context.Context, req *QueryOrderBookExposureRequest) (*QueryOrderBookExposureResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OrderBookExposure not implemented")
}
func (*UnimplementedQueryServer) ParticipationExposures(ctx context.Context, req *QueryParticipationExposuresRequest) (*QueryParticipationExposuresResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ParticipationExposures not implemented")
}
func (*UnimplementedQueryServer) ParticipationExposure(ctx context.Context, req *QueryParticipationExposureRequest) (*QueryParticipationExposureResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ParticipationExposure not implemented")
}
func (*UnimplementedQueryServer) HistoricalParticipationExposures(ctx context.Context, req *QueryHistoricalParticipationExposuresRequest) (*QueryHistoricalParticipationExposuresResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HistoricalParticipationExposures not implemented")
}
func (*UnimplementedQueryServer) ParticipationFulfilledBets(ctx context.Context, req *QueryParticipationFulfilledBetsRequest) (*QueryParticipationFulfilledBetsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ParticipationFulfilledBets not implemented")
}

func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
	s.RegisterService(&_Query_serviceDesc, srv)
}

func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Params(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furynetwork.fury.strategicreserve.Query/Params",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_OrderBooks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryOrderBooksRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).OrderBooks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furynetwork.fury.strategicreserve.Query/OrderBooks",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).OrderBooks(ctx, req.(*QueryOrderBooksRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_OrderBook_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryOrderBookRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).OrderBook(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furynetwork.fury.strategicreserve.Query/OrderBook",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).OrderBook(ctx, req.(*QueryOrderBookRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_OrderBookParticipations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryOrderBookParticipationsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).OrderBookParticipations(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furynetwork.fury.strategicreserve.Query/OrderBookParticipations",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).OrderBookParticipations(ctx, req.(*QueryOrderBookParticipationsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_OrderBookParticipation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryOrderBookParticipationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).OrderBookParticipation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furynetwork.fury.strategicreserve.Query/OrderBookParticipation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).OrderBookParticipation(ctx, req.(*QueryOrderBookParticipationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_OrderBookExposures_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryOrderBookExposuresRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).OrderBookExposures(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furynetwork.fury.strategicreserve.Query/OrderBookExposures",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).OrderBookExposures(ctx, req.(*QueryOrderBookExposuresRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_OrderBookExposure_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryOrderBookExposureRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).OrderBookExposure(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furynetwork.fury.strategicreserve.Query/OrderBookExposure",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).OrderBookExposure(ctx, req.(*QueryOrderBookExposureRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ParticipationExposures_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryParticipationExposuresRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ParticipationExposures(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furynetwork.fury.strategicreserve.Query/ParticipationExposures",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ParticipationExposures(ctx, req.(*QueryParticipationExposuresRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ParticipationExposure_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryParticipationExposureRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ParticipationExposure(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furynetwork.fury.strategicreserve.Query/ParticipationExposure",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ParticipationExposure(ctx, req.(*QueryParticipationExposureRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_HistoricalParticipationExposures_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryHistoricalParticipationExposuresRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).HistoricalParticipationExposures(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furynetwork.fury.strategicreserve.Query/HistoricalParticipationExposures",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).HistoricalParticipationExposures(ctx, req.(*QueryHistoricalParticipationExposuresRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ParticipationFulfilledBets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryParticipationFulfilledBetsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ParticipationFulfilledBets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furynetwork.fury.strategicreserve.Query/ParticipationFulfilledBets",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ParticipationFulfilledBets(ctx, req.(*QueryParticipationFulfilledBetsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "furynetwork.fury.strategicreserve.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
		{
			MethodName: "OrderBooks",
			Handler:    _Query_OrderBooks_Handler,
		},
		{
			MethodName: "OrderBook",
			Handler:    _Query_OrderBook_Handler,
		},
		{
			MethodName: "OrderBookParticipations",
			Handler:    _Query_OrderBookParticipations_Handler,
		},
		{
			MethodName: "OrderBookParticipation",
			Handler:    _Query_OrderBookParticipation_Handler,
		},
		{
			MethodName: "OrderBookExposures",
			Handler:    _Query_OrderBookExposures_Handler,
		},
		{
			MethodName: "OrderBookExposure",
			Handler:    _Query_OrderBookExposure_Handler,
		},
		{
			MethodName: "ParticipationExposures",
			Handler:    _Query_ParticipationExposures_Handler,
		},
		{
			MethodName: "ParticipationExposure",
			Handler:    _Query_ParticipationExposure_Handler,
		},
		{
			MethodName: "HistoricalParticipationExposures",
			Handler:    _Query_HistoricalParticipationExposures_Handler,
		},
		{
			MethodName: "ParticipationFulfilledBets",
			Handler:    _Query_ParticipationFulfilledBets_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "fury/strategicreserve/query.proto",
}

func (m *QueryParamsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *QueryOrderBooksRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryOrderBooksRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryOrderBooksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Status) > 0 {
		i -= len(m.Status)
		copy(dAtA[i:], m.Status)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Status)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryOrderBooksResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryOrderBooksResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryOrderBooksResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Orderbooks) > 0 {
		for iNdEx := len(m.Orderbooks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Orderbooks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *QueryOrderBookRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryOrderBookRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryOrderBookRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OrderBookUid) > 0 {
		i -= len(m.OrderBookUid)
		copy(dAtA[i:], m.OrderBookUid)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.OrderBookUid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryOrderBookResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryOrderBookResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryOrderBookResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.OrderBook.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *QueryOrderBookParticipationsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryOrderBookParticipationsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryOrderBookParticipationsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.OrderBookUid) > 0 {
		i -= len(m.OrderBookUid)
		copy(dAtA[i:], m.OrderBookUid)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.OrderBookUid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryOrderBookParticipationsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryOrderBookParticipationsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryOrderBookParticipationsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.OrderBookParticipations) > 0 {
		for iNdEx := len(m.OrderBookParticipations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OrderBookParticipations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *QueryOrderBookParticipationRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryOrderBookParticipationRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryOrderBookParticipationRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ParticipationIndex != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.ParticipationIndex))
		i--
		dAtA[i] = 0x10
	}
	if len(m.OrderBookUid) > 0 {
		i -= len(m.OrderBookUid)
		copy(dAtA[i:], m.OrderBookUid)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.OrderBookUid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryOrderBookParticipationResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryOrderBookParticipationResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryOrderBookParticipationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.OrderBookParticipation.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *QueryOrderBookExposuresRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryOrderBookExposuresRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryOrderBookExposuresRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.OrderBookUid) > 0 {
		i -= len(m.OrderBookUid)
		copy(dAtA[i:], m.OrderBookUid)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.OrderBookUid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryOrderBookExposuresResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryOrderBookExposuresResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryOrderBookExposuresResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.OrderBookExposures) > 0 {
		for iNdEx := len(m.OrderBookExposures) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OrderBookExposures[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *QueryOrderBookExposureRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryOrderBookExposureRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryOrderBookExposureRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OddsUid) > 0 {
		i -= len(m.OddsUid)
		copy(dAtA[i:], m.OddsUid)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.OddsUid)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.OrderBookUid) > 0 {
		i -= len(m.OrderBookUid)
		copy(dAtA[i:], m.OrderBookUid)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.OrderBookUid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryOrderBookExposureResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryOrderBookExposureResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryOrderBookExposureResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.OrderBookExposure.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *QueryParticipationExposuresRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryParticipationExposuresRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryParticipationExposuresRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.OrderBookUid) > 0 {
		i -= len(m.OrderBookUid)
		copy(dAtA[i:], m.OrderBookUid)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.OrderBookUid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryParticipationExposuresResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryParticipationExposuresResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryParticipationExposuresResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ParticipationExposures) > 0 {
		for iNdEx := len(m.ParticipationExposures) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ParticipationExposures[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *QueryParticipationExposureRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryParticipationExposureRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryParticipationExposureRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ParticipationIndex != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.ParticipationIndex))
		i--
		dAtA[i] = 0x10
	}
	if len(m.OrderBookUid) > 0 {
		i -= len(m.OrderBookUid)
		copy(dAtA[i:], m.OrderBookUid)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.OrderBookUid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryParticipationExposureResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryParticipationExposureResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryParticipationExposureResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ParticipationExposure) > 0 {
		for iNdEx := len(m.ParticipationExposure) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ParticipationExposure[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *QueryHistoricalParticipationExposuresRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryHistoricalParticipationExposuresRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryHistoricalParticipationExposuresRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.OrderBookUid) > 0 {
		i -= len(m.OrderBookUid)
		copy(dAtA[i:], m.OrderBookUid)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.OrderBookUid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryHistoricalParticipationExposuresResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryHistoricalParticipationExposuresResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryHistoricalParticipationExposuresResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ParticipationExposures) > 0 {
		for iNdEx := len(m.ParticipationExposures) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ParticipationExposures[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *QueryParticipationFulfilledBetsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryParticipationFulfilledBetsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryParticipationFulfilledBetsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ParticipationIndex != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.ParticipationIndex))
		i--
		dAtA[i] = 0x10
	}
	if len(m.OrderBookUid) > 0 {
		i -= len(m.OrderBookUid)
		copy(dAtA[i:], m.OrderBookUid)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.OrderBookUid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryParticipationFulfilledBetsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryParticipationFulfilledBetsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryParticipationFulfilledBetsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ParticipationBets) > 0 {
		for iNdEx := len(m.ParticipationBets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ParticipationBets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
	offset -= sovQuery(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *QueryParamsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryParamsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Params.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *QueryOrderBooksRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Status)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryOrderBooksResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Orderbooks) > 0 {
		for _, e := range m.Orderbooks {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryOrderBookRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OrderBookUid)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryOrderBookResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.OrderBook.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *QueryOrderBookParticipationsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OrderBookUid)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryOrderBookParticipationsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.OrderBookParticipations) > 0 {
		for _, e := range m.OrderBookParticipations {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryOrderBookParticipationRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OrderBookUid)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.ParticipationIndex != 0 {
		n += 1 + sovQuery(uint64(m.ParticipationIndex))
	}
	return n
}

func (m *QueryOrderBookParticipationResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.OrderBookParticipation.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *QueryOrderBookExposuresRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OrderBookUid)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryOrderBookExposuresResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.OrderBookExposures) > 0 {
		for _, e := range m.OrderBookExposures {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryOrderBookExposureRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OrderBookUid)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.OddsUid)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryOrderBookExposureResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.OrderBookExposure.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *QueryParticipationExposuresRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OrderBookUid)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryParticipationExposuresResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ParticipationExposures) > 0 {
		for _, e := range m.ParticipationExposures {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryParticipationExposureRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OrderBookUid)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.ParticipationIndex != 0 {
		n += 1 + sovQuery(uint64(m.ParticipationIndex))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryParticipationExposureResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ParticipationExposure) > 0 {
		for _, e := range m.ParticipationExposure {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryHistoricalParticipationExposuresRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OrderBookUid)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryHistoricalParticipationExposuresResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ParticipationExposures) > 0 {
		for _, e := range m.ParticipationExposures {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryParticipationFulfilledBetsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OrderBookUid)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.ParticipationIndex != 0 {
		n += 1 + sovQuery(uint64(m.ParticipationIndex))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryParticipationFulfilledBetsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ParticipationBets) > 0 {
		for _, e := range m.ParticipationBets {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func sovQuery(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozQuery(x uint64) (n int) {
	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryOrderBooksRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryOrderBooksRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOrderBooksRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryOrderBooksResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryOrderBooksResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOrderBooksResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Orderbooks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Orderbooks = append(m.Orderbooks, OrderBook{})
			if err := m.Orderbooks[len(m.Orderbooks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryOrderBookRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryOrderBookRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOrderBookRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderBookUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderBookUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryOrderBookResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryOrderBookResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOrderBookResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderBook", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OrderBook.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryOrderBookParticipationsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryOrderBookParticipationsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOrderBookParticipationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderBookUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderBookUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryOrderBookParticipationsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryOrderBookParticipationsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOrderBookParticipationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderBookParticipations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderBookParticipations = append(m.OrderBookParticipations, OrderBookParticipation{})
			if err := m.OrderBookParticipations[len(m.OrderBookParticipations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryOrderBookParticipationRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryOrderBookParticipationRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOrderBookParticipationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderBookUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderBookUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParticipationIndex", wireType)
			}
			m.ParticipationIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ParticipationIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryOrderBookParticipationResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryOrderBookParticipationResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOrderBookParticipationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderBookParticipation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OrderBookParticipation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryOrderBookExposuresRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryOrderBookExposuresRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOrderBookExposuresRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderBookUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderBookUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryOrderBookExposuresResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryOrderBookExposuresResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOrderBookExposuresResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderBookExposures", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderBookExposures = append(m.OrderBookExposures, OrderBookOddsExposure{})
			if err := m.OrderBookExposures[len(m.OrderBookExposures)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryOrderBookExposureRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryOrderBookExposureRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOrderBookExposureRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderBookUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderBookUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OddsUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OddsUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryOrderBookExposureResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryOrderBookExposureResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOrderBookExposureResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderBookExposure", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OrderBookExposure.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryParticipationExposuresRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryParticipationExposuresRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParticipationExposuresRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderBookUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderBookUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryParticipationExposuresResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryParticipationExposuresResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParticipationExposuresResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParticipationExposures", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ParticipationExposures = append(m.ParticipationExposures, ParticipationExposure{})
			if err := m.ParticipationExposures[len(m.ParticipationExposures)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryParticipationExposureRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryParticipationExposureRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParticipationExposureRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderBookUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderBookUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParticipationIndex", wireType)
			}
			m.ParticipationIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ParticipationIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryParticipationExposureResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryParticipationExposureResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParticipationExposureResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParticipationExposure", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ParticipationExposure = append(m.ParticipationExposure, ParticipationExposure{})
			if err := m.ParticipationExposure[len(m.ParticipationExposure)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryHistoricalParticipationExposuresRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryHistoricalParticipationExposuresRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryHistoricalParticipationExposuresRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderBookUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderBookUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryHistoricalParticipationExposuresResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryHistoricalParticipationExposuresResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryHistoricalParticipationExposuresResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParticipationExposures", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ParticipationExposures = append(m.ParticipationExposures, ParticipationExposure{})
			if err := m.ParticipationExposures[len(m.ParticipationExposures)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryParticipationFulfilledBetsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryParticipationFulfilledBetsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParticipationFulfilledBetsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderBookUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderBookUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParticipationIndex", wireType)
			}
			m.ParticipationIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ParticipationIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryParticipationFulfilledBetsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryParticipationFulfilledBetsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParticipationFulfilledBetsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParticipationBets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ParticipationBets = append(m.ParticipationBets, ParticipationBetPair{})
			if err := m.ParticipationBets[len(m.ParticipationBets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipQuery(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthQuery
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupQuery
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthQuery
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
)