vega.pb.go

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

package vega

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	_ "github.com/mwitkow/go-proto-validators"
	math "math"
)

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

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

// A side relates to the direction of an order, to Buy, or Sell
type Side int32

const (
	// Default value, always invalid
	Side_SIDE_UNSPECIFIED Side = 0
	// Buy order
	Side_SIDE_BUY Side = 1
	// Sell order
	Side_SIDE_SELL Side = 2
)

var Side_name = map[int32]string{
	0: "SIDE_UNSPECIFIED",
	1: "SIDE_BUY",
	2: "SIDE_SELL",
}

var Side_value = map[string]int32{
	"SIDE_UNSPECIFIED": 0,
	"SIDE_BUY":         1,
	"SIDE_SELL":        2,
}

func (x Side) String() string {
	return proto.EnumName(Side_name, int32(x))
}

func (Side) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{0}
}

// Represents a set of time intervals that are used when querying for candle-stick data
type Interval int32

const (
	// Default value, always invalid
	Interval_INTERVAL_UNSPECIFIED Interval = 0
	// 1 minute.
	Interval_INTERVAL_I1M Interval = 60
	// 5 minutes.
	Interval_INTERVAL_I5M Interval = 300
	// 15 minutes.
	Interval_INTERVAL_I15M Interval = 900
	// 1 hour.
	Interval_INTERVAL_I1H Interval = 3600
	// 6 hours.
	Interval_INTERVAL_I6H Interval = 21600
	// 1 day.
	Interval_INTERVAL_I1D Interval = 86400
)

var Interval_name = map[int32]string{
	0:     "INTERVAL_UNSPECIFIED",
	60:    "INTERVAL_I1M",
	300:   "INTERVAL_I5M",
	900:   "INTERVAL_I15M",
	3600:  "INTERVAL_I1H",
	21600: "INTERVAL_I6H",
	86400: "INTERVAL_I1D",
}

var Interval_value = map[string]int32{
	"INTERVAL_UNSPECIFIED": 0,
	"INTERVAL_I1M":         60,
	"INTERVAL_I5M":         300,
	"INTERVAL_I15M":        900,
	"INTERVAL_I1H":         3600,
	"INTERVAL_I6H":         21600,
	"INTERVAL_I1D":         86400,
}

func (x Interval) String() string {
	return proto.EnumName(Interval_name, int32(x))
}

func (Interval) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{1}
}

// Auction triggers indicate what condition triggered an auction (if market is in auction mode)
type AuctionTrigger int32

const (
	// Default value for AuctionTrigger, no auction triggered
	AuctionTrigger_AUCTION_TRIGGER_UNSPECIFIED AuctionTrigger = 0
	// Batch auction
	AuctionTrigger_AUCTION_TRIGGER_BATCH AuctionTrigger = 1
	// Opening auction
	AuctionTrigger_AUCTION_TRIGGER_OPENING AuctionTrigger = 2
	// Price monitoring trigger
	AuctionTrigger_AUCTION_TRIGGER_PRICE AuctionTrigger = 3
	// Liquidity monitoring trigger
	AuctionTrigger_AUCTION_TRIGGER_LIQUIDITY AuctionTrigger = 4
)

var AuctionTrigger_name = map[int32]string{
	0: "AUCTION_TRIGGER_UNSPECIFIED",
	1: "AUCTION_TRIGGER_BATCH",
	2: "AUCTION_TRIGGER_OPENING",
	3: "AUCTION_TRIGGER_PRICE",
	4: "AUCTION_TRIGGER_LIQUIDITY",
}

var AuctionTrigger_value = map[string]int32{
	"AUCTION_TRIGGER_UNSPECIFIED": 0,
	"AUCTION_TRIGGER_BATCH":       1,
	"AUCTION_TRIGGER_OPENING":     2,
	"AUCTION_TRIGGER_PRICE":       3,
	"AUCTION_TRIGGER_LIQUIDITY":   4,
}

func (x AuctionTrigger) String() string {
	return proto.EnumName(AuctionTrigger_name, int32(x))
}

func (AuctionTrigger) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{2}
}

// A pegged reference defines which price point a pegged order is linked to - meaning
// the price for a pegged order is calculated from the value of the reference price point
type PeggedReference int32

const (
	// Default value for PeggedReference, no reference given
	PeggedReference_PEGGED_REFERENCE_UNSPECIFIED PeggedReference = 0
	// Mid price reference
	PeggedReference_PEGGED_REFERENCE_MID PeggedReference = 1
	// Best bid price reference
	PeggedReference_PEGGED_REFERENCE_BEST_BID PeggedReference = 2
	// Best ask price reference
	PeggedReference_PEGGED_REFERENCE_BEST_ASK PeggedReference = 3
)

var PeggedReference_name = map[int32]string{
	0: "PEGGED_REFERENCE_UNSPECIFIED",
	1: "PEGGED_REFERENCE_MID",
	2: "PEGGED_REFERENCE_BEST_BID",
	3: "PEGGED_REFERENCE_BEST_ASK",
}

var PeggedReference_value = map[string]int32{
	"PEGGED_REFERENCE_UNSPECIFIED": 0,
	"PEGGED_REFERENCE_MID":         1,
	"PEGGED_REFERENCE_BEST_BID":    2,
	"PEGGED_REFERENCE_BEST_ASK":    3,
}

func (x PeggedReference) String() string {
	return proto.EnumName(PeggedReference_name, int32(x))
}

func (PeggedReference) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{3}
}

// OrderError codes are returned in the `[Order](#vega.Order).reason` field - If there is an issue
// with an order during its life-cycle, it will be marked with `status.ORDER_STATUS_REJECTED`
type OrderError int32

const (
	// Default value, no error reported
	OrderError_ORDER_ERROR_UNSPECIFIED OrderError = 0
	// Order was submitted for a market that does not exist
	OrderError_ORDER_ERROR_INVALID_MARKET_ID OrderError = 1
	// Order was submitted with an invalid identifier
	OrderError_ORDER_ERROR_INVALID_ORDER_ID OrderError = 2
	// Order was amended with a sequence number that was not previous version + 1
	OrderError_ORDER_ERROR_OUT_OF_SEQUENCE OrderError = 3
	// Order was amended with an invalid remaining size (e.g. remaining greater than total size)
	OrderError_ORDER_ERROR_INVALID_REMAINING_SIZE OrderError = 4
	// Node was unable to get Vega (blockchain) time
	OrderError_ORDER_ERROR_TIME_FAILURE OrderError = 5
	// Failed to remove an order from the book
	OrderError_ORDER_ERROR_REMOVAL_FAILURE OrderError = 6
	// An order with `TimeInForce.TIME_IN_FORCE_GTT` was submitted or amended
	// with an expiration that was badly formatted or otherwise invalid
	OrderError_ORDER_ERROR_INVALID_EXPIRATION_DATETIME OrderError = 7
	// Order was submitted or amended with an invalid reference field
	OrderError_ORDER_ERROR_INVALID_ORDER_REFERENCE OrderError = 8
	// Order amend was submitted for an order field that cannot not be amended (e.g. order identifier)
	OrderError_ORDER_ERROR_EDIT_NOT_ALLOWED OrderError = 9
	// Amend failure because amend details do not match original order
	OrderError_ORDER_ERROR_AMEND_FAILURE OrderError = 10
	// Order not found in an order book or store
	OrderError_ORDER_ERROR_NOT_FOUND OrderError = 11
	// Order was submitted with an invalid or missing party identifier
	OrderError_ORDER_ERROR_INVALID_PARTY_ID OrderError = 12
	// Order was submitted for a market that has closed
	OrderError_ORDER_ERROR_MARKET_CLOSED OrderError = 13
	// Order was submitted, but the party did not have enough collateral to cover the order
	OrderError_ORDER_ERROR_MARGIN_CHECK_FAILED OrderError = 14
	// Order was submitted, but the party did not have an account for this asset
	OrderError_ORDER_ERROR_MISSING_GENERAL_ACCOUNT OrderError = 15
	// Unspecified internal error
	OrderError_ORDER_ERROR_INTERNAL_ERROR OrderError = 16
	// Order was submitted with an invalid or missing size (e.g. 0)
	OrderError_ORDER_ERROR_INVALID_SIZE OrderError = 17
	// Order was submitted with an invalid persistence for its type
	OrderError_ORDER_ERROR_INVALID_PERSISTENCE OrderError = 18
	// Order was submitted with an invalid type field
	OrderError_ORDER_ERROR_INVALID_TYPE OrderError = 19
	// Order was stopped as it would have traded with another order submitted from the same party
	OrderError_ORDER_ERROR_SELF_TRADING OrderError = 20
	// Order was submitted, but the party did not have enough collateral to cover the fees for the order
	OrderError_ORDER_ERROR_INSUFFICIENT_FUNDS_TO_PAY_FEES OrderError = 21
	// Order was submitted with an incorrect or invalid market type
	OrderError_ORDER_ERROR_INCORRECT_MARKET_TYPE OrderError = 22
	// Order was submitted with invalid time in force
	OrderError_ORDER_ERROR_INVALID_TIME_IN_FORCE OrderError = 23
	// A GFN order has got to the market when it is in auction mode
	OrderError_ORDER_ERROR_GFN_ORDER_DURING_AN_AUCTION OrderError = 24
	// A GFA order has got to the market when it is in continuous trading mode
	OrderError_ORDER_ERROR_GFA_ORDER_DURING_CONTINUOUS_TRADING OrderError = 25
	// Attempt to amend order to GTT without ExpiryAt
	OrderError_ORDER_ERROR_CANNOT_AMEND_TO_GTT_WITHOUT_EXPIRYAT OrderError = 26
	// Attempt to amend ExpiryAt to a value before CreatedAt
	OrderError_ORDER_ERROR_EXPIRYAT_BEFORE_CREATEDAT OrderError = 27
	// Attempt to amend to GTC without an ExpiryAt value
	OrderError_ORDER_ERROR_CANNOT_HAVE_GTC_AND_EXPIRYAT OrderError = 28
	// Amending to FOK or IOC is invalid
	OrderError_ORDER_ERROR_CANNOT_AMEND_TO_FOK_OR_IOC OrderError = 29
	// Amending to GFA or GFN is invalid
	OrderError_ORDER_ERROR_CANNOT_AMEND_TO_GFA_OR_GFN OrderError = 30
	// Amending from GFA or GFN is invalid
	OrderError_ORDER_ERROR_CANNOT_AMEND_FROM_GFA_OR_GFN OrderError = 31
	// IOC orders are not allowed during auction
	OrderError_ORDER_ERROR_CANNOT_SEND_IOC_ORDER_DURING_AUCTION OrderError = 32
	// FOK orders are not allowed during auction
	OrderError_ORDER_ERROR_CANNOT_SEND_FOK_ORDER_DURING_AUCTION OrderError = 33
	// Pegged orders must be LIMIT orders
	OrderError_ORDER_ERROR_MUST_BE_LIMIT_ORDER OrderError = 34
	// Pegged orders can only have TIF GTC or GTT
	OrderError_ORDER_ERROR_MUST_BE_GTT_OR_GTC OrderError = 35
	// Pegged order must have a reference price
	OrderError_ORDER_ERROR_WITHOUT_REFERENCE_PRICE OrderError = 36
	// Buy pegged order cannot reference best ask price
	OrderError_ORDER_ERROR_BUY_CANNOT_REFERENCE_BEST_ASK_PRICE OrderError = 37
	// Pegged order offset must be <= 0
	OrderError_ORDER_ERROR_OFFSET_MUST_BE_LESS_OR_EQUAL_TO_ZERO OrderError = 38
	// Pegged order offset must be < 0
	OrderError_ORDER_ERROR_OFFSET_MUST_BE_LESS_THAN_ZERO OrderError = 39
	// Pegged order offset must be >= 0
	OrderError_ORDER_ERROR_OFFSET_MUST_BE_GREATER_OR_EQUAL_TO_ZERO OrderError = 40
	// Sell pegged order cannot reference best bid price
	OrderError_ORDER_ERROR_SELL_CANNOT_REFERENCE_BEST_BID_PRICE OrderError = 41
	// Pegged order offset must be > zero
	OrderError_ORDER_ERROR_OFFSET_MUST_BE_GREATER_THAN_ZERO OrderError = 42
	// The party has an insufficient balance, or does not have
	// a general account to submit the order (no deposits made
	// for the required asset)
	OrderError_ORDER_ERROR_INSUFFICIENT_ASSET_BALANCE OrderError = 43
	// Cannot amend a non pegged orders details
	OrderError_ORDER_ERROR_CANNOT_AMEND_PEGGED_ORDER_DETAILS_ON_NON_PEGGED_ORDER OrderError = 44
	// We are unable to re-price a pegged order because a market price is unavailable
	OrderError_ORDER_ERROR_UNABLE_TO_REPRICE_PEGGED_ORDER OrderError = 45
	// It is not possible to amend the price of an existing pegged order
	OrderError_ORDER_ERROR_UNABLE_TO_AMEND_PRICE_ON_PEGGED_ORDER OrderError = 46
	// An FOK, IOC, or GFN order was rejected because it resulted in trades outside the price bounds
	OrderError_ORDER_ERROR_NON_PERSISTENT_ORDER_OUT_OF_PRICE_BOUNDS OrderError = 47
)

var OrderError_name = map[int32]string{
	0:  "ORDER_ERROR_UNSPECIFIED",
	1:  "ORDER_ERROR_INVALID_MARKET_ID",
	2:  "ORDER_ERROR_INVALID_ORDER_ID",
	3:  "ORDER_ERROR_OUT_OF_SEQUENCE",
	4:  "ORDER_ERROR_INVALID_REMAINING_SIZE",
	5:  "ORDER_ERROR_TIME_FAILURE",
	6:  "ORDER_ERROR_REMOVAL_FAILURE",
	7:  "ORDER_ERROR_INVALID_EXPIRATION_DATETIME",
	8:  "ORDER_ERROR_INVALID_ORDER_REFERENCE",
	9:  "ORDER_ERROR_EDIT_NOT_ALLOWED",
	10: "ORDER_ERROR_AMEND_FAILURE",
	11: "ORDER_ERROR_NOT_FOUND",
	12: "ORDER_ERROR_INVALID_PARTY_ID",
	13: "ORDER_ERROR_MARKET_CLOSED",
	14: "ORDER_ERROR_MARGIN_CHECK_FAILED",
	15: "ORDER_ERROR_MISSING_GENERAL_ACCOUNT",
	16: "ORDER_ERROR_INTERNAL_ERROR",
	17: "ORDER_ERROR_INVALID_SIZE",
	18: "ORDER_ERROR_INVALID_PERSISTENCE",
	19: "ORDER_ERROR_INVALID_TYPE",
	20: "ORDER_ERROR_SELF_TRADING",
	21: "ORDER_ERROR_INSUFFICIENT_FUNDS_TO_PAY_FEES",
	22: "ORDER_ERROR_INCORRECT_MARKET_TYPE",
	23: "ORDER_ERROR_INVALID_TIME_IN_FORCE",
	24: "ORDER_ERROR_GFN_ORDER_DURING_AN_AUCTION",
	25: "ORDER_ERROR_GFA_ORDER_DURING_CONTINUOUS_TRADING",
	26: "ORDER_ERROR_CANNOT_AMEND_TO_GTT_WITHOUT_EXPIRYAT",
	27: "ORDER_ERROR_EXPIRYAT_BEFORE_CREATEDAT",
	28: "ORDER_ERROR_CANNOT_HAVE_GTC_AND_EXPIRYAT",
	29: "ORDER_ERROR_CANNOT_AMEND_TO_FOK_OR_IOC",
	30: "ORDER_ERROR_CANNOT_AMEND_TO_GFA_OR_GFN",
	31: "ORDER_ERROR_CANNOT_AMEND_FROM_GFA_OR_GFN",
	32: "ORDER_ERROR_CANNOT_SEND_IOC_ORDER_DURING_AUCTION",
	33: "ORDER_ERROR_CANNOT_SEND_FOK_ORDER_DURING_AUCTION",
	34: "ORDER_ERROR_MUST_BE_LIMIT_ORDER",
	35: "ORDER_ERROR_MUST_BE_GTT_OR_GTC",
	36: "ORDER_ERROR_WITHOUT_REFERENCE_PRICE",
	37: "ORDER_ERROR_BUY_CANNOT_REFERENCE_BEST_ASK_PRICE",
	38: "ORDER_ERROR_OFFSET_MUST_BE_LESS_OR_EQUAL_TO_ZERO",
	39: "ORDER_ERROR_OFFSET_MUST_BE_LESS_THAN_ZERO",
	40: "ORDER_ERROR_OFFSET_MUST_BE_GREATER_OR_EQUAL_TO_ZERO",
	41: "ORDER_ERROR_SELL_CANNOT_REFERENCE_BEST_BID_PRICE",
	42: "ORDER_ERROR_OFFSET_MUST_BE_GREATER_THAN_ZERO",
	43: "ORDER_ERROR_INSUFFICIENT_ASSET_BALANCE",
	44: "ORDER_ERROR_CANNOT_AMEND_PEGGED_ORDER_DETAILS_ON_NON_PEGGED_ORDER",
	45: "ORDER_ERROR_UNABLE_TO_REPRICE_PEGGED_ORDER",
	46: "ORDER_ERROR_UNABLE_TO_AMEND_PRICE_ON_PEGGED_ORDER",
	47: "ORDER_ERROR_NON_PERSISTENT_ORDER_OUT_OF_PRICE_BOUNDS",
}

var OrderError_value = map[string]int32{
	"ORDER_ERROR_UNSPECIFIED":                                           0,
	"ORDER_ERROR_INVALID_MARKET_ID":                                     1,
	"ORDER_ERROR_INVALID_ORDER_ID":                                      2,
	"ORDER_ERROR_OUT_OF_SEQUENCE":                                       3,
	"ORDER_ERROR_INVALID_REMAINING_SIZE":                                4,
	"ORDER_ERROR_TIME_FAILURE":                                          5,
	"ORDER_ERROR_REMOVAL_FAILURE":                                       6,
	"ORDER_ERROR_INVALID_EXPIRATION_DATETIME":                           7,
	"ORDER_ERROR_INVALID_ORDER_REFERENCE":                               8,
	"ORDER_ERROR_EDIT_NOT_ALLOWED":                                      9,
	"ORDER_ERROR_AMEND_FAILURE":                                         10,
	"ORDER_ERROR_NOT_FOUND":                                             11,
	"ORDER_ERROR_INVALID_PARTY_ID":                                      12,
	"ORDER_ERROR_MARKET_CLOSED":                                         13,
	"ORDER_ERROR_MARGIN_CHECK_FAILED":                                   14,
	"ORDER_ERROR_MISSING_GENERAL_ACCOUNT":                               15,
	"ORDER_ERROR_INTERNAL_ERROR":                                        16,
	"ORDER_ERROR_INVALID_SIZE":                                          17,
	"ORDER_ERROR_INVALID_PERSISTENCE":                                   18,
	"ORDER_ERROR_INVALID_TYPE":                                          19,
	"ORDER_ERROR_SELF_TRADING":                                          20,
	"ORDER_ERROR_INSUFFICIENT_FUNDS_TO_PAY_FEES":                        21,
	"ORDER_ERROR_INCORRECT_MARKET_TYPE":                                 22,
	"ORDER_ERROR_INVALID_TIME_IN_FORCE":                                 23,
	"ORDER_ERROR_GFN_ORDER_DURING_AN_AUCTION":                           24,
	"ORDER_ERROR_GFA_ORDER_DURING_CONTINUOUS_TRADING":                   25,
	"ORDER_ERROR_CANNOT_AMEND_TO_GTT_WITHOUT_EXPIRYAT":                  26,
	"ORDER_ERROR_EXPIRYAT_BEFORE_CREATEDAT":                             27,
	"ORDER_ERROR_CANNOT_HAVE_GTC_AND_EXPIRYAT":                          28,
	"ORDER_ERROR_CANNOT_AMEND_TO_FOK_OR_IOC":                            29,
	"ORDER_ERROR_CANNOT_AMEND_TO_GFA_OR_GFN":                            30,
	"ORDER_ERROR_CANNOT_AMEND_FROM_GFA_OR_GFN":                          31,
	"ORDER_ERROR_CANNOT_SEND_IOC_ORDER_DURING_AUCTION":                  32,
	"ORDER_ERROR_CANNOT_SEND_FOK_ORDER_DURING_AUCTION":                  33,
	"ORDER_ERROR_MUST_BE_LIMIT_ORDER":                                   34,
	"ORDER_ERROR_MUST_BE_GTT_OR_GTC":                                    35,
	"ORDER_ERROR_WITHOUT_REFERENCE_PRICE":                               36,
	"ORDER_ERROR_BUY_CANNOT_REFERENCE_BEST_ASK_PRICE":                   37,
	"ORDER_ERROR_OFFSET_MUST_BE_LESS_OR_EQUAL_TO_ZERO":                  38,
	"ORDER_ERROR_OFFSET_MUST_BE_LESS_THAN_ZERO":                         39,
	"ORDER_ERROR_OFFSET_MUST_BE_GREATER_OR_EQUAL_TO_ZERO":               40,
	"ORDER_ERROR_SELL_CANNOT_REFERENCE_BEST_BID_PRICE":                  41,
	"ORDER_ERROR_OFFSET_MUST_BE_GREATER_THAN_ZERO":                      42,
	"ORDER_ERROR_INSUFFICIENT_ASSET_BALANCE":                            43,
	"ORDER_ERROR_CANNOT_AMEND_PEGGED_ORDER_DETAILS_ON_NON_PEGGED_ORDER": 44,
	"ORDER_ERROR_UNABLE_TO_REPRICE_PEGGED_ORDER":                        45,
	"ORDER_ERROR_UNABLE_TO_AMEND_PRICE_ON_PEGGED_ORDER":                 46,
	"ORDER_ERROR_NON_PERSISTENT_ORDER_OUT_OF_PRICE_BOUNDS":              47,
}

func (x OrderError) String() string {
	return proto.EnumName(OrderError_name, int32(x))
}

func (OrderError) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{4}
}

// The Vega blockchain status as reported by the node the caller is connected to
type ChainStatus int32

const (
	// Default value, always invalid
	ChainStatus_CHAIN_STATUS_UNSPECIFIED ChainStatus = 0
	// Blockchain is disconnected
	ChainStatus_CHAIN_STATUS_DISCONNECTED ChainStatus = 1
	// Blockchain is replaying historic transactions
	ChainStatus_CHAIN_STATUS_REPLAYING ChainStatus = 2
	// Blockchain is connected and receiving transactions
	ChainStatus_CHAIN_STATUS_CONNECTED ChainStatus = 3
)

var ChainStatus_name = map[int32]string{
	0: "CHAIN_STATUS_UNSPECIFIED",
	1: "CHAIN_STATUS_DISCONNECTED",
	2: "CHAIN_STATUS_REPLAYING",
	3: "CHAIN_STATUS_CONNECTED",
}

var ChainStatus_value = map[string]int32{
	"CHAIN_STATUS_UNSPECIFIED":  0,
	"CHAIN_STATUS_DISCONNECTED": 1,
	"CHAIN_STATUS_REPLAYING":    2,
	"CHAIN_STATUS_CONNECTED":    3,
}

func (x ChainStatus) String() string {
	return proto.EnumName(ChainStatus_name, int32(x))
}

func (ChainStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{5}
}

// Various collateral/account types as used by Vega
type AccountType int32

const (
	// Default value
	AccountType_ACCOUNT_TYPE_UNSPECIFIED AccountType = 0
	// Insurance pool accounts contain insurance pool funds for a market
	AccountType_ACCOUNT_TYPE_INSURANCE AccountType = 1
	// Settlement accounts exist only during settlement or mark-to-market
	AccountType_ACCOUNT_TYPE_SETTLEMENT AccountType = 2
	// Margin accounts contain margin funds for a party and each party will
	// have multiple margin accounts, one for each market they have traded in
	//
	// Margin account funds will alter as margin requirements on positions change
	AccountType_ACCOUNT_TYPE_MARGIN AccountType = 3
	// General accounts contains general funds for a party. A party will
	// have multiple general accounts, one for each asset they want
	// to trade with
	//
	// General accounts are where funds are initially deposited or withdrawn from,
	// it is also the account where funds are taken to fulfil fees and initial margin requirements
	AccountType_ACCOUNT_TYPE_GENERAL AccountType = 4
	// Infrastructure accounts contain fees earned by providing infrastructure on Vega
	AccountType_ACCOUNT_TYPE_FEES_INFRASTRUCTURE AccountType = 5
	// Liquidity accounts contain fees earned by providing liquidity on Vega markets
	AccountType_ACCOUNT_TYPE_FEES_LIQUIDITY AccountType = 6
	// This account is created to hold fees earned by placing orders that sit on the book
	// and are then matched with an incoming order to create a trade - These fees reward parties
	// who provide the best priced liquidity that actually allows trading to take place
	AccountType_ACCOUNT_TYPE_FEES_MAKER AccountType = 7
	// This account is created to lock funds to be withdrawn by parties
	AccountType_ACCOUNT_TYPE_LOCK_WITHDRAW AccountType = 8
	// This account is created to maintain liquidity providers funds commitments
	AccountType_ACCOUNT_TYPE_BOND AccountType = 9
	// External account represents an external source (deposit/withdrawal)
	AccountType_ACCOUNT_TYPE_EXTERNAL AccountType = 10
	// Global insurance account for the asset
	AccountType_ACCOUNT_TYPE_GLOBAL_INSURANCE AccountType = 11
	// Global reward account for the asset
	AccountType_ACCOUNT_TYPE_GLOBAL_REWARD AccountType = 12
)

var AccountType_name = map[int32]string{
	0:  "ACCOUNT_TYPE_UNSPECIFIED",
	1:  "ACCOUNT_TYPE_INSURANCE",
	2:  "ACCOUNT_TYPE_SETTLEMENT",
	3:  "ACCOUNT_TYPE_MARGIN",
	4:  "ACCOUNT_TYPE_GENERAL",
	5:  "ACCOUNT_TYPE_FEES_INFRASTRUCTURE",
	6:  "ACCOUNT_TYPE_FEES_LIQUIDITY",
	7:  "ACCOUNT_TYPE_FEES_MAKER",
	8:  "ACCOUNT_TYPE_LOCK_WITHDRAW",
	9:  "ACCOUNT_TYPE_BOND",
	10: "ACCOUNT_TYPE_EXTERNAL",
	11: "ACCOUNT_TYPE_GLOBAL_INSURANCE",
	12: "ACCOUNT_TYPE_GLOBAL_REWARD",
}

var AccountType_value = map[string]int32{
	"ACCOUNT_TYPE_UNSPECIFIED":         0,
	"ACCOUNT_TYPE_INSURANCE":           1,
	"ACCOUNT_TYPE_SETTLEMENT":          2,
	"ACCOUNT_TYPE_MARGIN":              3,
	"ACCOUNT_TYPE_GENERAL":             4,
	"ACCOUNT_TYPE_FEES_INFRASTRUCTURE": 5,
	"ACCOUNT_TYPE_FEES_LIQUIDITY":      6,
	"ACCOUNT_TYPE_FEES_MAKER":          7,
	"ACCOUNT_TYPE_LOCK_WITHDRAW":       8,
	"ACCOUNT_TYPE_BOND":                9,
	"ACCOUNT_TYPE_EXTERNAL":            10,
	"ACCOUNT_TYPE_GLOBAL_INSURANCE":    11,
	"ACCOUNT_TYPE_GLOBAL_REWARD":       12,
}

func (x AccountType) String() string {
	return proto.EnumName(AccountType_name, int32(x))
}

func (AccountType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{6}
}

// Transfers can occur between parties on Vega, these are the types that indicate why a transfer took place
type TransferType int32

const (
	// Default value, always invalid
	TransferType_TRANSFER_TYPE_UNSPECIFIED TransferType = 0
	// Loss
	TransferType_TRANSFER_TYPE_LOSS TransferType = 1
	// Win
	TransferType_TRANSFER_TYPE_WIN TransferType = 2
	// Close
	TransferType_TRANSFER_TYPE_CLOSE TransferType = 3
	// Mark to market loss
	TransferType_TRANSFER_TYPE_MTM_LOSS TransferType = 4
	// Mark to market win
	TransferType_TRANSFER_TYPE_MTM_WIN TransferType = 5
	// Margin too low
	TransferType_TRANSFER_TYPE_MARGIN_LOW TransferType = 6
	// Margin too high
	TransferType_TRANSFER_TYPE_MARGIN_HIGH TransferType = 7
	// Margin was confiscated
	TransferType_TRANSFER_TYPE_MARGIN_CONFISCATED TransferType = 8
	// Pay maker fee
	TransferType_TRANSFER_TYPE_MAKER_FEE_PAY TransferType = 9
	// Receive maker fee
	TransferType_TRANSFER_TYPE_MAKER_FEE_RECEIVE TransferType = 10
	// Pay infrastructure fee
	TransferType_TRANSFER_TYPE_INFRASTRUCTURE_FEE_PAY TransferType = 11
	// Receive infrastructure fee
	TransferType_TRANSFER_TYPE_INFRASTRUCTURE_FEE_DISTRIBUTE TransferType = 12
	// Pay liquidity fee
	TransferType_TRANSFER_TYPE_LIQUIDITY_FEE_PAY TransferType = 13
	// Receive liquidity fee
	TransferType_TRANSFER_TYPE_LIQUIDITY_FEE_DISTRIBUTE TransferType = 14
	// Bond too low
	TransferType_TRANSFER_TYPE_BOND_LOW TransferType = 15
	// Bond too high
	TransferType_TRANSFER_TYPE_BOND_HIGH TransferType = 16
	// Lock amount for withdraw
	TransferType_TRANSFER_TYPE_WITHDRAW_LOCK TransferType = 17
	// Actual withdraw from system
	TransferType_TRANSFER_TYPE_WITHDRAW TransferType = 18
	// Deposit funds
	TransferType_TRANSFER_TYPE_DEPOSIT TransferType = 19
	// Bond slashing
	TransferType_TRANSFER_TYPE_BOND_SLASHING TransferType = 20
	// Stake reward
	TransferType_TRANSFER_TYPE_STAKE_REWARD TransferType = 21
)

var TransferType_name = map[int32]string{
	0:  "TRANSFER_TYPE_UNSPECIFIED",
	1:  "TRANSFER_TYPE_LOSS",
	2:  "TRANSFER_TYPE_WIN",
	3:  "TRANSFER_TYPE_CLOSE",
	4:  "TRANSFER_TYPE_MTM_LOSS",
	5:  "TRANSFER_TYPE_MTM_WIN",
	6:  "TRANSFER_TYPE_MARGIN_LOW",
	7:  "TRANSFER_TYPE_MARGIN_HIGH",
	8:  "TRANSFER_TYPE_MARGIN_CONFISCATED",
	9:  "TRANSFER_TYPE_MAKER_FEE_PAY",
	10: "TRANSFER_TYPE_MAKER_FEE_RECEIVE",
	11: "TRANSFER_TYPE_INFRASTRUCTURE_FEE_PAY",
	12: "TRANSFER_TYPE_INFRASTRUCTURE_FEE_DISTRIBUTE",
	13: "TRANSFER_TYPE_LIQUIDITY_FEE_PAY",
	14: "TRANSFER_TYPE_LIQUIDITY_FEE_DISTRIBUTE",
	15: "TRANSFER_TYPE_BOND_LOW",
	16: "TRANSFER_TYPE_BOND_HIGH",
	17: "TRANSFER_TYPE_WITHDRAW_LOCK",
	18: "TRANSFER_TYPE_WITHDRAW",
	19: "TRANSFER_TYPE_DEPOSIT",
	20: "TRANSFER_TYPE_BOND_SLASHING",
	21: "TRANSFER_TYPE_STAKE_REWARD",
}

var TransferType_value = map[string]int32{
	"TRANSFER_TYPE_UNSPECIFIED":                   0,
	"TRANSFER_TYPE_LOSS":                          1,
	"TRANSFER_TYPE_WIN":                           2,
	"TRANSFER_TYPE_CLOSE":                         3,
	"TRANSFER_TYPE_MTM_LOSS":                      4,
	"TRANSFER_TYPE_MTM_WIN":                       5,
	"TRANSFER_TYPE_MARGIN_LOW":                    6,
	"TRANSFER_TYPE_MARGIN_HIGH":                   7,
	"TRANSFER_TYPE_MARGIN_CONFISCATED":            8,
	"TRANSFER_TYPE_MAKER_FEE_PAY":                 9,
	"TRANSFER_TYPE_MAKER_FEE_RECEIVE":             10,
	"TRANSFER_TYPE_INFRASTRUCTURE_FEE_PAY":        11,
	"TRANSFER_TYPE_INFRASTRUCTURE_FEE_DISTRIBUTE": 12,
	"TRANSFER_TYPE_LIQUIDITY_FEE_PAY":             13,
	"TRANSFER_TYPE_LIQUIDITY_FEE_DISTRIBUTE":      14,
	"TRANSFER_TYPE_BOND_LOW":                      15,
	"TRANSFER_TYPE_BOND_HIGH":                     16,
	"TRANSFER_TYPE_WITHDRAW_LOCK":                 17,
	"TRANSFER_TYPE_WITHDRAW":                      18,
	"TRANSFER_TYPE_DEPOSIT":                       19,
	"TRANSFER_TYPE_BOND_SLASHING":                 20,
	"TRANSFER_TYPE_STAKE_REWARD":                  21,
}

func (x TransferType) String() string {
	return proto.EnumName(TransferType_name, int32(x))
}

func (TransferType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{7}
}

// Node status type
type NodeStatus int32

const (
	NodeStatus_NODE_STATUS_UNSPECIFIED NodeStatus = 0
	// The node is validating
	NodeStatus_NODE_STATUS_VALIDATOR NodeStatus = 1
	// The node is non-validating
	NodeStatus_NODE_STATUS_NON_VALIDATOR NodeStatus = 2
)

var NodeStatus_name = map[int32]string{
	0: "NODE_STATUS_UNSPECIFIED",
	1: "NODE_STATUS_VALIDATOR",
	2: "NODE_STATUS_NON_VALIDATOR",
}

var NodeStatus_value = map[string]int32{
	"NODE_STATUS_UNSPECIFIED":   0,
	"NODE_STATUS_VALIDATOR":     1,
	"NODE_STATUS_NON_VALIDATOR": 2,
}

func (x NodeStatus) String() string {
	return proto.EnumName(NodeStatus_name, int32(x))
}

func (NodeStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{8}
}

// Time In Force for an order
// See [What order types are available to trade on Vega?](https://docs.testnet.vega.xyz/docs/trading-questions/#what-order-types-are-available-to-trade-on-vega) for more detail
type Order_TimeInForce int32

const (
	// Default value for TimeInForce, can be valid for an amend
	Order_TIME_IN_FORCE_UNSPECIFIED Order_TimeInForce = 0
	// Good until cancelled
	Order_TIME_IN_FORCE_GTC Order_TimeInForce = 1
	// Good until specified time
	Order_TIME_IN_FORCE_GTT Order_TimeInForce = 2
	// Immediate or cancel
	Order_TIME_IN_FORCE_IOC Order_TimeInForce = 3
	// Fill or kill
	Order_TIME_IN_FORCE_FOK Order_TimeInForce = 4
	// Good for auction
	Order_TIME_IN_FORCE_GFA Order_TimeInForce = 5
	// Good for normal
	Order_TIME_IN_FORCE_GFN Order_TimeInForce = 6
)

var Order_TimeInForce_name = map[int32]string{
	0: "TIME_IN_FORCE_UNSPECIFIED",
	1: "TIME_IN_FORCE_GTC",
	2: "TIME_IN_FORCE_GTT",
	3: "TIME_IN_FORCE_IOC",
	4: "TIME_IN_FORCE_FOK",
	5: "TIME_IN_FORCE_GFA",
	6: "TIME_IN_FORCE_GFN",
}

var Order_TimeInForce_value = map[string]int32{
	"TIME_IN_FORCE_UNSPECIFIED": 0,
	"TIME_IN_FORCE_GTC":         1,
	"TIME_IN_FORCE_GTT":         2,
	"TIME_IN_FORCE_IOC":         3,
	"TIME_IN_FORCE_FOK":         4,
	"TIME_IN_FORCE_GFA":         5,
	"TIME_IN_FORCE_GFN":         6,
}

func (x Order_TimeInForce) String() string {
	return proto.EnumName(Order_TimeInForce_name, int32(x))
}

func (Order_TimeInForce) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{6, 0}
}

// Type values for an order
type Order_Type int32

const (
	// Default value, always invalid
	Order_TYPE_UNSPECIFIED Order_Type = 0
	// Used for Limit orders
	Order_TYPE_LIMIT Order_Type = 1
	// Used for Market orders
	Order_TYPE_MARKET Order_Type = 2
	// Used for orders where the initiating party is the network (with distressed parties)
	Order_TYPE_NETWORK Order_Type = 3
)

var Order_Type_name = map[int32]string{
	0: "TYPE_UNSPECIFIED",
	1: "TYPE_LIMIT",
	2: "TYPE_MARKET",
	3: "TYPE_NETWORK",
}

var Order_Type_value = map[string]int32{
	"TYPE_UNSPECIFIED": 0,
	"TYPE_LIMIT":       1,
	"TYPE_MARKET":      2,
	"TYPE_NETWORK":     3,
}

func (x Order_Type) String() string {
	return proto.EnumName(Order_Type_name, int32(x))
}

func (Order_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{6, 1}
}

// Status values for an order
// See resulting status in [What order types are available to trade on Vega?](https://docs.testnet.vega.xyz/docs/trading-questions/#what-order-types-are-available-to-trade-on-vega) for more detail.
type Order_Status int32

const (
	// Default value, always invalid
	Order_STATUS_UNSPECIFIED Order_Status = 0
	// Used for active unfilled or partially filled orders
	Order_STATUS_ACTIVE Order_Status = 1
	// Used for expired GTT orders
	Order_STATUS_EXPIRED Order_Status = 2
	// Used for orders cancelled by the party that created the order
	Order_STATUS_CANCELLED Order_Status = 3
	// Used for unfilled FOK or IOC orders, and for orders that were stopped by the network
	Order_STATUS_STOPPED Order_Status = 4
	// Used for closed fully filled orders
	Order_STATUS_FILLED Order_Status = 5
	// Used for orders when not enough collateral was available to fill the margin requirements
	Order_STATUS_REJECTED Order_Status = 6
	// Used for closed partially filled IOC orders
	Order_STATUS_PARTIALLY_FILLED Order_Status = 7
	// Order has been removed from the order book and has been parked, this applies to pegged orders only
	Order_STATUS_PARKED Order_Status = 8
)

var Order_Status_name = map[int32]string{
	0: "STATUS_UNSPECIFIED",
	1: "STATUS_ACTIVE",
	2: "STATUS_EXPIRED",
	3: "STATUS_CANCELLED",
	4: "STATUS_STOPPED",
	5: "STATUS_FILLED",
	6: "STATUS_REJECTED",
	7: "STATUS_PARTIALLY_FILLED",
	8: "STATUS_PARKED",
}

var Order_Status_value = map[string]int32{
	"STATUS_UNSPECIFIED":      0,
	"STATUS_ACTIVE":           1,
	"STATUS_EXPIRED":          2,
	"STATUS_CANCELLED":        3,
	"STATUS_STOPPED":          4,
	"STATUS_FILLED":           5,
	"STATUS_REJECTED":         6,
	"STATUS_PARTIALLY_FILLED": 7,
	"STATUS_PARKED":           8,
}

func (x Order_Status) String() string {
	return proto.EnumName(Order_Status_name, int32(x))
}

func (Order_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{6, 2}
}

// Type values for a trade
type Trade_Type int32

const (
	// Default value, always invalid
	Trade_TYPE_UNSPECIFIED Trade_Type = 0
	// Normal trading between two parties
	Trade_TYPE_DEFAULT Trade_Type = 1
	// Trading initiated by the network with another party on the book,
	// which helps to zero-out the positions of one or more distressed parties
	Trade_TYPE_NETWORK_CLOSE_OUT_GOOD Trade_Type = 2
	// Trading initiated by the network with another party off the book,
	// with a distressed party in order to zero-out the position of the party
	Trade_TYPE_NETWORK_CLOSE_OUT_BAD Trade_Type = 3
)

var Trade_Type_name = map[int32]string{
	0: "TYPE_UNSPECIFIED",
	1: "TYPE_DEFAULT",
	2: "TYPE_NETWORK_CLOSE_OUT_GOOD",
	3: "TYPE_NETWORK_CLOSE_OUT_BAD",
}

var Trade_Type_value = map[string]int32{
	"TYPE_UNSPECIFIED":            0,
	"TYPE_DEFAULT":                1,
	"TYPE_NETWORK_CLOSE_OUT_GOOD": 2,
	"TYPE_NETWORK_CLOSE_OUT_BAD":  3,
}

func (x Trade_Type) String() string {
	return proto.EnumName(Trade_Type_name, int32(x))
}

func (Trade_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{10, 0}
}

// The status of the deposit
type Deposit_Status int32

const (
	// Default value, always invalid
	Deposit_STATUS_UNSPECIFIED Deposit_Status = 0
	// The deposit is being processed by the network
	Deposit_STATUS_OPEN Deposit_Status = 1
	// The deposit has been cancelled by the network
	Deposit_STATUS_CANCELLED Deposit_Status = 2
	// The deposit has been finalised and accounts have been updated
	Deposit_STATUS_FINALIZED Deposit_Status = 3
)

var Deposit_Status_name = map[int32]string{
	0: "STATUS_UNSPECIFIED",
	1: "STATUS_OPEN",
	2: "STATUS_CANCELLED",
	3: "STATUS_FINALIZED",
}

var Deposit_Status_value = map[string]int32{
	"STATUS_UNSPECIFIED": 0,
	"STATUS_OPEN":        1,
	"STATUS_CANCELLED":   2,
	"STATUS_FINALIZED":   3,
}

func (x Deposit_Status) String() string {
	return proto.EnumName(Deposit_Status_name, int32(x))
}

func (Deposit_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{19, 0}
}

// The status of the withdrawal
type Withdrawal_Status int32

const (
	// Default value, always invalid
	Withdrawal_STATUS_UNSPECIFIED Withdrawal_Status = 0
	// The withdrawal is open and being processed by the network
	Withdrawal_STATUS_OPEN Withdrawal_Status = 1
	// The withdrawal have been cancelled
	Withdrawal_STATUS_CANCELLED Withdrawal_Status = 2
	// The withdrawal went through and is fully finalised, the funds are removed from the
	// Vega network and are unlocked on the foreign chain bridge, for example, on the Ethereum network
	Withdrawal_STATUS_FINALIZED Withdrawal_Status = 3
)

var Withdrawal_Status_name = map[int32]string{
	0: "STATUS_UNSPECIFIED",
	1: "STATUS_OPEN",
	2: "STATUS_CANCELLED",
	3: "STATUS_FINALIZED",
}

var Withdrawal_Status_value = map[string]int32{
	"STATUS_UNSPECIFIED": 0,
	"STATUS_OPEN":        1,
	"STATUS_CANCELLED":   2,
	"STATUS_FINALIZED":   3,
}

func (x Withdrawal_Status) String() string {
	return proto.EnumName(Withdrawal_Status_name, int32(x))
}

func (Withdrawal_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{20, 0}
}

// Status of a liquidity provision order
type LiquidityProvision_Status int32

const (
	// The default value
	LiquidityProvision_STATUS_UNSPECIFIED LiquidityProvision_Status = 0
	// The liquidity provision is active
	LiquidityProvision_STATUS_ACTIVE LiquidityProvision_Status = 1
	// The liquidity provision was stopped by the network
	LiquidityProvision_STATUS_STOPPED LiquidityProvision_Status = 2
	// The liquidity provision was cancelled by the liquidity provider
	LiquidityProvision_STATUS_CANCELLED LiquidityProvision_Status = 3
	// The liquidity provision was invalid and got rejected
	LiquidityProvision_STATUS_REJECTED LiquidityProvision_Status = 4
	// The liquidity provision is valid and accepted by network, but orders aren't deployed
	LiquidityProvision_STATUS_UNDEPLOYED LiquidityProvision_Status = 5
	// The liquidity provision is valid and accepted by network
	// but have never been deployed. I when it's possible to deploy them for the first time
	// margin check fails, then they will be cancelled without any penalties.
	LiquidityProvision_STATUS_PENDING LiquidityProvision_Status = 6
)

var LiquidityProvision_Status_name = map[int32]string{
	0: "STATUS_UNSPECIFIED",
	1: "STATUS_ACTIVE",
	2: "STATUS_STOPPED",
	3: "STATUS_CANCELLED",
	4: "STATUS_REJECTED",
	5: "STATUS_UNDEPLOYED",
	6: "STATUS_PENDING",
}

var LiquidityProvision_Status_value = map[string]int32{
	"STATUS_UNSPECIFIED": 0,
	"STATUS_ACTIVE":      1,
	"STATUS_STOPPED":     2,
	"STATUS_CANCELLED":   3,
	"STATUS_REJECTED":    4,
	"STATUS_UNDEPLOYED":  5,
	"STATUS_PENDING":     6,
}

func (x LiquidityProvision_Status) String() string {
	return proto.EnumName(LiquidityProvision_Status_name, int32(x))
}

func (LiquidityProvision_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{38, 0}
}

type Price struct {
	// Price value, given as an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	Value                uint64   `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Price proto.InternalMessageInfo

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

// A timestamp in nanoseconds since epoch
// See [`VegaTimeResponse`](#api.VegaTimeResponse).`timestamp`
type Timestamp struct {
	// Timestamp value
	Value                int64    `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Timestamp proto.InternalMessageInfo

func (m *Timestamp) GetValue() int64 {
	if m != nil {
		return m.Value
	}
	return 0
}

// A party represents an entity who wishes to trade on or query a Vega network
type Party struct {
	// A unique identifier for the party, typically represented by a public key
	Id                   string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Delegations          []*Delegation `protobuf:"bytes,2,rep,name=delegations,proto3" json:"delegations,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_Party proto.InternalMessageInfo

func (m *Party) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Party) GetDelegations() []*Delegation {
	if m != nil {
		return m.Delegations
	}
	return nil
}

// Risk factors are used to calculate the current risk associated with orders trading on a given market
type RiskFactor struct {
	// Market ID that relates to this risk factor
	Market string `protobuf:"bytes,1,opt,name=market,proto3" json:"market,omitempty"`
	// Short Risk factor value
	Short float64 `protobuf:"fixed64,2,opt,name=short,proto3" json:"short,omitempty"`
	// Long Risk factor value
	Long                 float64  `protobuf:"fixed64,3,opt,name=long,proto3" json:"long,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RiskFactor proto.InternalMessageInfo

func (m *RiskFactor) GetMarket() string {
	if m != nil {
		return m.Market
	}
	return ""
}

func (m *RiskFactor) GetShort() float64 {
	if m != nil {
		return m.Short
	}
	return 0
}

func (m *RiskFactor) GetLong() float64 {
	if m != nil {
		return m.Long
	}
	return 0
}

// Risk results are calculated internally by Vega to attempt to maintain safe trading
type RiskResult struct {
	// Timestamp for when risk factors were generated
	UpdatedTimestamp int64 `protobuf:"varint,1,opt,name=updated_timestamp,json=updatedTimestamp,proto3" json:"updated_timestamp,omitempty"`
	// Risk factors (long and short) for each margin-able asset/currency (usually == settlement assets) in the market
	RiskFactors map[string]*RiskFactor `protobuf:"bytes,2,rep,name=risk_factors,json=riskFactors,proto3" json:"risk_factors,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Timestamp for when risk factors are expected to change (or empty if risk factors are continually updated)
	NextUpdateTimestamp int64 `protobuf:"varint,3,opt,name=next_update_timestamp,json=nextUpdateTimestamp,proto3" json:"next_update_timestamp,omitempty"`
	// Predicted risk factors at next change (what they would be if the change occurred now)
	PredictedNextRiskFactors map[string]*RiskFactor `protobuf:"bytes,4,rep,name=predicted_next_risk_factors,json=predictedNextRiskFactors,proto3" json:"predicted_next_risk_factors,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral     struct{}               `json:"-"`
	XXX_unrecognized         []byte                 `json:"-"`
	XXX_sizecache            int32                  `json:"-"`
}

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

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

var xxx_messageInfo_RiskResult proto.InternalMessageInfo

func (m *RiskResult) GetUpdatedTimestamp() int64 {
	if m != nil {
		return m.UpdatedTimestamp
	}
	return 0
}

func (m *RiskResult) GetRiskFactors() map[string]*RiskFactor {
	if m != nil {
		return m.RiskFactors
	}
	return nil
}

func (m *RiskResult) GetNextUpdateTimestamp() int64 {
	if m != nil {
		return m.NextUpdateTimestamp
	}
	return 0
}

func (m *RiskResult) GetPredictedNextRiskFactors() map[string]*RiskFactor {
	if m != nil {
		return m.PredictedNextRiskFactors
	}
	return nil
}

// Pegged orders are limit orders where the price is specified in the form REFERENCE +/- OFFSET
// They can be used for any limit order that is valid during continuous trading
type PeggedOrder struct {
	// Which price point are we linked to
	Reference PeggedReference `protobuf:"varint,1,opt,name=reference,proto3,enum=vega.PeggedReference" json:"reference,omitempty"`
	// Offset from the price reference
	Offset               int64    `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PeggedOrder proto.InternalMessageInfo

func (m *PeggedOrder) GetReference() PeggedReference {
	if m != nil {
		return m.Reference
	}
	return PeggedReference_PEGGED_REFERENCE_UNSPECIFIED
}

func (m *PeggedOrder) GetOffset() int64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

// An order can be submitted, amended and cancelled on Vega in an attempt to make trades with other parties
type Order struct {
	// Unique identifier for the order (set by the system after consensus)
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Market identifier for the order
	MarketId string `protobuf:"bytes,2,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// Party identifier for the order
	PartyId string `protobuf:"bytes,3,opt,name=party_id,json=partyId,proto3" json:"party_id,omitempty"`
	// Side for the order, e.g. SIDE_BUY or SIDE_SELL - See [`Side`](#vega.Side)
	Side Side `protobuf:"varint,4,opt,name=side,proto3,enum=vega.Side" json:"side,omitempty"`
	// Price for the order, the price is an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	Price uint64 `protobuf:"varint,5,opt,name=price,proto3" json:"price,omitempty"`
	// Size for the order, for example, in a futures market the size equals the number of contracts
	Size uint64 `protobuf:"varint,6,opt,name=size,proto3" json:"size,omitempty"`
	// Size remaining, when this reaches 0 then the order is fully filled and status becomes STATUS_FILLED
	Remaining uint64 `protobuf:"varint,7,opt,name=remaining,proto3" json:"remaining,omitempty"`
	// Time in force indicates how long an order will remain active before it is executed or expires.
	// - See [`Order.TimeInForce`](#vega.Order.TimeInForce)
	TimeInForce Order_TimeInForce `protobuf:"varint,8,opt,name=time_in_force,json=timeInForce,proto3,enum=vega.Order_TimeInForce" json:"time_in_force,omitempty"`
	// Type for the order - See [`Order.Type`](#vega.Order.Type)
	Type Order_Type `protobuf:"varint,9,opt,name=type,proto3,enum=vega.Order_Type" json:"type,omitempty"`
	// Timestamp for when the order was created at, in nanoseconds since the epoch
	// - See [`VegaTimeResponse`](#api.VegaTimeResponse).`timestamp`
	CreatedAt int64 `protobuf:"varint,10,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// The current status for the order. See [`Order.Status`](#vega.Order.Status)
	// - For detail on `STATUS_REJECTED` please check the [`OrderError`](#vega.OrderError) value given in the `reason` field
	Status Order_Status `protobuf:"varint,11,opt,name=status,proto3,enum=vega.Order_Status" json:"status,omitempty"`
	// Timestamp for when the order will expire, in nanoseconds since the epoch
	// - See [`VegaTimeResponse`](#api.VegaTimeResponse).`timestamp`, valid only for [`Order.TimeInForce`](#vega.Order.TimeInForce)`.TIME_IN_FORCE_GTT`
	ExpiresAt int64 `protobuf:"varint,12,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"`
	// Reference given for the order, this is typically used to retrieve an order submitted through consensus
	// - Currently set internally by the node to return a unique reference identifier for the order submission
	Reference string `protobuf:"bytes,13,opt,name=reference,proto3" json:"reference,omitempty"`
	// If the Order `status` is `STATUS_REJECTED` then an [`OrderError`](#vega.OrderError) reason will be specified
	// - The default for this field is `ORDER_ERROR_NONE` which signifies that there were no errors
	Reason OrderError `protobuf:"varint,14,opt,name=reason,proto3,enum=vega.OrderError" json:"reason,omitempty"`
	// Timestamp for when the Order was last updated, in nanoseconds since the epoch
	// - See [`VegaTimeResponse`](#api.VegaTimeResponse).`timestamp`
	UpdatedAt int64 `protobuf:"varint,15,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// The version for the order, initial value is version 1 and is incremented after each successful amend
	Version uint64 `protobuf:"varint,16,opt,name=version,proto3" json:"version,omitempty"`
	// Batch identifier for the order, used internally for orders submitted during auctions
	// to keep track of the auction batch this order falls under (required for fees calculation)
	BatchId uint64 `protobuf:"varint,17,opt,name=batch_id,json=batchId,proto3" json:"batch_id,omitempty"`
	// Pegged order details, used only if the order represents a pegged order.
	PeggedOrder *PeggedOrder `protobuf:"bytes,18,opt,name=pegged_order,json=peggedOrder,proto3" json:"pegged_order,omitempty"`
	// Is this order created as part of a liquidity provision, will be empty if not.
	LiquidityProvisionId string   `protobuf:"bytes,19,opt,name=liquidity_provision_id,json=liquidityProvisionId,proto3" json:"liquidity_provision_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Order proto.InternalMessageInfo

func (m *Order) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Order) GetMarketId() string {
	if m != nil {
		return m.MarketId
	}
	return ""
}

func (m *Order) GetPartyId() string {
	if m != nil {
		return m.PartyId
	}
	return ""
}

func (m *Order) GetSide() Side {
	if m != nil {
		return m.Side
	}
	return Side_SIDE_UNSPECIFIED
}

func (m *Order) GetPrice() uint64 {
	if m != nil {
		return m.Price
	}
	return 0
}

func (m *Order) GetSize() uint64 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *Order) GetRemaining() uint64 {
	if m != nil {
		return m.Remaining
	}
	return 0
}

func (m *Order) GetTimeInForce() Order_TimeInForce {
	if m != nil {
		return m.TimeInForce
	}
	return Order_TIME_IN_FORCE_UNSPECIFIED
}

func (m *Order) GetType() Order_Type {
	if m != nil {
		return m.Type
	}
	return Order_TYPE_UNSPECIFIED
}

func (m *Order) GetCreatedAt() int64 {
	if m != nil {
		return m.CreatedAt
	}
	return 0
}

func (m *Order) GetStatus() Order_Status {
	if m != nil {
		return m.Status
	}
	return Order_STATUS_UNSPECIFIED
}

func (m *Order) GetExpiresAt() int64 {
	if m != nil {
		return m.ExpiresAt
	}
	return 0
}

func (m *Order) GetReference() string {
	if m != nil {
		return m.Reference
	}
	return ""
}

func (m *Order) GetReason() OrderError {
	if m != nil {
		return m.Reason
	}
	return OrderError_ORDER_ERROR_UNSPECIFIED
}

func (m *Order) GetUpdatedAt() int64 {
	if m != nil {
		return m.UpdatedAt
	}
	return 0
}

func (m *Order) GetVersion() uint64 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *Order) GetBatchId() uint64 {
	if m != nil {
		return m.BatchId
	}
	return 0
}

func (m *Order) GetPeggedOrder() *PeggedOrder {
	if m != nil {
		return m.PeggedOrder
	}
	return nil
}

func (m *Order) GetLiquidityProvisionId() string {
	if m != nil {
		return m.LiquidityProvisionId
	}
	return ""
}

// Used when cancelling an Order
type OrderCancellationConfirmation struct {
	// The order that was cancelled
	Order                *Order   `protobuf:"bytes,1,opt,name=order,proto3" json:"order,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_OrderCancellationConfirmation proto.InternalMessageInfo

func (m *OrderCancellationConfirmation) GetOrder() *Order {
	if m != nil {
		return m.Order
	}
	return nil
}

// Used when confirming an Order
type OrderConfirmation struct {
	// The order that was confirmed
	Order *Order `protobuf:"bytes,1,opt,name=order,proto3" json:"order,omitempty"`
	// 0 or more trades that were emitted
	Trades []*Trade `protobuf:"bytes,2,rep,name=trades,proto3" json:"trades,omitempty"`
	// 0 or more passive orders that were affected
	PassiveOrdersAffected []*Order `protobuf:"bytes,3,rep,name=passive_orders_affected,json=passiveOrdersAffected,proto3" json:"passive_orders_affected,omitempty"`
	XXX_NoUnkeyedLiteral  struct{} `json:"-"`
	XXX_unrecognized      []byte   `json:"-"`
	XXX_sizecache         int32    `json:"-"`
}

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

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

var xxx_messageInfo_OrderConfirmation proto.InternalMessageInfo

func (m *OrderConfirmation) GetOrder() *Order {
	if m != nil {
		return m.Order
	}
	return nil
}

func (m *OrderConfirmation) GetTrades() []*Trade {
	if m != nil {
		return m.Trades
	}
	return nil
}

func (m *OrderConfirmation) GetPassiveOrdersAffected() []*Order {
	if m != nil {
		return m.PassiveOrdersAffected
	}
	return nil
}

// AuctionIndicativeState is used to emit an event with the indicative price/volume per market during an auction
type AuctionIndicativeState struct {
	// The market identifier for which this state relates to
	MarketId string `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// The Indicative Uncrossing Price is the price at which all trades would occur if we uncrossed the auction now
	IndicativePrice uint64 `protobuf:"varint,2,opt,name=indicative_price,json=indicativePrice,proto3" json:"indicative_price,omitempty"`
	// The Indicative Uncrossing Volume is the volume available at the Indicative crossing price if we uncrossed the auction now
	IndicativeVolume uint64 `protobuf:"varint,3,opt,name=indicative_volume,json=indicativeVolume,proto3" json:"indicative_volume,omitempty"`
	// The timestamp at which the auction started
	AuctionStart int64 `protobuf:"varint,4,opt,name=auction_start,json=auctionStart,proto3" json:"auction_start,omitempty"`
	// The timestamp at which the auction is meant to stop
	AuctionEnd           int64    `protobuf:"varint,5,opt,name=auction_end,json=auctionEnd,proto3" json:"auction_end,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_AuctionIndicativeState proto.InternalMessageInfo

func (m *AuctionIndicativeState) GetMarketId() string {
	if m != nil {
		return m.MarketId
	}
	return ""
}

func (m *AuctionIndicativeState) GetIndicativePrice() uint64 {
	if m != nil {
		return m.IndicativePrice
	}
	return 0
}

func (m *AuctionIndicativeState) GetIndicativeVolume() uint64 {
	if m != nil {
		return m.IndicativeVolume
	}
	return 0
}

func (m *AuctionIndicativeState) GetAuctionStart() int64 {
	if m != nil {
		return m.AuctionStart
	}
	return 0
}

func (m *AuctionIndicativeState) GetAuctionEnd() int64 {
	if m != nil {
		return m.AuctionEnd
	}
	return 0
}

// A trade occurs when an aggressive order crosses one or more passive orders on the order book for a market on Vega
type Trade struct {
	// Unique identifier for the trade (generated by Vega)
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Market identifier (the market that the trade occurred on)
	MarketId string `protobuf:"bytes,2,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// Price for the trade, the price is an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	Price uint64 `protobuf:"varint,3,opt,name=price,proto3" json:"price,omitempty"`
	// Size filled for the trade
	Size uint64 `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"`
	// Unique party identifier for the buyer
	Buyer string `protobuf:"bytes,5,opt,name=buyer,proto3" json:"buyer,omitempty"`
	// Unique party identifier for the seller
	Seller string `protobuf:"bytes,6,opt,name=seller,proto3" json:"seller,omitempty"`
	// Direction of the aggressive party e.g. SIDE_BUY or SIDE_SELL - See [`Side`](#vega.Side)
	Aggressor Side `protobuf:"varint,7,opt,name=aggressor,proto3,enum=vega.Side" json:"aggressor,omitempty"`
	// Identifier of the order from the buy side
	BuyOrder string `protobuf:"bytes,8,opt,name=buy_order,json=buyOrder,proto3" json:"buy_order,omitempty"`
	// Identifier of the order from the sell side
	SellOrder string `protobuf:"bytes,9,opt,name=sell_order,json=sellOrder,proto3" json:"sell_order,omitempty"`
	// Timestamp for when the trade occurred, in nanoseconds since the epoch
	// - See [`VegaTimeResponse`](#api.VegaTimeResponse).`timestamp`
	Timestamp int64 `protobuf:"varint,10,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Type for the trade - See [`Trade.Type`](#vega.Trade.Type)
	Type Trade_Type `protobuf:"varint,11,opt,name=type,proto3,enum=vega.Trade_Type" json:"type,omitempty"`
	// Fee amount charged to the buyer party for the trade
	BuyerFee *Fee `protobuf:"bytes,12,opt,name=buyer_fee,json=buyerFee,proto3" json:"buyer_fee,omitempty"`
	// Fee amount charged to the seller party for the trade
	SellerFee *Fee `protobuf:"bytes,13,opt,name=seller_fee,json=sellerFee,proto3" json:"seller_fee,omitempty"`
	// Auction batch number that the buy side order was placed in
	BuyerAuctionBatch uint64 `protobuf:"varint,14,opt,name=buyer_auction_batch,json=buyerAuctionBatch,proto3" json:"buyer_auction_batch,omitempty"`
	// Auction batch number that the sell side order was placed in
	SellerAuctionBatch   uint64   `protobuf:"varint,15,opt,name=seller_auction_batch,json=sellerAuctionBatch,proto3" json:"seller_auction_batch,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Trade proto.InternalMessageInfo

func (m *Trade) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Trade) GetMarketId() string {
	if m != nil {
		return m.MarketId
	}
	return ""
}

func (m *Trade) GetPrice() uint64 {
	if m != nil {
		return m.Price
	}
	return 0
}

func (m *Trade) GetSize() uint64 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *Trade) GetBuyer() string {
	if m != nil {
		return m.Buyer
	}
	return ""
}

func (m *Trade) GetSeller() string {
	if m != nil {
		return m.Seller
	}
	return ""
}

func (m *Trade) GetAggressor() Side {
	if m != nil {
		return m.Aggressor
	}
	return Side_SIDE_UNSPECIFIED
}

func (m *Trade) GetBuyOrder() string {
	if m != nil {
		return m.BuyOrder
	}
	return ""
}

func (m *Trade) GetSellOrder() string {
	if m != nil {
		return m.SellOrder
	}
	return ""
}

func (m *Trade) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *Trade) GetType() Trade_Type {
	if m != nil {
		return m.Type
	}
	return Trade_TYPE_UNSPECIFIED
}

func (m *Trade) GetBuyerFee() *Fee {
	if m != nil {
		return m.BuyerFee
	}
	return nil
}

func (m *Trade) GetSellerFee() *Fee {
	if m != nil {
		return m.SellerFee
	}
	return nil
}

func (m *Trade) GetBuyerAuctionBatch() uint64 {
	if m != nil {
		return m.BuyerAuctionBatch
	}
	return 0
}

func (m *Trade) GetSellerAuctionBatch() uint64 {
	if m != nil {
		return m.SellerAuctionBatch
	}
	return 0
}

// Represents any fees paid by a party, resulting from a trade
type Fee struct {
	// Fee amount paid to the non-aggressive party of the trade
	MakerFee uint64 `protobuf:"varint,1,opt,name=maker_fee,json=makerFee,proto3" json:"maker_fee,omitempty"`
	// Fee amount paid for maintaining the Vega infrastructure
	InfrastructureFee uint64 `protobuf:"varint,2,opt,name=infrastructure_fee,json=infrastructureFee,proto3" json:"infrastructure_fee,omitempty"`
	// Fee amount paid to market makers
	LiquidityFee         uint64   `protobuf:"varint,3,opt,name=liquidity_fee,json=liquidityFee,proto3" json:"liquidity_fee,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Fee proto.InternalMessageInfo

func (m *Fee) GetMakerFee() uint64 {
	if m != nil {
		return m.MakerFee
	}
	return 0
}

func (m *Fee) GetInfrastructureFee() uint64 {
	if m != nil {
		return m.InfrastructureFee
	}
	return 0
}

func (m *Fee) GetLiquidityFee() uint64 {
	if m != nil {
		return m.LiquidityFee
	}
	return 0
}

type TradeSet struct {
	// A set of one or more trades
	Trades               []*Trade `protobuf:"bytes,1,rep,name=trades,proto3" json:"trades,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_TradeSet proto.InternalMessageInfo

func (m *TradeSet) GetTrades() []*Trade {
	if m != nil {
		return m.Trades
	}
	return nil
}

// Represents the high, low, open, and closing prices for an interval of trading,
// referred to commonly as a candlestick or candle
type Candle struct {
	// Timestamp for the point in time when the candle was initially created/opened, in nanoseconds since the epoch
	// - See [`VegaTimeResponse`](#api.VegaTimeResponse).`timestamp`
	Timestamp int64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// An ISO-8601 datetime with nanosecond precision for when the candle was last updated
	Datetime string `protobuf:"bytes,2,opt,name=datetime,proto3" json:"datetime,omitempty"`
	// Highest price for trading during the candle interval
	High uint64 `protobuf:"varint,3,opt,name=high,proto3" json:"high,omitempty"`
	// Lowest price for trading during the candle interval
	Low uint64 `protobuf:"varint,4,opt,name=low,proto3" json:"low,omitempty"`
	// Open trade price
	Open uint64 `protobuf:"varint,5,opt,name=open,proto3" json:"open,omitempty"`
	// Closing trade price
	Close uint64 `protobuf:"varint,6,opt,name=close,proto3" json:"close,omitempty"`
	// Total trading volume during the candle interval
	Volume uint64 `protobuf:"varint,7,opt,name=volume,proto3" json:"volume,omitempty"`
	// Time interval for the candle - See [`Interval`](#vega.Interval)
	Interval             Interval `protobuf:"varint,8,opt,name=interval,proto3,enum=vega.Interval" json:"interval,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Candle proto.InternalMessageInfo

func (m *Candle) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *Candle) GetDatetime() string {
	if m != nil {
		return m.Datetime
	}
	return ""
}

func (m *Candle) GetHigh() uint64 {
	if m != nil {
		return m.High
	}
	return 0
}

func (m *Candle) GetLow() uint64 {
	if m != nil {
		return m.Low
	}
	return 0
}

func (m *Candle) GetOpen() uint64 {
	if m != nil {
		return m.Open
	}
	return 0
}

func (m *Candle) GetClose() uint64 {
	if m != nil {
		return m.Close
	}
	return 0
}

func (m *Candle) GetVolume() uint64 {
	if m != nil {
		return m.Volume
	}
	return 0
}

func (m *Candle) GetInterval() Interval {
	if m != nil {
		return m.Interval
	}
	return Interval_INTERVAL_UNSPECIFIED
}

// Represents a price level from market depth or order book data
type PriceLevel struct {
	// Price for the price level, the price is an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	Price uint64 `protobuf:"varint,1,opt,name=price,proto3" json:"price,omitempty"`
	// Number of orders at the price level
	NumberOfOrders uint64 `protobuf:"varint,2,opt,name=number_of_orders,json=numberOfOrders,proto3" json:"number_of_orders,omitempty"`
	// Volume at the price level
	Volume               uint64   `protobuf:"varint,3,opt,name=volume,proto3" json:"volume,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PriceLevel proto.InternalMessageInfo

func (m *PriceLevel) GetPrice() uint64 {
	if m != nil {
		return m.Price
	}
	return 0
}

func (m *PriceLevel) GetNumberOfOrders() uint64 {
	if m != nil {
		return m.NumberOfOrders
	}
	return 0
}

func (m *PriceLevel) GetVolume() uint64 {
	if m != nil {
		return m.Volume
	}
	return 0
}

// Represents market depth or order book data for the specified market on Vega
type MarketDepth struct {
	// Market identifier
	MarketId string `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// Collection of price levels for the buy side of the book
	Buy []*PriceLevel `protobuf:"bytes,2,rep,name=buy,proto3" json:"buy,omitempty"`
	// Collection of price levels for the sell side of the book
	Sell []*PriceLevel `protobuf:"bytes,3,rep,name=sell,proto3" json:"sell,omitempty"`
	// Sequence number for the market depth data returned
	SequenceNumber       uint64   `protobuf:"varint,4,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MarketDepth) Reset()         { *m = MarketDepth{} }
func (m *MarketDepth) String() string { return proto.CompactTextString(m) }
func (*MarketDepth) ProtoMessage()    {}
func (*MarketDepth) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{15}
}

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

var xxx_messageInfo_MarketDepth proto.InternalMessageInfo

func (m *MarketDepth) GetMarketId() string {
	if m != nil {
		return m.MarketId
	}
	return ""
}

func (m *MarketDepth) GetBuy() []*PriceLevel {
	if m != nil {
		return m.Buy
	}
	return nil
}

func (m *MarketDepth) GetSell() []*PriceLevel {
	if m != nil {
		return m.Sell
	}
	return nil
}

func (m *MarketDepth) GetSequenceNumber() uint64 {
	if m != nil {
		return m.SequenceNumber
	}
	return 0
}

// Represents the changed market depth since the last update
type MarketDepthUpdate struct {
	// Market identifier
	MarketId string `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// Collection of updated price levels for the buy side of the book
	Buy []*PriceLevel `protobuf:"bytes,2,rep,name=buy,proto3" json:"buy,omitempty"`
	// Collection of updated price levels for the sell side of the book
	Sell []*PriceLevel `protobuf:"bytes,3,rep,name=sell,proto3" json:"sell,omitempty"`
	// Sequence number for the market depth update data returned
	SequenceNumber       uint64   `protobuf:"varint,4,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MarketDepthUpdate) Reset()         { *m = MarketDepthUpdate{} }
func (m *MarketDepthUpdate) String() string { return proto.CompactTextString(m) }
func (*MarketDepthUpdate) ProtoMessage()    {}
func (*MarketDepthUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{16}
}

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

var xxx_messageInfo_MarketDepthUpdate proto.InternalMessageInfo

func (m *MarketDepthUpdate) GetMarketId() string {
	if m != nil {
		return m.MarketId
	}
	return ""
}

func (m *MarketDepthUpdate) GetBuy() []*PriceLevel {
	if m != nil {
		return m.Buy
	}
	return nil
}

func (m *MarketDepthUpdate) GetSell() []*PriceLevel {
	if m != nil {
		return m.Sell
	}
	return nil
}

func (m *MarketDepthUpdate) GetSequenceNumber() uint64 {
	if m != nil {
		return m.SequenceNumber
	}
	return 0
}

// Represents position data for a party on the specified market on Vega
type Position struct {
	// Market identifier
	MarketId string `protobuf:"bytes,1,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// Party identifier
	PartyId string `protobuf:"bytes,2,opt,name=party_id,json=partyId,proto3" json:"party_id,omitempty"`
	// Open volume for the position, value is signed +ve for long and -ve for short
	OpenVolume int64 `protobuf:"varint,3,opt,name=open_volume,json=openVolume,proto3" json:"open_volume,omitempty"`
	// Realised profit and loss for the position, value is signed +ve for long and -ve for short
	RealisedPnl int64 `protobuf:"varint,4,opt,name=realised_pnl,json=realisedPnl,proto3" json:"realised_pnl,omitempty"`
	// Unrealised profit and loss for the position, value is signed +ve for long and -ve for short
	UnrealisedPnl int64 `protobuf:"varint,5,opt,name=unrealised_pnl,json=unrealisedPnl,proto3" json:"unrealised_pnl,omitempty"`
	// Average entry price for the position, the price is an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	AverageEntryPrice uint64 `protobuf:"varint,6,opt,name=average_entry_price,json=averageEntryPrice,proto3" json:"average_entry_price,omitempty"`
	// Timestamp for the latest time the position was updated
	UpdatedAt            int64    `protobuf:"varint,7,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Position) Reset()         { *m = Position{} }
func (m *Position) String() string { return proto.CompactTextString(m) }
func (*Position) ProtoMessage()    {}
func (*Position) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{17}
}

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

var xxx_messageInfo_Position proto.InternalMessageInfo

func (m *Position) GetMarketId() string {
	if m != nil {
		return m.MarketId
	}
	return ""
}

func (m *Position) GetPartyId() string {
	if m != nil {
		return m.PartyId
	}
	return ""
}

func (m *Position) GetOpenVolume() int64 {
	if m != nil {
		return m.OpenVolume
	}
	return 0
}

func (m *Position) GetRealisedPnl() int64 {
	if m != nil {
		return m.RealisedPnl
	}
	return 0
}

func (m *Position) GetUnrealisedPnl() int64 {
	if m != nil {
		return m.UnrealisedPnl
	}
	return 0
}

func (m *Position) GetAverageEntryPrice() uint64 {
	if m != nil {
		return m.AverageEntryPrice
	}
	return 0
}

func (m *Position) GetUpdatedAt() int64 {
	if m != nil {
		return m.UpdatedAt
	}
	return 0
}

type PositionTrade struct {
	// Volume for the position trade, value is signed +ve for long and -ve for short
	Volume int64 `protobuf:"varint,1,opt,name=volume,proto3" json:"volume,omitempty"`
	// Price for the position trade, the price is an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	Price                uint64   `protobuf:"varint,2,opt,name=price,proto3" json:"price,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PositionTrade) Reset()         { *m = PositionTrade{} }
func (m *PositionTrade) String() string { return proto.CompactTextString(m) }
func (*PositionTrade) ProtoMessage()    {}
func (*PositionTrade) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{18}
}

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

var xxx_messageInfo_PositionTrade proto.InternalMessageInfo

func (m *PositionTrade) GetVolume() int64 {
	if m != nil {
		return m.Volume
	}
	return 0
}

func (m *PositionTrade) GetPrice() uint64 {
	if m != nil {
		return m.Price
	}
	return 0
}

// A deposit on to the Vega network
type Deposit struct {
	// Unique identifier for the deposit
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Status of the deposit
	Status Deposit_Status `protobuf:"varint,2,opt,name=status,proto3,enum=vega.Deposit_Status" json:"status,omitempty"`
	// Party identifier of the user initiating the deposit
	PartyId string `protobuf:"bytes,3,opt,name=party_id,json=partyId,proto3" json:"party_id,omitempty"`
	// The Vega asset targeted by this deposit
	Asset string `protobuf:"bytes,4,opt,name=asset,proto3" json:"asset,omitempty"`
	// The amount to be deposited
	Amount string `protobuf:"bytes,5,opt,name=amount,proto3" json:"amount,omitempty"`
	// The hash of the transaction from the foreign chain
	TxHash string `protobuf:"bytes,6,opt,name=tx_hash,json=txHash,proto3" json:"tx_hash,omitempty"`
	// Timestamp for when the Vega account was updated with the deposit
	CreditedTimestamp int64 `protobuf:"varint,7,opt,name=credited_timestamp,json=creditedTimestamp,proto3" json:"credited_timestamp,omitempty"`
	// Timestamp for when the deposit was created on the Vega network
	CreatedTimestamp     int64    `protobuf:"varint,8,opt,name=created_timestamp,json=createdTimestamp,proto3" json:"created_timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Deposit) Reset()         { *m = Deposit{} }
func (m *Deposit) String() string { return proto.CompactTextString(m) }
func (*Deposit) ProtoMessage()    {}
func (*Deposit) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{19}
}

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

var xxx_messageInfo_Deposit proto.InternalMessageInfo

func (m *Deposit) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Deposit) GetStatus() Deposit_Status {
	if m != nil {
		return m.Status
	}
	return Deposit_STATUS_UNSPECIFIED
}

func (m *Deposit) GetPartyId() string {
	if m != nil {
		return m.PartyId
	}
	return ""
}

func (m *Deposit) GetAsset() string {
	if m != nil {
		return m.Asset
	}
	return ""
}

func (m *Deposit) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

func (m *Deposit) GetTxHash() string {
	if m != nil {
		return m.TxHash
	}
	return ""
}

func (m *Deposit) GetCreditedTimestamp() int64 {
	if m != nil {
		return m.CreditedTimestamp
	}
	return 0
}

func (m *Deposit) GetCreatedTimestamp() int64 {
	if m != nil {
		return m.CreatedTimestamp
	}
	return 0
}

// A withdrawal from the Vega network
type Withdrawal struct {
	// Unique identifier for the withdrawal
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Unique party identifier of the user initiating the withdrawal
	PartyId string `protobuf:"bytes,2,opt,name=party_id,json=partyId,proto3" json:"party_id,omitempty"`
	// The amount to be withdrawn
	Amount uint64 `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
	// The asset we want to withdraw funds from
	Asset string `protobuf:"bytes,4,opt,name=asset,proto3" json:"asset,omitempty"`
	// The status of the withdrawal
	Status Withdrawal_Status `protobuf:"varint,5,opt,name=status,proto3,enum=vega.Withdrawal_Status" json:"status,omitempty"`
	// The reference which is used by the foreign chain
	// to refer to this withdrawal
	Ref string `protobuf:"bytes,6,opt,name=ref,proto3" json:"ref,omitempty"`
	// The time until when the withdrawal is valid
	Expiry int64 `protobuf:"varint,7,opt,name=expiry,proto3" json:"expiry,omitempty"`
	// The hash of the foreign chain for this transaction
	TxHash string `protobuf:"bytes,8,opt,name=tx_hash,json=txHash,proto3" json:"tx_hash,omitempty"`
	// Timestamp for when the network started to process this withdrawal
	CreatedTimestamp int64 `protobuf:"varint,9,opt,name=created_timestamp,json=createdTimestamp,proto3" json:"created_timestamp,omitempty"`
	// Timestamp for when the withdrawal was finalised by the network
	WithdrawnTimestamp int64 `protobuf:"varint,10,opt,name=withdrawn_timestamp,json=withdrawnTimestamp,proto3" json:"withdrawn_timestamp,omitempty"`
	// Foreign chain specifics
	Ext                  *WithdrawExt `protobuf:"bytes,11,opt,name=ext,proto3" json:"ext,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *Withdrawal) Reset()         { *m = Withdrawal{} }
func (m *Withdrawal) String() string { return proto.CompactTextString(m) }
func (*Withdrawal) ProtoMessage()    {}
func (*Withdrawal) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{20}
}

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

var xxx_messageInfo_Withdrawal proto.InternalMessageInfo

func (m *Withdrawal) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Withdrawal) GetPartyId() string {
	if m != nil {
		return m.PartyId
	}
	return ""
}

func (m *Withdrawal) GetAmount() uint64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *Withdrawal) GetAsset() string {
	if m != nil {
		return m.Asset
	}
	return ""
}

func (m *Withdrawal) GetStatus() Withdrawal_Status {
	if m != nil {
		return m.Status
	}
	return Withdrawal_STATUS_UNSPECIFIED
}

func (m *Withdrawal) GetRef() string {
	if m != nil {
		return m.Ref
	}
	return ""
}

func (m *Withdrawal) GetExpiry() int64 {
	if m != nil {
		return m.Expiry
	}
	return 0
}

func (m *Withdrawal) GetTxHash() string {
	if m != nil {
		return m.TxHash
	}
	return ""
}

func (m *Withdrawal) GetCreatedTimestamp() int64 {
	if m != nil {
		return m.CreatedTimestamp
	}
	return 0
}

func (m *Withdrawal) GetWithdrawnTimestamp() int64 {
	if m != nil {
		return m.WithdrawnTimestamp
	}
	return 0
}

func (m *Withdrawal) GetExt() *WithdrawExt {
	if m != nil {
		return m.Ext
	}
	return nil
}

// Withdrawal external details
type WithdrawExt struct {
	// Foreign chain specifics
	//
	// Types that are valid to be assigned to Ext:
	//	*WithdrawExt_Erc20
	Ext                  isWithdrawExt_Ext `protobuf_oneof:"ext"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *WithdrawExt) Reset()         { *m = WithdrawExt{} }
func (m *WithdrawExt) String() string { return proto.CompactTextString(m) }
func (*WithdrawExt) ProtoMessage()    {}
func (*WithdrawExt) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{21}
}

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

var xxx_messageInfo_WithdrawExt proto.InternalMessageInfo

type isWithdrawExt_Ext interface {
	isWithdrawExt_Ext()
}

type WithdrawExt_Erc20 struct {
	Erc20 *Erc20WithdrawExt `protobuf:"bytes,1,opt,name=erc20,proto3,oneof"`
}

func (*WithdrawExt_Erc20) isWithdrawExt_Ext() {}

func (m *WithdrawExt) GetExt() isWithdrawExt_Ext {
	if m != nil {
		return m.Ext
	}
	return nil
}

func (m *WithdrawExt) GetErc20() *Erc20WithdrawExt {
	if x, ok := m.GetExt().(*WithdrawExt_Erc20); ok {
		return x.Erc20
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*WithdrawExt) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*WithdrawExt_Erc20)(nil),
	}
}

// An extension of data required for the withdraw submissions
type Erc20WithdrawExt struct {
	// The address into which the bridge will release the funds
	ReceiverAddress      string   `protobuf:"bytes,1,opt,name=receiver_address,json=receiverAddress,proto3" json:"receiver_address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Erc20WithdrawExt) Reset()         { *m = Erc20WithdrawExt{} }
func (m *Erc20WithdrawExt) String() string { return proto.CompactTextString(m) }
func (*Erc20WithdrawExt) ProtoMessage()    {}
func (*Erc20WithdrawExt) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{22}
}

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

var xxx_messageInfo_Erc20WithdrawExt proto.InternalMessageInfo

func (m *Erc20WithdrawExt) GetReceiverAddress() string {
	if m != nil {
		return m.ReceiverAddress
	}
	return ""
}

// Represents an account for an asset on Vega for a particular owner or party
type Account struct {
	// Unique account identifier (used internally by Vega)
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// The party that the account belongs to, special values include `network`, which represents the Vega network and is
	// most commonly seen during liquidation of distressed trading positions
	Owner string `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"`
	// Balance of the asset, the balance is an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	// and importantly balances cannot be negative
	Balance uint64 `protobuf:"varint,3,opt,name=balance,proto3" json:"balance,omitempty"`
	// Asset identifier for the account
	Asset string `protobuf:"bytes,4,opt,name=asset,proto3" json:"asset,omitempty"`
	// Market identifier for the account, if [`AccountType`](#vega.AccountType).`ACCOUNT_TYPE_GENERAL` this will be empty
	MarketId string `protobuf:"bytes,5,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// The account type related to this account
	Type                 AccountType `protobuf:"varint,6,opt,name=type,proto3,enum=vega.AccountType" json:"type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *Account) Reset()         { *m = Account{} }
func (m *Account) String() string { return proto.CompactTextString(m) }
func (*Account) ProtoMessage()    {}
func (*Account) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{23}
}

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

var xxx_messageInfo_Account proto.InternalMessageInfo

func (m *Account) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Account) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *Account) GetBalance() uint64 {
	if m != nil {
		return m.Balance
	}
	return 0
}

func (m *Account) GetAsset() string {
	if m != nil {
		return m.Asset
	}
	return ""
}

func (m *Account) GetMarketId() string {
	if m != nil {
		return m.MarketId
	}
	return ""
}

func (m *Account) GetType() AccountType {
	if m != nil {
		return m.Type
	}
	return AccountType_ACCOUNT_TYPE_UNSPECIFIED
}

// Asset value information used within a transfer
type FinancialAmount struct {
	// A signed integer amount of asset
	Amount uint64 `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
	// Asset identifier
	Asset                string   `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FinancialAmount) Reset()         { *m = FinancialAmount{} }
func (m *FinancialAmount) String() string { return proto.CompactTextString(m) }
func (*FinancialAmount) ProtoMessage()    {}
func (*FinancialAmount) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{24}
}

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

var xxx_messageInfo_FinancialAmount proto.InternalMessageInfo

func (m *FinancialAmount) GetAmount() uint64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *FinancialAmount) GetAsset() string {
	if m != nil {
		return m.Asset
	}
	return ""
}

// Represents a financial transfer within Vega
type Transfer struct {
	// Party identifier for the owner of the transfer
	Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
	// A financial amount (of an asset) to transfer
	Amount *FinancialAmount `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"`
	// The type of transfer, gives the reason for the transfer
	Type TransferType `protobuf:"varint,3,opt,name=type,proto3,enum=vega.TransferType" json:"type,omitempty"`
	// A minimum amount
	MinAmount            uint64   `protobuf:"varint,4,opt,name=min_amount,json=minAmount,proto3" json:"min_amount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Transfer) Reset()         { *m = Transfer{} }
func (m *Transfer) String() string { return proto.CompactTextString(m) }
func (*Transfer) ProtoMessage()    {}
func (*Transfer) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{25}
}

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

var xxx_messageInfo_Transfer proto.InternalMessageInfo

func (m *Transfer) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *Transfer) GetAmount() *FinancialAmount {
	if m != nil {
		return m.Amount
	}
	return nil
}

func (m *Transfer) GetType() TransferType {
	if m != nil {
		return m.Type
	}
	return TransferType_TRANSFER_TYPE_UNSPECIFIED
}

func (m *Transfer) GetMinAmount() uint64 {
	if m != nil {
		return m.MinAmount
	}
	return 0
}

// Represents a request to transfer from one set of accounts to another
type TransferRequest struct {
	// One or more accounts to transfer from
	FromAccount []*Account `protobuf:"bytes,1,rep,name=from_account,json=fromAccount,proto3" json:"from_account,omitempty"`
	// One or more accounts to transfer to
	ToAccount []*Account `protobuf:"bytes,2,rep,name=to_account,json=toAccount,proto3" json:"to_account,omitempty"`
	// An amount to transfer for the asset
	Amount uint64 `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
	// A minimum amount
	MinAmount uint64 `protobuf:"varint,4,opt,name=min_amount,json=minAmount,proto3" json:"min_amount,omitempty"`
	// Asset identifier
	Asset string `protobuf:"bytes,5,opt,name=asset,proto3" json:"asset,omitempty"`
	// A reference for auditing purposes
	Reference            string   `protobuf:"bytes,6,opt,name=reference,proto3" json:"reference,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TransferRequest) Reset()         { *m = TransferRequest{} }
func (m *TransferRequest) String() string { return proto.CompactTextString(m) }
func (*TransferRequest) ProtoMessage()    {}
func (*TransferRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{26}
}

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

var xxx_messageInfo_TransferRequest proto.InternalMessageInfo

func (m *TransferRequest) GetFromAccount() []*Account {
	if m != nil {
		return m.FromAccount
	}
	return nil
}

func (m *TransferRequest) GetToAccount() []*Account {
	if m != nil {
		return m.ToAccount
	}
	return nil
}

func (m *TransferRequest) GetAmount() uint64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *TransferRequest) GetMinAmount() uint64 {
	if m != nil {
		return m.MinAmount
	}
	return 0
}

func (m *TransferRequest) GetAsset() string {
	if m != nil {
		return m.Asset
	}
	return ""
}

func (m *TransferRequest) GetReference() string {
	if m != nil {
		return m.Reference
	}
	return ""
}

// Represents a ledger entry on Vega
type LedgerEntry struct {
	// One or more accounts to transfer from
	FromAccount string `protobuf:"bytes,1,opt,name=from_account,json=fromAccount,proto3" json:"from_account,omitempty"`
	// One or more accounts to transfer to
	ToAccount string `protobuf:"bytes,2,opt,name=to_account,json=toAccount,proto3" json:"to_account,omitempty"`
	// An amount to transfer
	Amount uint64 `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
	// A reference for auditing purposes
	Reference string `protobuf:"bytes,4,opt,name=reference,proto3" json:"reference,omitempty"`
	// Type of ledger entry
	Type string `protobuf:"bytes,5,opt,name=type,proto3" json:"type,omitempty"`
	// Timestamp for the time the ledger entry was created, in nanoseconds since the epoch
	// - See [`VegaTimeResponse`](#api.VegaTimeResponse).`timestamp`
	Timestamp            int64    `protobuf:"varint,6,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LedgerEntry) Reset()         { *m = LedgerEntry{} }
func (m *LedgerEntry) String() string { return proto.CompactTextString(m) }
func (*LedgerEntry) ProtoMessage()    {}
func (*LedgerEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{27}
}

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

var xxx_messageInfo_LedgerEntry proto.InternalMessageInfo

func (m *LedgerEntry) GetFromAccount() string {
	if m != nil {
		return m.FromAccount
	}
	return ""
}

func (m *LedgerEntry) GetToAccount() string {
	if m != nil {
		return m.ToAccount
	}
	return ""
}

func (m *LedgerEntry) GetAmount() uint64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *LedgerEntry) GetReference() string {
	if m != nil {
		return m.Reference
	}
	return ""
}

func (m *LedgerEntry) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *LedgerEntry) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

// Represents the balance for an account during a transfer
type TransferBalance struct {
	// The account relating to the transfer
	Account *Account `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	// The balance relating to the transfer
	Balance              uint64   `protobuf:"varint,2,opt,name=balance,proto3" json:"balance,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TransferBalance) Reset()         { *m = TransferBalance{} }
func (m *TransferBalance) String() string { return proto.CompactTextString(m) }
func (*TransferBalance) ProtoMessage()    {}
func (*TransferBalance) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{28}
}

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

var xxx_messageInfo_TransferBalance proto.InternalMessageInfo

func (m *TransferBalance) GetAccount() *Account {
	if m != nil {
		return m.Account
	}
	return nil
}

func (m *TransferBalance) GetBalance() uint64 {
	if m != nil {
		return m.Balance
	}
	return 0
}

// Represents the response from a transfer
type TransferResponse struct {
	// One or more ledger entries representing the transfers
	Transfers []*LedgerEntry `protobuf:"bytes,1,rep,name=transfers,proto3" json:"transfers,omitempty"`
	// One or more account balances
	Balances             []*TransferBalance `protobuf:"bytes,2,rep,name=balances,proto3" json:"balances,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *TransferResponse) Reset()         { *m = TransferResponse{} }
func (m *TransferResponse) String() string { return proto.CompactTextString(m) }
func (*TransferResponse) ProtoMessage()    {}
func (*TransferResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{29}
}

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

var xxx_messageInfo_TransferResponse proto.InternalMessageInfo

func (m *TransferResponse) GetTransfers() []*LedgerEntry {
	if m != nil {
		return m.Transfers
	}
	return nil
}

func (m *TransferResponse) GetBalances() []*TransferBalance {
	if m != nil {
		return m.Balances
	}
	return nil
}

// Represents the margin levels for a party on a market at a given time
type MarginLevels struct {
	// Maintenance margin value
	MaintenanceMargin uint64 `protobuf:"varint,1,opt,name=maintenance_margin,json=maintenanceMargin,proto3" json:"maintenance_margin,omitempty"`
	// Search level value
	SearchLevel uint64 `protobuf:"varint,2,opt,name=search_level,json=searchLevel,proto3" json:"search_level,omitempty"`
	// Initial margin value
	InitialMargin uint64 `protobuf:"varint,3,opt,name=initial_margin,json=initialMargin,proto3" json:"initial_margin,omitempty"`
	// Collateral release level value
	CollateralReleaseLevel uint64 `protobuf:"varint,4,opt,name=collateral_release_level,json=collateralReleaseLevel,proto3" json:"collateral_release_level,omitempty"`
	// Party identifier
	PartyId string `protobuf:"bytes,5,opt,name=party_id,json=partyId,proto3" json:"party_id,omitempty"`
	// Market identifier
	MarketId string `protobuf:"bytes,6,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// Asset identifier
	Asset string `protobuf:"bytes,7,opt,name=asset,proto3" json:"asset,omitempty"`
	// Timestamp for the time the ledger entry was created, in nanoseconds since the epoch
	// - See [`VegaTimeResponse`](#api.VegaTimeResponse).`timestamp`
	Timestamp            int64    `protobuf:"varint,8,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MarginLevels) Reset()         { *m = MarginLevels{} }
func (m *MarginLevels) String() string { return proto.CompactTextString(m) }
func (*MarginLevels) ProtoMessage()    {}
func (*MarginLevels) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{30}
}

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

var xxx_messageInfo_MarginLevels proto.InternalMessageInfo

func (m *MarginLevels) GetMaintenanceMargin() uint64 {
	if m != nil {
		return m.MaintenanceMargin
	}
	return 0
}

func (m *MarginLevels) GetSearchLevel() uint64 {
	if m != nil {
		return m.SearchLevel
	}
	return 0
}

func (m *MarginLevels) GetInitialMargin() uint64 {
	if m != nil {
		return m.InitialMargin
	}
	return 0
}

func (m *MarginLevels) GetCollateralReleaseLevel() uint64 {
	if m != nil {
		return m.CollateralReleaseLevel
	}
	return 0
}

func (m *MarginLevels) GetPartyId() string {
	if m != nil {
		return m.PartyId
	}
	return ""
}

func (m *MarginLevels) GetMarketId() string {
	if m != nil {
		return m.MarketId
	}
	return ""
}

func (m *MarginLevels) GetAsset() string {
	if m != nil {
		return m.Asset
	}
	return ""
}

func (m *MarginLevels) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

// Represents data generated by a market when open
type MarketData struct {
	// Mark price, as an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	MarkPrice uint64 `protobuf:"varint,1,opt,name=mark_price,json=markPrice,proto3" json:"mark_price,omitempty"`
	// Highest price level on an order book for buy orders, as an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	BestBidPrice uint64 `protobuf:"varint,2,opt,name=best_bid_price,json=bestBidPrice,proto3" json:"best_bid_price,omitempty"`
	// Aggregated volume being bid at the best bid price
	BestBidVolume uint64 `protobuf:"varint,3,opt,name=best_bid_volume,json=bestBidVolume,proto3" json:"best_bid_volume,omitempty"`
	// Lowest price level on an order book for offer orders
	BestOfferPrice uint64 `protobuf:"varint,4,opt,name=best_offer_price,json=bestOfferPrice,proto3" json:"best_offer_price,omitempty"`
	// Aggregated volume being offered at the best offer price, as an integer, for example `123456` is a correctly
	//  // formatted price of `1.23456` assuming market configured to 5 decimal places
	BestOfferVolume uint64 `protobuf:"varint,5,opt,name=best_offer_volume,json=bestOfferVolume,proto3" json:"best_offer_volume,omitempty"`
	// Highest price on the order book for buy orders not including pegged orders
	BestStaticBidPrice uint64 `protobuf:"varint,6,opt,name=best_static_bid_price,json=bestStaticBidPrice,proto3" json:"best_static_bid_price,omitempty"`
	// Total volume at the best static bid price excluding pegged orders
	BestStaticBidVolume uint64 `protobuf:"varint,7,opt,name=best_static_bid_volume,json=bestStaticBidVolume,proto3" json:"best_static_bid_volume,omitempty"`
	// Lowest price on the order book for sell orders not including pegged orders
	BestStaticOfferPrice uint64 `protobuf:"varint,8,opt,name=best_static_offer_price,json=bestStaticOfferPrice,proto3" json:"best_static_offer_price,omitempty"`
	// Total volume at the best static offer price excluding pegged orders
	BestStaticOfferVolume uint64 `protobuf:"varint,9,opt,name=best_static_offer_volume,json=bestStaticOfferVolume,proto3" json:"best_static_offer_volume,omitempty"`
	// Arithmetic average of the best bid price and best offer price, as an integer, for example `123456` is a correctly
	// formatted price of `1.23456` assuming market configured to 5 decimal places
	MidPrice uint64 `protobuf:"varint,10,opt,name=mid_price,json=midPrice,proto3" json:"mid_price,omitempty"`
	// Arithmetic average of the best static bid price and best static offer price
	StaticMidPrice uint64 `protobuf:"varint,11,opt,name=static_mid_price,json=staticMidPrice,proto3" json:"static_mid_price,omitempty"`
	// Market identifier for the data
	Market string `protobuf:"bytes,12,opt,name=market,proto3" json:"market,omitempty"`
	// Timestamp at which this mark price was relevant, in nanoseconds since the epoch
	// - See [`VegaTimeResponse`](#api.VegaTimeResponse).`timestamp`
	Timestamp int64 `protobuf:"varint,13,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// The sum of the size of all positions greater than 0 on the market
	OpenInterest uint64 `protobuf:"varint,14,opt,name=open_interest,json=openInterest,proto3" json:"open_interest,omitempty"`
	// Time in seconds until the end of the auction (0 if currently not in auction period)
	AuctionEnd int64 `protobuf:"varint,15,opt,name=auction_end,json=auctionEnd,proto3" json:"auction_end,omitempty"`
	// Time until next auction (used in FBA's) - currently always 0
	AuctionStart int64 `protobuf:"varint,16,opt,name=auction_start,json=auctionStart,proto3" json:"auction_start,omitempty"`
	// Indicative price (zero if not in auction)
	IndicativePrice uint64 `protobuf:"varint,17,opt,name=indicative_price,json=indicativePrice,proto3" json:"indicative_price,omitempty"`
	// Indicative volume (zero if not in auction)
	IndicativeVolume uint64 `protobuf:"varint,18,opt,name=indicative_volume,json=indicativeVolume,proto3" json:"indicative_volume,omitempty"`
	// The current trading mode for the market
	MarketTradingMode Market_TradingMode `protobuf:"varint,19,opt,name=market_trading_mode,json=marketTradingMode,proto3,enum=vega.Market_TradingMode" json:"market_trading_mode,omitempty"`
	// When a market is in an auction trading mode, this field indicates what triggered the auction
	Trigger AuctionTrigger `protobuf:"varint,20,opt,name=trigger,proto3,enum=vega.AuctionTrigger" json:"trigger,omitempty"`
	// When a market auction is extended, this field indicates what caused the extension
	ExtensionTrigger AuctionTrigger `protobuf:"varint,21,opt,name=extension_trigger,json=extensionTrigger,proto3,enum=vega.AuctionTrigger" json:"extension_trigger,omitempty"`
	// Targeted stake for the given market
	TargetStake string `protobuf:"bytes,22,opt,name=target_stake,json=targetStake,proto3" json:"target_stake,omitempty"`
	// Available stake for the given market
	SuppliedStake string `protobuf:"bytes,23,opt,name=supplied_stake,json=suppliedStake,proto3" json:"supplied_stake,omitempty"`
	// One or more price monitoring bounds for the current timestamp
	PriceMonitoringBounds []*PriceMonitoringBounds `protobuf:"bytes,24,rep,name=price_monitoring_bounds,json=priceMonitoringBounds,proto3" json:"price_monitoring_bounds,omitempty"`
	// the market value proxy
	MarketValueProxy string `protobuf:"bytes,25,opt,name=market_value_proxy,json=marketValueProxy,proto3" json:"market_value_proxy,omitempty"`
	// the equity like share of liquidity fee for each liquidity provider
	LiquidityProviderFeeShare []*LiquidityProviderFeeShare `protobuf:"bytes,26,rep,name=liquidity_provider_fee_share,json=liquidityProviderFeeShare,proto3" json:"liquidity_provider_fee_share,omitempty"`
	XXX_NoUnkeyedLiteral      struct{}                     `json:"-"`
	XXX_unrecognized          []byte                       `json:"-"`
	XXX_sizecache             int32                        `json:"-"`
}

func (m *MarketData) Reset()         { *m = MarketData{} }
func (m *MarketData) String() string { return proto.CompactTextString(m) }
func (*MarketData) ProtoMessage()    {}
func (*MarketData) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{31}
}

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

var xxx_messageInfo_MarketData proto.InternalMessageInfo

func (m *MarketData) GetMarkPrice() uint64 {
	if m != nil {
		return m.MarkPrice
	}
	return 0
}

func (m *MarketData) GetBestBidPrice() uint64 {
	if m != nil {
		return m.BestBidPrice
	}
	return 0
}

func (m *MarketData) GetBestBidVolume() uint64 {
	if m != nil {
		return m.BestBidVolume
	}
	return 0
}

func (m *MarketData) GetBestOfferPrice() uint64 {
	if m != nil {
		return m.BestOfferPrice
	}
	return 0
}

func (m *MarketData) GetBestOfferVolume() uint64 {
	if m != nil {
		return m.BestOfferVolume
	}
	return 0
}

func (m *MarketData) GetBestStaticBidPrice() uint64 {
	if m != nil {
		return m.BestStaticBidPrice
	}
	return 0
}

func (m *MarketData) GetBestStaticBidVolume() uint64 {
	if m != nil {
		return m.BestStaticBidVolume
	}
	return 0
}

func (m *MarketData) GetBestStaticOfferPrice() uint64 {
	if m != nil {
		return m.BestStaticOfferPrice
	}
	return 0
}

func (m *MarketData) GetBestStaticOfferVolume() uint64 {
	if m != nil {
		return m.BestStaticOfferVolume
	}
	return 0
}

func (m *MarketData) GetMidPrice() uint64 {
	if m != nil {
		return m.MidPrice
	}
	return 0
}

func (m *MarketData) GetStaticMidPrice() uint64 {
	if m != nil {
		return m.StaticMidPrice
	}
	return 0
}

func (m *MarketData) GetMarket() string {
	if m != nil {
		return m.Market
	}
	return ""
}

func (m *MarketData) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *MarketData) GetOpenInterest() uint64 {
	if m != nil {
		return m.OpenInterest
	}
	return 0
}

func (m *MarketData) GetAuctionEnd() int64 {
	if m != nil {
		return m.AuctionEnd
	}
	return 0
}

func (m *MarketData) GetAuctionStart() int64 {
	if m != nil {
		return m.AuctionStart
	}
	return 0
}

func (m *MarketData) GetIndicativePrice() uint64 {
	if m != nil {
		return m.IndicativePrice
	}
	return 0
}

func (m *MarketData) GetIndicativeVolume() uint64 {
	if m != nil {
		return m.IndicativeVolume
	}
	return 0
}

func (m *MarketData) GetMarketTradingMode() Market_TradingMode {
	if m != nil {
		return m.MarketTradingMode
	}
	return Market_TRADING_MODE_UNSPECIFIED
}

func (m *MarketData) GetTrigger() AuctionTrigger {
	if m != nil {
		return m.Trigger
	}
	return AuctionTrigger_AUCTION_TRIGGER_UNSPECIFIED
}

func (m *MarketData) GetExtensionTrigger() AuctionTrigger {
	if m != nil {
		return m.ExtensionTrigger
	}
	return AuctionTrigger_AUCTION_TRIGGER_UNSPECIFIED
}

func (m *MarketData) GetTargetStake() string {
	if m != nil {
		return m.TargetStake
	}
	return ""
}

func (m *MarketData) GetSuppliedStake() string {
	if m != nil {
		return m.SuppliedStake
	}
	return ""
}

func (m *MarketData) GetPriceMonitoringBounds() []*PriceMonitoringBounds {
	if m != nil {
		return m.PriceMonitoringBounds
	}
	return nil
}

func (m *MarketData) GetMarketValueProxy() string {
	if m != nil {
		return m.MarketValueProxy
	}
	return ""
}

func (m *MarketData) GetLiquidityProviderFeeShare() []*LiquidityProviderFeeShare {
	if m != nil {
		return m.LiquidityProviderFeeShare
	}
	return nil
}

// The equity like share of liquidity fee for each liquidity provider
type LiquidityProviderFeeShare struct {
	// The liquidity provider party id
	Party string `protobuf:"bytes,1,opt,name=party,proto3" json:"party,omitempty"`
	// The share own by this liquidity provider (float)
	EquityLikeShare string `protobuf:"bytes,2,opt,name=equity_like_share,json=equityLikeShare,proto3" json:"equity_like_share,omitempty"`
	// The average entry valuation of the liquidity provider for the market
	AverageEntryValuation string   `protobuf:"bytes,3,opt,name=average_entry_valuation,json=averageEntryValuation,proto3" json:"average_entry_valuation,omitempty"`
	XXX_NoUnkeyedLiteral  struct{} `json:"-"`
	XXX_unrecognized      []byte   `json:"-"`
	XXX_sizecache         int32    `json:"-"`
}

func (m *LiquidityProviderFeeShare) Reset()         { *m = LiquidityProviderFeeShare{} }
func (m *LiquidityProviderFeeShare) String() string { return proto.CompactTextString(m) }
func (*LiquidityProviderFeeShare) ProtoMessage()    {}
func (*LiquidityProviderFeeShare) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{32}
}

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

var xxx_messageInfo_LiquidityProviderFeeShare proto.InternalMessageInfo

func (m *LiquidityProviderFeeShare) GetParty() string {
	if m != nil {
		return m.Party
	}
	return ""
}

func (m *LiquidityProviderFeeShare) GetEquityLikeShare() string {
	if m != nil {
		return m.EquityLikeShare
	}
	return ""
}

func (m *LiquidityProviderFeeShare) GetAverageEntryValuation() string {
	if m != nil {
		return m.AverageEntryValuation
	}
	return ""
}

// Represents a list of valid (at the current timestamp) price ranges per associated trigger
type PriceMonitoringBounds struct {
	// Minimum price that isn't currently breaching the specified price monitoring trigger
	MinValidPrice uint64 `protobuf:"varint,1,opt,name=min_valid_price,json=minValidPrice,proto3" json:"min_valid_price,omitempty"`
	// Maximum price that isn't currently breaching the specified price monitoring trigger
	MaxValidPrice uint64 `protobuf:"varint,2,opt,name=max_valid_price,json=maxValidPrice,proto3" json:"max_valid_price,omitempty"`
	// Price monitoring trigger associated with the bounds
	Trigger *PriceMonitoringTrigger `protobuf:"bytes,3,opt,name=trigger,proto3" json:"trigger,omitempty"`
	// Reference price used to calculate the valid price range
	ReferencePrice       float64  `protobuf:"fixed64,4,opt,name=reference_price,json=referencePrice,proto3" json:"reference_price,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PriceMonitoringBounds) Reset()         { *m = PriceMonitoringBounds{} }
func (m *PriceMonitoringBounds) String() string { return proto.CompactTextString(m) }
func (*PriceMonitoringBounds) ProtoMessage()    {}
func (*PriceMonitoringBounds) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{33}
}

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

var xxx_messageInfo_PriceMonitoringBounds proto.InternalMessageInfo

func (m *PriceMonitoringBounds) GetMinValidPrice() uint64 {
	if m != nil {
		return m.MinValidPrice
	}
	return 0
}

func (m *PriceMonitoringBounds) GetMaxValidPrice() uint64 {
	if m != nil {
		return m.MaxValidPrice
	}
	return 0
}

func (m *PriceMonitoringBounds) GetTrigger() *PriceMonitoringTrigger {
	if m != nil {
		return m.Trigger
	}
	return nil
}

func (m *PriceMonitoringBounds) GetReferencePrice() float64 {
	if m != nil {
		return m.ReferencePrice
	}
	return 0
}

// Represents Vega domain specific error information over gRPC/Protobuf
type ErrorDetail struct {
	// A Vega API domain specific unique error code, useful for client side mappings, e.g. 10004
	Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	// A message that describes the error in more detail, should describe the problem encountered
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// Any inner error information that could add more context, or be helpful for error reporting
	Inner                string   `protobuf:"bytes,3,opt,name=inner,proto3" json:"inner,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ErrorDetail proto.InternalMessageInfo

func (m *ErrorDetail) GetCode() int32 {
	if m != nil {
		return m.Code
	}
	return 0
}

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

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

// Represents a network parameter on Vega
type NetworkParameter struct {
	// The unique key
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The value for the network parameter
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NetworkParameter) Reset()         { *m = NetworkParameter{} }
func (m *NetworkParameter) String() string { return proto.CompactTextString(m) }
func (*NetworkParameter) ProtoMessage()    {}
func (*NetworkParameter) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{35}
}

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

var xxx_messageInfo_NetworkParameter proto.InternalMessageInfo

func (m *NetworkParameter) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *NetworkParameter) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

// Represents a liquidity order
type LiquidityOrder struct {
	// The pegged reference point for the order
	Reference PeggedReference `protobuf:"varint,1,opt,name=reference,proto3,enum=vega.PeggedReference" json:"reference,omitempty"`
	// The relative proportion of the commitment to be allocated at a price level
	Proportion uint32 `protobuf:"varint,2,opt,name=proportion,proto3" json:"proportion,omitempty"`
	// The offset/amount of units away for the order
	Offset               int64    `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LiquidityOrder) Reset()         { *m = LiquidityOrder{} }
func (m *LiquidityOrder) String() string { return proto.CompactTextString(m) }
func (*LiquidityOrder) ProtoMessage()    {}
func (*LiquidityOrder) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{36}
}

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

var xxx_messageInfo_LiquidityOrder proto.InternalMessageInfo

func (m *LiquidityOrder) GetReference() PeggedReference {
	if m != nil {
		return m.Reference
	}
	return PeggedReference_PEGGED_REFERENCE_UNSPECIFIED
}

func (m *LiquidityOrder) GetProportion() uint32 {
	if m != nil {
		return m.Proportion
	}
	return 0
}

func (m *LiquidityOrder) GetOffset() int64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

// A pair of a liquidity order and the id of the generated order by the core
type LiquidityOrderReference struct {
	// Unique identifier of the pegged order generated by the core to fulfil this liquidity order
	OrderId string `protobuf:"bytes,1,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"`
	// The liquidity order from the original submission
	LiquidityOrder       *LiquidityOrder `protobuf:"bytes,2,opt,name=liquidity_order,json=liquidityOrder,proto3" json:"liquidity_order,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *LiquidityOrderReference) Reset()         { *m = LiquidityOrderReference{} }
func (m *LiquidityOrderReference) String() string { return proto.CompactTextString(m) }
func (*LiquidityOrderReference) ProtoMessage()    {}
func (*LiquidityOrderReference) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{37}
}

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

var xxx_messageInfo_LiquidityOrderReference proto.InternalMessageInfo

func (m *LiquidityOrderReference) GetOrderId() string {
	if m != nil {
		return m.OrderId
	}
	return ""
}

func (m *LiquidityOrderReference) GetLiquidityOrder() *LiquidityOrder {
	if m != nil {
		return m.LiquidityOrder
	}
	return nil
}

// An Liquidity provider commitment
type LiquidityProvision struct {
	// Unique identifier
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Unique party identifier for the creator of the provision
	PartyId string `protobuf:"bytes,2,opt,name=party_id,json=partyId,proto3" json:"party_id,omitempty"`
	// Timestamp for when the order was created at, in nanoseconds since the epoch
	// - See [`VegaTimeResponse`](#api.VegaTimeResponse).`timestamp`
	CreatedAt int64 `protobuf:"varint,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Timestamp for when the order was updated at, in nanoseconds since the epoch
	// - See [`VegaTimeResponse`](#api.VegaTimeResponse).`timestamp`
	UpdatedAt int64 `protobuf:"varint,4,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// Market identifier for the order, required field
	MarketId string `protobuf:"bytes,5,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"`
	// Specified as a unitless number that represents the amount of settlement asset of the market
	CommitmentAmount uint64 `protobuf:"varint,6,opt,name=commitment_amount,json=commitmentAmount,proto3" json:"commitment_amount,omitempty"`
	// Nominated liquidity fee factor, which is an input to the calculation of taker fees on the market, as per seeting fees and rewarding liquidity providers
	Fee string `protobuf:"bytes,7,opt,name=fee,proto3" json:"fee,omitempty"`
	// A set of liquidity sell orders to meet the liquidity provision obligation
	Sells []*LiquidityOrderReference `protobuf:"bytes,8,rep,name=sells,proto3" json:"sells,omitempty"`
	// A set of liquidity buy orders to meet the liquidity provision obligation
	Buys []*LiquidityOrderReference `protobuf:"bytes,9,rep,name=buys,proto3" json:"buys,omitempty"`
	// Version of this liquidity provision order
	Version string `protobuf:"bytes,10,opt,name=version,proto3" json:"version,omitempty"`
	// Status of this liquidity provision order
	Status LiquidityProvision_Status `protobuf:"varint,11,opt,name=status,proto3,enum=vega.LiquidityProvision_Status" json:"status,omitempty"`
	// A reference shared between this liquidity provision and all it's orders
	Reference            string   `protobuf:"bytes,12,opt,name=reference,proto3" json:"reference,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LiquidityProvision) Reset()         { *m = LiquidityProvision{} }
func (m *LiquidityProvision) String() string { return proto.CompactTextString(m) }
func (*LiquidityProvision) ProtoMessage()    {}
func (*LiquidityProvision) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{38}
}

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

var xxx_messageInfo_LiquidityProvision proto.InternalMessageInfo

func (m *LiquidityProvision) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *LiquidityProvision) GetPartyId() string {
	if m != nil {
		return m.PartyId
	}
	return ""
}

func (m *LiquidityProvision) GetCreatedAt() int64 {
	if m != nil {
		return m.CreatedAt
	}
	return 0
}

func (m *LiquidityProvision) GetUpdatedAt() int64 {
	if m != nil {
		return m.UpdatedAt
	}
	return 0
}

func (m *LiquidityProvision) GetMarketId() string {
	if m != nil {
		return m.MarketId
	}
	return ""
}

func (m *LiquidityProvision) GetCommitmentAmount() uint64 {
	if m != nil {
		return m.CommitmentAmount
	}
	return 0
}

func (m *LiquidityProvision) GetFee() string {
	if m != nil {
		return m.Fee
	}
	return ""
}

func (m *LiquidityProvision) GetSells() []*LiquidityOrderReference {
	if m != nil {
		return m.Sells
	}
	return nil
}

func (m *LiquidityProvision) GetBuys() []*LiquidityOrderReference {
	if m != nil {
		return m.Buys
	}
	return nil
}

func (m *LiquidityProvision) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *LiquidityProvision) GetStatus() LiquidityProvision_Status {
	if m != nil {
		return m.Status
	}
	return LiquidityProvision_STATUS_UNSPECIFIED
}

func (m *LiquidityProvision) GetReference() string {
	if m != nil {
		return m.Reference
	}
	return ""
}

// Ethereum configuration details
type EthereumConfig struct {
	// Network identifier of this Ethereum network
	NetworkId string `protobuf:"bytes,1,opt,name=network_id,json=networkId,proto3" json:"network_id,omitempty"`
	// Chain identifier of this Ethereum network
	ChainId string `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	// Bridge address for this Ethereum network
	BridgeAddress string `protobuf:"bytes,3,opt,name=bridge_address,json=bridgeAddress,proto3" json:"bridge_address,omitempty"`
	// Number of confirmations
	Confirmations uint32 `protobuf:"varint,4,opt,name=confirmations,proto3" json:"confirmations,omitempty"`
	// Staking Bridge addresses for the ethereum network
	StakingBridgeAddresses []string `protobuf:"bytes,5,rep,name=staking_bridge_addresses,json=stakingBridgeAddresses,proto3" json:"staking_bridge_addresses,omitempty"`
	XXX_NoUnkeyedLiteral   struct{} `json:"-"`
	XXX_unrecognized       []byte   `json:"-"`
	XXX_sizecache          int32    `json:"-"`
}

func (m *EthereumConfig) Reset()         { *m = EthereumConfig{} }
func (m *EthereumConfig) String() string { return proto.CompactTextString(m) }
func (*EthereumConfig) ProtoMessage()    {}
func (*EthereumConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{39}
}

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

var xxx_messageInfo_EthereumConfig proto.InternalMessageInfo

func (m *EthereumConfig) GetNetworkId() string {
	if m != nil {
		return m.NetworkId
	}
	return ""
}

func (m *EthereumConfig) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

func (m *EthereumConfig) GetBridgeAddress() string {
	if m != nil {
		return m.BridgeAddress
	}
	return ""
}

func (m *EthereumConfig) GetConfirmations() uint32 {
	if m != nil {
		return m.Confirmations
	}
	return 0
}

func (m *EthereumConfig) GetStakingBridgeAddresses() []string {
	if m != nil {
		return m.StakingBridgeAddresses
	}
	return nil
}

// Describes in both human readable and block time when an epoch spans
type EpochTimestamps struct {
	// Timestamp of epoch start in nanoseconds, empty if not started
	// - See [`VegaTimeResponse`](#api.VegaTimeResponse).`timestamp`
	StartTime int64 `protobuf:"varint,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// Timestamp of epoch end in nanoseconds, empty if not started
	// - See [`VegaTimeResponse`](#api.VegaTimeResponse).`timestamp`
	EndTime int64 `protobuf:"varint,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	// Height of first block in the epoch
	FirstBlock uint64 `protobuf:"varint,3,opt,name=first_block,json=firstBlock,proto3" json:"first_block,omitempty"`
	// Height of last block in the epoch, empty if not ended
	LastBlock            uint64   `protobuf:"varint,4,opt,name=last_block,json=lastBlock,proto3" json:"last_block,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EpochTimestamps) Reset()         { *m = EpochTimestamps{} }
func (m *EpochTimestamps) String() string { return proto.CompactTextString(m) }
func (*EpochTimestamps) ProtoMessage()    {}
func (*EpochTimestamps) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{40}
}

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

var xxx_messageInfo_EpochTimestamps proto.InternalMessageInfo

func (m *EpochTimestamps) GetStartTime() int64 {
	if m != nil {
		return m.StartTime
	}
	return 0
}

func (m *EpochTimestamps) GetEndTime() int64 {
	if m != nil {
		return m.EndTime
	}
	return 0
}

func (m *EpochTimestamps) GetFirstBlock() uint64 {
	if m != nil {
		return m.FirstBlock
	}
	return 0
}

func (m *EpochTimestamps) GetLastBlock() uint64 {
	if m != nil {
		return m.LastBlock
	}
	return 0
}

type Epoch struct {
	// Sequence is used as epoch indentifier
	Seq uint64 `protobuf:"varint,1,opt,name=seq,proto3" json:"seq,omitempty"`
	// Timestamps for start/end etc
	Timestamps *EpochTimestamps `protobuf:"bytes,2,opt,name=timestamps,proto3" json:"timestamps,omitempty"`
	// Validators that participated in this epoch
	Validators []*Node `protobuf:"bytes,3,rep,name=validators,proto3" json:"validators,omitempty"`
	// List of all delegations in epoch
	Delegations          []*Delegation `protobuf:"bytes,4,rep,name=delegations,proto3" json:"delegations,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *Epoch) Reset()         { *m = Epoch{} }
func (m *Epoch) String() string { return proto.CompactTextString(m) }
func (*Epoch) ProtoMessage()    {}
func (*Epoch) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{41}
}

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

var xxx_messageInfo_Epoch proto.InternalMessageInfo

func (m *Epoch) GetSeq() uint64 {
	if m != nil {
		return m.Seq
	}
	return 0
}

func (m *Epoch) GetTimestamps() *EpochTimestamps {
	if m != nil {
		return m.Timestamps
	}
	return nil
}

func (m *Epoch) GetValidators() []*Node {
	if m != nil {
		return m.Validators
	}
	return nil
}

func (m *Epoch) GetDelegations() []*Delegation {
	if m != nil {
		return m.Delegations
	}
	return nil
}

type EpochParticipation struct {
	Epoch                *Epoch   `protobuf:"bytes,1,opt,name=epoch,proto3" json:"epoch,omitempty"`
	Offline              uint64   `protobuf:"varint,2,opt,name=offline,proto3" json:"offline,omitempty"`
	Online               uint64   `protobuf:"varint,3,opt,name=online,proto3" json:"online,omitempty"`
	TotalRewards         float64  `protobuf:"fixed64,4,opt,name=total_rewards,json=totalRewards,proto3" json:"total_rewards,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EpochParticipation) Reset()         { *m = EpochParticipation{} }
func (m *EpochParticipation) String() string { return proto.CompactTextString(m) }
func (*EpochParticipation) ProtoMessage()    {}
func (*EpochParticipation) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{42}
}

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

var xxx_messageInfo_EpochParticipation proto.InternalMessageInfo

func (m *EpochParticipation) GetEpoch() *Epoch {
	if m != nil {
		return m.Epoch
	}
	return nil
}

func (m *EpochParticipation) GetOffline() uint64 {
	if m != nil {
		return m.Offline
	}
	return 0
}

func (m *EpochParticipation) GetOnline() uint64 {
	if m != nil {
		return m.Online
	}
	return 0
}

func (m *EpochParticipation) GetTotalRewards() float64 {
	if m != nil {
		return m.TotalRewards
	}
	return 0
}

type EpochData struct {
	// Total number of epochs since node was created
	Total int32 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
	// Total number of offline epochs since node was created
	Offline int32 `protobuf:"varint,2,opt,name=offline,proto3" json:"offline,omitempty"`
	// Total number of online epochs since node was created
	Online               int32    `protobuf:"varint,3,opt,name=online,proto3" json:"online,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EpochData) Reset()         { *m = EpochData{} }
func (m *EpochData) String() string { return proto.CompactTextString(m) }
func (*EpochData) ProtoMessage()    {}
func (*EpochData) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{43}
}

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

var xxx_messageInfo_EpochData proto.InternalMessageInfo

func (m *EpochData) GetTotal() int32 {
	if m != nil {
		return m.Total
	}
	return 0
}

func (m *EpochData) GetOffline() int32 {
	if m != nil {
		return m.Offline
	}
	return 0
}

func (m *EpochData) GetOnline() int32 {
	if m != nil {
		return m.Online
	}
	return 0
}

type Node struct {
	// The node url eg n01.vega.xyz
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Pub key of the node operator
	PubKey string `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
	// URL where I can find out more info on the node
	InfoUrl string `protobuf:"bytes,3,opt,name=info_url,json=infoUrl,proto3" json:"info_url,omitempty"`
	// Country code for the location of the node
	Location string `protobuf:"bytes,4,opt,name=location,proto3" json:"location,omitempty"`
	// The amount the node has put up themselves
	StakedByOperator string `protobuf:"bytes,5,opt,name=staked_by_operator,json=stakedByOperator,proto3" json:"staked_by_operator,omitempty"`
	// The amount of stake that has been delegated by token holders
	StakedByDelegates string `protobuf:"bytes,6,opt,name=staked_by_delegates,json=stakedByDelegates,proto3" json:"staked_by_delegates,omitempty"`
	// Total amount staked on node
	StakedTotal string `protobuf:"bytes,7,opt,name=staked_total,json=stakedTotal,proto3" json:"staked_total,omitempty"`
	// Max amount of (wanted) stake, is this a network param or a node param
	MaxIntendedStake string `protobuf:"bytes,8,opt,name=max_intended_stake,json=maxIntendedStake,proto3" json:"max_intended_stake,omitempty"`
	// Amount of stake on the next epoch
	PendingStake string `protobuf:"bytes,9,opt,name=pending_stake,json=pendingStake,proto3" json:"pending_stake,omitempty"`
	// Informantion about epoch
	EpochData *EpochData `protobuf:"bytes,10,opt,name=epoch_data,json=epochData,proto3" json:"epoch_data,omitempty"`
	// Node status
	Status NodeStatus `protobuf:"varint,11,opt,name=status,proto3,enum=vega.NodeStatus" json:"status,omitempty"`
	// Node's delegations
	Delagations          []*Delegation `protobuf:"bytes,12,rep,name=delagations,proto3" json:"delagations,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *Node) Reset()         { *m = Node{} }
func (m *Node) String() string { return proto.CompactTextString(m) }
func (*Node) ProtoMessage()    {}
func (*Node) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{44}
}

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

var xxx_messageInfo_Node proto.InternalMessageInfo

func (m *Node) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Node) GetPubKey() string {
	if m != nil {
		return m.PubKey
	}
	return ""
}

func (m *Node) GetInfoUrl() string {
	if m != nil {
		return m.InfoUrl
	}
	return ""
}

func (m *Node) GetLocation() string {
	if m != nil {
		return m.Location
	}
	return ""
}

func (m *Node) GetStakedByOperator() string {
	if m != nil {
		return m.StakedByOperator
	}
	return ""
}

func (m *Node) GetStakedByDelegates() string {
	if m != nil {
		return m.StakedByDelegates
	}
	return ""
}

func (m *Node) GetStakedTotal() string {
	if m != nil {
		return m.StakedTotal
	}
	return ""
}

func (m *Node) GetMaxIntendedStake() string {
	if m != nil {
		return m.MaxIntendedStake
	}
	return ""
}

func (m *Node) GetPendingStake() string {
	if m != nil {
		return m.PendingStake
	}
	return ""
}

func (m *Node) GetEpochData() *EpochData {
	if m != nil {
		return m.EpochData
	}
	return nil
}

func (m *Node) GetStatus() NodeStatus {
	if m != nil {
		return m.Status
	}
	return NodeStatus_NODE_STATUS_UNSPECIFIED
}

func (m *Node) GetDelagations() []*Delegation {
	if m != nil {
		return m.Delagations
	}
	return nil
}

type NodeData struct {
	// Total staked amount across all nodes
	StakedTotal string `protobuf:"bytes,1,opt,name=staked_total,json=stakedTotal,proto3" json:"staked_total,omitempty"`
	// Total number of nodes
	TotalNodes uint32 `protobuf:"varint,2,opt,name=total_nodes,json=totalNodes,proto3" json:"total_nodes,omitempty"`
	// Number of inactive nodes
	InactiveNodes uint32 `protobuf:"varint,3,opt,name=inactive_nodes,json=inactiveNodes,proto3" json:"inactive_nodes,omitempty"`
	// Number of nodes validating
	ValidatingNodes uint32 `protobuf:"varint,4,opt,name=validating_nodes,json=validatingNodes,proto3" json:"validating_nodes,omitempty"`
	// Total uptime for all epochs across all nodes
	Uptime               float32  `protobuf:"fixed32,5,opt,name=uptime,proto3" json:"uptime,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NodeData) Reset()         { *m = NodeData{} }
func (m *NodeData) String() string { return proto.CompactTextString(m) }
func (*NodeData) ProtoMessage()    {}
func (*NodeData) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{45}
}

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

var xxx_messageInfo_NodeData proto.InternalMessageInfo

func (m *NodeData) GetStakedTotal() string {
	if m != nil {
		return m.StakedTotal
	}
	return ""
}

func (m *NodeData) GetTotalNodes() uint32 {
	if m != nil {
		return m.TotalNodes
	}
	return 0
}

func (m *NodeData) GetInactiveNodes() uint32 {
	if m != nil {
		return m.InactiveNodes
	}
	return 0
}

func (m *NodeData) GetValidatingNodes() uint32 {
	if m != nil {
		return m.ValidatingNodes
	}
	return 0
}

func (m *NodeData) GetUptime() float32 {
	if m != nil {
		return m.Uptime
	}
	return 0
}

type Delegation struct {
	// Party which is delegating
	Party string `protobuf:"bytes,1,opt,name=party,proto3" json:"party,omitempty"`
	// Node ID
	NodeId string `protobuf:"bytes,2,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	// Amount delegated
	Amount string `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"`
	// Epoch of delegation
	EpochSeq             string   `protobuf:"bytes,4,opt,name=epoch_seq,json=epochSeq,proto3" json:"epoch_seq,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Delegation) Reset()         { *m = Delegation{} }
func (m *Delegation) String() string { return proto.CompactTextString(m) }
func (*Delegation) ProtoMessage()    {}
func (*Delegation) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{46}
}

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

var xxx_messageInfo_Delegation proto.InternalMessageInfo

func (m *Delegation) GetParty() string {
	if m != nil {
		return m.Party
	}
	return ""
}

func (m *Delegation) GetNodeId() string {
	if m != nil {
		return m.NodeId
	}
	return ""
}

func (m *Delegation) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

func (m *Delegation) GetEpochSeq() string {
	if m != nil {
		return m.EpochSeq
	}
	return ""
}

// Details for a single reward payment
type RewardDetails struct {
	AssetId              string   `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
	PartyId              string   `protobuf:"bytes,2,opt,name=party_id,json=partyId,proto3" json:"party_id,omitempty"`
	Epoch                uint64   `protobuf:"varint,3,opt,name=epoch,proto3" json:"epoch,omitempty"`
	Amount               string   `protobuf:"bytes,4,opt,name=amount,proto3" json:"amount,omitempty"`
	PercentageOfTotal    string   `protobuf:"bytes,5,opt,name=percentage_of_total,json=percentageOfTotal,proto3" json:"percentage_of_total,omitempty"`
	ReceivedAt           int64    `protobuf:"varint,6,opt,name=received_at,json=receivedAt,proto3" json:"received_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RewardDetails) Reset()         { *m = RewardDetails{} }
func (m *RewardDetails) String() string { return proto.CompactTextString(m) }
func (*RewardDetails) ProtoMessage()    {}
func (*RewardDetails) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{47}
}

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

var xxx_messageInfo_RewardDetails proto.InternalMessageInfo

func (m *RewardDetails) GetAssetId() string {
	if m != nil {
		return m.AssetId
	}
	return ""
}

func (m *RewardDetails) GetPartyId() string {
	if m != nil {
		return m.PartyId
	}
	return ""
}

func (m *RewardDetails) GetEpoch() uint64 {
	if m != nil {
		return m.Epoch
	}
	return 0
}

func (m *RewardDetails) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

func (m *RewardDetails) GetPercentageOfTotal() string {
	if m != nil {
		return m.PercentageOfTotal
	}
	return ""
}

func (m *RewardDetails) GetReceivedAt() int64 {
	if m != nil {
		return m.ReceivedAt
	}
	return 0
}

// Details for rewards for a single asset
type RewardPerAssetDetail struct {
	// asset details
	Asset string `protobuf:"bytes,1,opt,name=asset,proto3" json:"asset,omitempty"`
	// rewards ordered by received_at
	Details []*RewardDetails `protobuf:"bytes,2,rep,name=details,proto3" json:"details,omitempty"`
	// Total amount of rewards for the asset
	TotalForAsset        string   `protobuf:"bytes,3,opt,name=total_for_asset,json=totalForAsset,proto3" json:"total_for_asset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RewardPerAssetDetail) Reset()         { *m = RewardPerAssetDetail{} }
func (m *RewardPerAssetDetail) String() string { return proto.CompactTextString(m) }
func (*RewardPerAssetDetail) ProtoMessage()    {}
func (*RewardPerAssetDetail) Descriptor() ([]byte, []int) {
	return fileDescriptor_ee8879d05d97612a, []int{48}
}

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

var xxx_messageInfo_RewardPerAssetDetail proto.InternalMessageInfo

func (m *RewardPerAssetDetail) GetAsset() string {
	if m != nil {
		return m.Asset
	}
	return ""
}

func (m *RewardPerAssetDetail) GetDetails() []*RewardDetails {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *RewardPerAssetDetail) GetTotalForAsset() string {
	if m != nil {
		return m.TotalForAsset
	}
	return ""
}

func init() {
	proto.RegisterEnum("vega.Side", Side_name, Side_value)
	proto.RegisterEnum("vega.Interval", Interval_name, Interval_value)
	proto.RegisterEnum("vega.AuctionTrigger", AuctionTrigger_name, AuctionTrigger_value)
	proto.RegisterEnum("vega.PeggedReference", PeggedReference_name, PeggedReference_value)
	proto.RegisterEnum("vega.OrderError", OrderError_name, OrderError_value)
	proto.RegisterEnum("vega.ChainStatus", ChainStatus_name, ChainStatus_value)
	proto.RegisterEnum("vega.AccountType", AccountType_name, AccountType_value)
	proto.RegisterEnum("vega.TransferType", TransferType_name, TransferType_value)
	proto.RegisterEnum("vega.NodeStatus", NodeStatus_name, NodeStatus_value)
	proto.RegisterEnum("vega.Order_TimeInForce", Order_TimeInForce_name, Order_TimeInForce_value)
	proto.RegisterEnum("vega.Order_Type", Order_Type_name, Order_Type_value)
	proto.RegisterEnum("vega.Order_Status", Order_Status_name, Order_Status_value)
	proto.RegisterEnum("vega.Trade_Type", Trade_Type_name, Trade_Type_value)
	proto.RegisterEnum("vega.Deposit_Status", Deposit_Status_name, Deposit_Status_value)
	proto.RegisterEnum("vega.Withdrawal_Status", Withdrawal_Status_name, Withdrawal_Status_value)
	proto.RegisterEnum("vega.LiquidityProvision_Status", LiquidityProvision_Status_name, LiquidityProvision_Status_value)
	proto.RegisterType((*Price)(nil), "vega.Price")
	proto.RegisterType((*Timestamp)(nil), "vega.Timestamp")
	proto.RegisterType((*Party)(nil), "vega.Party")
	proto.RegisterType((*RiskFactor)(nil), "vega.RiskFactor")
	proto.RegisterType((*RiskResult)(nil), "vega.RiskResult")
	proto.RegisterMapType((map[string]*RiskFactor)(nil), "vega.RiskResult.PredictedNextRiskFactorsEntry")
	proto.RegisterMapType((map[string]*RiskFactor)(nil), "vega.RiskResult.RiskFactorsEntry")
	proto.RegisterType((*PeggedOrder)(nil), "vega.PeggedOrder")
	proto.RegisterType((*Order)(nil), "vega.Order")
	proto.RegisterType((*OrderCancellationConfirmation)(nil), "vega.OrderCancellationConfirmation")
	proto.RegisterType((*OrderConfirmation)(nil), "vega.OrderConfirmation")
	proto.RegisterType((*AuctionIndicativeState)(nil), "vega.AuctionIndicativeState")
	proto.RegisterType((*Trade)(nil), "vega.Trade")
	proto.RegisterType((*Fee)(nil), "vega.Fee")
	proto.RegisterType((*TradeSet)(nil), "vega.TradeSet")
	proto.RegisterType((*Candle)(nil), "vega.Candle")
	proto.RegisterType((*PriceLevel)(nil), "vega.PriceLevel")
	proto.RegisterType((*MarketDepth)(nil), "vega.MarketDepth")
	proto.RegisterType((*MarketDepthUpdate)(nil), "vega.MarketDepthUpdate")
	proto.RegisterType((*Position)(nil), "vega.Position")
	proto.RegisterType((*PositionTrade)(nil), "vega.PositionTrade")
	proto.RegisterType((*Deposit)(nil), "vega.Deposit")
	proto.RegisterType((*Withdrawal)(nil), "vega.Withdrawal")
	proto.RegisterType((*WithdrawExt)(nil), "vega.WithdrawExt")
	proto.RegisterType((*Erc20WithdrawExt)(nil), "vega.Erc20WithdrawExt")
	proto.RegisterType((*Account)(nil), "vega.Account")
	proto.RegisterType((*FinancialAmount)(nil), "vega.FinancialAmount")
	proto.RegisterType((*Transfer)(nil), "vega.Transfer")
	proto.RegisterType((*TransferRequest)(nil), "vega.TransferRequest")
	proto.RegisterType((*LedgerEntry)(nil), "vega.LedgerEntry")
	proto.RegisterType((*TransferBalance)(nil), "vega.TransferBalance")
	proto.RegisterType((*TransferResponse)(nil), "vega.TransferResponse")
	proto.RegisterType((*MarginLevels)(nil), "vega.MarginLevels")
	proto.RegisterType((*MarketData)(nil), "vega.MarketData")
	proto.RegisterType((*LiquidityProviderFeeShare)(nil), "vega.LiquidityProviderFeeShare")
	proto.RegisterType((*PriceMonitoringBounds)(nil), "vega.PriceMonitoringBounds")
	proto.RegisterType((*ErrorDetail)(nil), "vega.ErrorDetail")
	proto.RegisterType((*NetworkParameter)(nil), "vega.NetworkParameter")
	proto.RegisterType((*LiquidityOrder)(nil), "vega.LiquidityOrder")
	proto.RegisterType((*LiquidityOrderReference)(nil), "vega.LiquidityOrderReference")
	proto.RegisterType((*LiquidityProvision)(nil), "vega.LiquidityProvision")
	proto.RegisterType((*EthereumConfig)(nil), "vega.EthereumConfig")
	proto.RegisterType((*EpochTimestamps)(nil), "vega.EpochTimestamps")
	proto.RegisterType((*Epoch)(nil), "vega.Epoch")
	proto.RegisterType((*EpochParticipation)(nil), "vega.EpochParticipation")
	proto.RegisterType((*EpochData)(nil), "vega.EpochData")
	proto.RegisterType((*Node)(nil), "vega.Node")
	proto.RegisterType((*NodeData)(nil), "vega.NodeData")
	proto.RegisterType((*Delegation)(nil), "vega.Delegation")
	proto.RegisterType((*RewardDetails)(nil), "vega.RewardDetails")
	proto.RegisterType((*RewardPerAssetDetail)(nil), "vega.RewardPerAssetDetail")
}

func init() { proto.RegisterFile("vega/vega.proto", fileDescriptor_ee8879d05d97612a) }

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