// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: provenance/ledger/v1/events.proto

package types

import (
	fmt "fmt"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// UpdateType is the type of data update that caused the EventLedgerUpdated event to be emitted.
// This is used to identify the specific update that caused the event to be emitted.
type UpdateType int32

const (
	// The update type is unspecified.
	UPDATE_TYPE_UNSPECIFIED UpdateType = 0
	// The status of the ledger was updated.
	UPDATE_TYPE_STATUS UpdateType = 1
	// The interest rate of the ledger was updated.
	UPDATE_TYPE_INTEREST_RATE UpdateType = 2
	// The payment of the ledger was updated.
	UPDATE_TYPE_PAYMENT UpdateType = 3
	// The maturity date of the ledger was updated.
	UPDATE_TYPE_MATURITY_DATE UpdateType = 4
)

var UpdateType_name = map[int32]string{
	0: "UPDATE_TYPE_UNSPECIFIED",
	1: "UPDATE_TYPE_STATUS",
	2: "UPDATE_TYPE_INTEREST_RATE",
	3: "UPDATE_TYPE_PAYMENT",
	4: "UPDATE_TYPE_MATURITY_DATE",
}

var UpdateType_value = map[string]int32{
	"UPDATE_TYPE_UNSPECIFIED":   0,
	"UPDATE_TYPE_STATUS":        1,
	"UPDATE_TYPE_INTEREST_RATE": 2,
	"UPDATE_TYPE_PAYMENT":       3,
	"UPDATE_TYPE_MATURITY_DATE": 4,
}

func (x UpdateType) String() string {
	return proto.EnumName(UpdateType_name, int32(x))
}

func (UpdateType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_805ee43b97f8de5c, []int{0}
}

// ClassTypeCreated is the type of data that caused the EventLedgerClassTypeCreated event to be emitted.
// This is used to identify the specific type that was just created.
type ClassTypeCreated int32

const (
	// CLASS_TYPE_CREATED_UNSPECIFIED indicates that the class type is unspecified.
	CLASS_TYPE_CREATED_UNSPECIFIED ClassTypeCreated = 0
	// CLASS_TYPE_CREATED_STATUS is for when a LedgerClassStatusType is created.
	CLASS_TYPE_CREATED_STATUS ClassTypeCreated = 1
	// CLASS_TYPE_CREATED_ENTRY is for when a LedgerClassEntryType is created.
	CLASS_TYPE_CREATED_ENTRY ClassTypeCreated = 2
	// CLASS_TYPE_CREATED_BUCKET is for when a LedgerClassBucketType is created.
	CLASS_TYPE_CREATED_BUCKET ClassTypeCreated = 3
)

var ClassTypeCreated_name = map[int32]string{
	0: "CLASS_TYPE_CREATED_UNSPECIFIED",
	1: "CLASS_TYPE_CREATED_STATUS",
	2: "CLASS_TYPE_CREATED_ENTRY",
	3: "CLASS_TYPE_CREATED_BUCKET",
}

var ClassTypeCreated_value = map[string]int32{
	"CLASS_TYPE_CREATED_UNSPECIFIED": 0,
	"CLASS_TYPE_CREATED_STATUS":      1,
	"CLASS_TYPE_CREATED_ENTRY":       2,
	"CLASS_TYPE_CREATED_BUCKET":      3,
}

func (x ClassTypeCreated) String() string {
	return proto.EnumName(ClassTypeCreated_name, int32(x))
}

func (ClassTypeCreated) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_805ee43b97f8de5c, []int{1}
}

// EventLedgerCreated is emitted when a new ledger is created for an asset.
// This event is triggered by the MsgCreateLedger message handler when a
// ledger is successfully created for a specific NFT or scope.
type EventLedgerCreated struct {
	// asset class of the ledger.
	AssetClassId string `protobuf:"bytes,1,opt,name=asset_class_id,json=assetClassId,proto3" json:"asset_class_id,omitempty"`
	// nft id of the ledger (scope id or nft id).
	NftId string `protobuf:"bytes,2,opt,name=nft_id,json=nftId,proto3" json:"nft_id,omitempty"`
}

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

var xxx_messageInfo_EventLedgerCreated proto.InternalMessageInfo

func (m *EventLedgerCreated) GetAssetClassId() string {
	if m != nil {
		return m.AssetClassId
	}
	return ""
}

func (m *EventLedgerCreated) GetNftId() string {
	if m != nil {
		return m.NftId
	}
	return ""
}

// EventLedgerUpdated is emitted when a ledger's configuration is updated.
// This event is triggered by various update message handlers such as
// MsgUpdateLedgerStatus, MsgUpdateLedgerInterestRate, MsgUpdateLedgerPayment,
// and MsgUpdateLedgerMaturityDate when a ledger's configuration is
// successfully modified.
type EventLedgerUpdated struct {
	// asset class of the ledger.
	AssetClassId string `protobuf:"bytes,1,opt,name=asset_class_id,json=assetClassId,proto3" json:"asset_class_id,omitempty"`
	// nft id of the ledger (scope id or nft id).
	NftId string `protobuf:"bytes,2,opt,name=nft_id,json=nftId,proto3" json:"nft_id,omitempty"`
	// What type of data update caused this event to be emitted.
	UpdateType UpdateType `protobuf:"varint,3,opt,name=update_type,json=updateType,proto3,enum=provenance.ledger.v1.UpdateType" json:"update_type,omitempty"`
}

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

var xxx_messageInfo_EventLedgerUpdated proto.InternalMessageInfo

func (m *EventLedgerUpdated) GetAssetClassId() string {
	if m != nil {
		return m.AssetClassId
	}
	return ""
}

func (m *EventLedgerUpdated) GetNftId() string {
	if m != nil {
		return m.NftId
	}
	return ""
}

func (m *EventLedgerUpdated) GetUpdateType() UpdateType {
	if m != nil {
		return m.UpdateType
	}
	return UPDATE_TYPE_UNSPECIFIED
}

// EventLedgerEntryAdded is emitted when a new entry is added to a ledger.
// This event is triggered by the MsgAppendLedgerEntry message handler when
// one or more ledger entries are successfully added to an existing ledger.
type EventLedgerEntryAdded struct {
	// asset class of the ledger.
	AssetClassId string `protobuf:"bytes,1,opt,name=asset_class_id,json=assetClassId,proto3" json:"asset_class_id,omitempty"`
	// nft id of the ledger (scope id or nft id).
	NftId string `protobuf:"bytes,2,opt,name=nft_id,json=nftId,proto3" json:"nft_id,omitempty"`
	// correlation id of the ledger entry.
	CorrelationId string `protobuf:"bytes,3,opt,name=correlation_id,json=correlationId,proto3" json:"correlation_id,omitempty"`
}

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

var xxx_messageInfo_EventLedgerEntryAdded proto.InternalMessageInfo

func (m *EventLedgerEntryAdded) GetAssetClassId() string {
	if m != nil {
		return m.AssetClassId
	}
	return ""
}

func (m *EventLedgerEntryAdded) GetNftId() string {
	if m != nil {
		return m.NftId
	}
	return ""
}

func (m *EventLedgerEntryAdded) GetCorrelationId() string {
	if m != nil {
		return m.CorrelationId
	}
	return ""
}

// EventLedgerEntryUpdated is emitted when an existing ledger entry is updated.
// This event is triggered by the UpdateBalances message handler when a ledger
// entry is successfully updated.
type EventLedgerEntryUpdated struct {
	// asset class of the ledger.
	AssetClassId string `protobuf:"bytes,1,opt,name=asset_class_id,json=assetClassId,proto3" json:"asset_class_id,omitempty"`
	// nft id of the ledger (scope id or nft id).
	NftId string `protobuf:"bytes,2,opt,name=nft_id,json=nftId,proto3" json:"nft_id,omitempty"`
	// correlation id of the ledger entry.
	CorrelationId string `protobuf:"bytes,3,opt,name=correlation_id,json=correlationId,proto3" json:"correlation_id,omitempty"`
}

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

var xxx_messageInfo_EventLedgerEntryUpdated proto.InternalMessageInfo

func (m *EventLedgerEntryUpdated) GetAssetClassId() string {
	if m != nil {
		return m.AssetClassId
	}
	return ""
}

func (m *EventLedgerEntryUpdated) GetNftId() string {
	if m != nil {
		return m.NftId
	}
	return ""
}

func (m *EventLedgerEntryUpdated) GetCorrelationId() string {
	if m != nil {
		return m.CorrelationId
	}
	return ""
}

// EventFundTransferWithSettlement is emitted when funds are transferred with
// settlement instructions. This event is triggered by the
// MsgTransferFundsWithSettlement message handler when a fund transfer with
// settlement instructions is successfully processed.
type EventFundTransferWithSettlement struct {
	// asset class of the ledger.
	AssetClassId string `protobuf:"bytes,1,opt,name=asset_class_id,json=assetClassId,proto3" json:"asset_class_id,omitempty"`
	// nft id of the ledger (scope id or nft id).
	NftId string `protobuf:"bytes,2,opt,name=nft_id,json=nftId,proto3" json:"nft_id,omitempty"`
	// correlation id of the ledger entry.
	CorrelationId string `protobuf:"bytes,3,opt,name=correlation_id,json=correlationId,proto3" json:"correlation_id,omitempty"`
}

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

var xxx_messageInfo_EventFundTransferWithSettlement proto.InternalMessageInfo

func (m *EventFundTransferWithSettlement) GetAssetClassId() string {
	if m != nil {
		return m.AssetClassId
	}
	return ""
}

func (m *EventFundTransferWithSettlement) GetNftId() string {
	if m != nil {
		return m.NftId
	}
	return ""
}

func (m *EventFundTransferWithSettlement) GetCorrelationId() string {
	if m != nil {
		return m.CorrelationId
	}
	return ""
}

// EventLedgerDestroyed is emitted when a ledger is destroyed.
// This event is triggered by the MsgDestroyLedger message handler when
// a ledger and all its associated data are successfully removed.
type EventLedgerDestroyed struct {
	// asset class of the ledger.
	AssetClassId string `protobuf:"bytes,1,opt,name=asset_class_id,json=assetClassId,proto3" json:"asset_class_id,omitempty"`
	// nft id of the ledger (scope id or nft id).
	NftId string `protobuf:"bytes,2,opt,name=nft_id,json=nftId,proto3" json:"nft_id,omitempty"`
}

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

var xxx_messageInfo_EventLedgerDestroyed proto.InternalMessageInfo

func (m *EventLedgerDestroyed) GetAssetClassId() string {
	if m != nil {
		return m.AssetClassId
	}
	return ""
}

func (m *EventLedgerDestroyed) GetNftId() string {
	if m != nil {
		return m.NftId
	}
	return ""
}

// EventLedgerClassCreated is emitted when a ledger class is created.
// This event is triggered by the MsgCreateLedgerClassRequest message handler
// when a new ledger class is created.
type EventLedgerClassCreated struct {
	// The id of the ledger class that was created.
	LedgerClassId string `protobuf:"bytes,1,opt,name=ledger_class_id,json=ledgerClassId,proto3" json:"ledger_class_id,omitempty"`
	// The id of the asset class that the ledger class was created for.
	AssetClassId string `protobuf:"bytes,2,opt,name=asset_class_id,json=assetClassId,proto3" json:"asset_class_id,omitempty"`
	// The denom that this ledger class uses.
	Denom string `protobuf:"bytes,3,opt,name=denom,proto3" json:"denom,omitempty"`
}

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

var xxx_messageInfo_EventLedgerClassCreated proto.InternalMessageInfo

func (m *EventLedgerClassCreated) GetLedgerClassId() string {
	if m != nil {
		return m.LedgerClassId
	}
	return ""
}

func (m *EventLedgerClassCreated) GetAssetClassId() string {
	if m != nil {
		return m.AssetClassId
	}
	return ""
}

func (m *EventLedgerClassCreated) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

// EventLedgerClassTypeCreated is emitted when any type for a ledger class is created.
// This event is triggered by the MsgAddLedgerClassStatusTypeRequest, MsgAddLedgerClassEntryTypeRequest,
// and MsgAddLedgerClassBucketTypeRequest message handlers when they create their respective types.
type EventLedgerClassTypeCreated struct {
	// The id of the ledger class that the type was created.
	LedgerClassId string `protobuf:"bytes,1,opt,name=ledger_class_id,json=ledgerClassId,proto3" json:"ledger_class_id,omitempty"`
	// The specific type of thing that was created.
	TypeCreated ClassTypeCreated `protobuf:"varint,2,opt,name=type_created,json=typeCreated,proto3,enum=provenance.ledger.v1.ClassTypeCreated" json:"type_created,omitempty"`
	// The id of the created type.
	Id string `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
	// The code of the created type.
	Code string `protobuf:"bytes,4,opt,name=code,proto3" json:"code,omitempty"`
}

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

var xxx_messageInfo_EventLedgerClassTypeCreated proto.InternalMessageInfo

func (m *EventLedgerClassTypeCreated) GetLedgerClassId() string {
	if m != nil {
		return m.LedgerClassId
	}
	return ""
}

func (m *EventLedgerClassTypeCreated) GetTypeCreated() ClassTypeCreated {
	if m != nil {
		return m.TypeCreated
	}
	return CLASS_TYPE_CREATED_UNSPECIFIED
}

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

func (m *EventLedgerClassTypeCreated) GetCode() string {
	if m != nil {
		return m.Code
	}
	return ""
}

func init() {
	proto.RegisterEnum("provenance.ledger.v1.UpdateType", UpdateType_name, UpdateType_value)
	proto.RegisterEnum("provenance.ledger.v1.ClassTypeCreated", ClassTypeCreated_name, ClassTypeCreated_value)
	proto.RegisterType((*EventLedgerCreated)(nil), "provenance.ledger.v1.EventLedgerCreated")
	proto.RegisterType((*EventLedgerUpdated)(nil), "provenance.ledger.v1.EventLedgerUpdated")
	proto.RegisterType((*EventLedgerEntryAdded)(nil), "provenance.ledger.v1.EventLedgerEntryAdded")
	proto.RegisterType((*EventLedgerEntryUpdated)(nil), "provenance.ledger.v1.EventLedgerEntryUpdated")
	proto.RegisterType((*EventFundTransferWithSettlement)(nil), "provenance.ledger.v1.EventFundTransferWithSettlement")
	proto.RegisterType((*EventLedgerDestroyed)(nil), "provenance.ledger.v1.EventLedgerDestroyed")
	proto.RegisterType((*EventLedgerClassCreated)(nil), "provenance.ledger.v1.EventLedgerClassCreated")
	proto.RegisterType((*EventLedgerClassTypeCreated)(nil), "provenance.ledger.v1.EventLedgerClassTypeCreated")
}

func init() { proto.RegisterFile("provenance/ledger/v1/events.proto", fileDescriptor_805ee43b97f8de5c) }

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

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

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

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

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

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

func (m *EventLedgerUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UpdateType != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.UpdateType))
		i--
		dAtA[i] = 0x18
	}
	if len(m.NftId) > 0 {
		i -= len(m.NftId)
		copy(dAtA[i:], m.NftId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.NftId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AssetClassId) > 0 {
		i -= len(m.AssetClassId)
		copy(dAtA[i:], m.AssetClassId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AssetClassId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *EventLedgerEntryAdded) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CorrelationId) > 0 {
		i -= len(m.CorrelationId)
		copy(dAtA[i:], m.CorrelationId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.CorrelationId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.NftId) > 0 {
		i -= len(m.NftId)
		copy(dAtA[i:], m.NftId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.NftId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AssetClassId) > 0 {
		i -= len(m.AssetClassId)
		copy(dAtA[i:], m.AssetClassId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AssetClassId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *EventLedgerEntryUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CorrelationId) > 0 {
		i -= len(m.CorrelationId)
		copy(dAtA[i:], m.CorrelationId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.CorrelationId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.NftId) > 0 {
		i -= len(m.NftId)
		copy(dAtA[i:], m.NftId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.NftId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AssetClassId) > 0 {
		i -= len(m.AssetClassId)
		copy(dAtA[i:], m.AssetClassId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AssetClassId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *EventFundTransferWithSettlement) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CorrelationId) > 0 {
		i -= len(m.CorrelationId)
		copy(dAtA[i:], m.CorrelationId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.CorrelationId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.NftId) > 0 {
		i -= len(m.NftId)
		copy(dAtA[i:], m.NftId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.NftId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AssetClassId) > 0 {
		i -= len(m.AssetClassId)
		copy(dAtA[i:], m.AssetClassId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AssetClassId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *EventLedgerClassCreated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Denom)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.AssetClassId) > 0 {
		i -= len(m.AssetClassId)
		copy(dAtA[i:], m.AssetClassId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AssetClassId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.LedgerClassId) > 0 {
		i -= len(m.LedgerClassId)
		copy(dAtA[i:], m.LedgerClassId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.LedgerClassId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *EventLedgerClassTypeCreated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Code) > 0 {
		i -= len(m.Code)
		copy(dAtA[i:], m.Code)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Code)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0x1a
	}
	if m.TypeCreated != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.TypeCreated))
		i--
		dAtA[i] = 0x10
	}
	if len(m.LedgerClassId) > 0 {
		i -= len(m.LedgerClassId)
		copy(dAtA[i:], m.LedgerClassId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.LedgerClassId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EventLedgerUpdated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AssetClassId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.NftId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.UpdateType != 0 {
		n += 1 + sovEvents(uint64(m.UpdateType))
	}
	return n
}

func (m *EventLedgerEntryAdded) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AssetClassId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.NftId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.CorrelationId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventLedgerEntryUpdated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AssetClassId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.NftId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.CorrelationId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventFundTransferWithSettlement) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AssetClassId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.NftId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.CorrelationId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventLedgerDestroyed) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AssetClassId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.NftId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventLedgerClassCreated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.LedgerClassId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.AssetClassId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.Denom)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventLedgerClassTypeCreated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.LedgerClassId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.TypeCreated != 0 {
		n += 1 + sovEvents(uint64(m.TypeCreated))
	}
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.Code)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func sovEvents(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozEvents(x uint64) (n int) {
	return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *EventLedgerCreated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEvents
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EventLedgerCreated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventLedgerCreated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AssetClassId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AssetClassId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NftId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NftId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

var (
	ErrInvalidLengthEvents        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEvents          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group")
)
