github.com/Finschia/finschia-sdk@v0.48.1/x/foundation/foundation.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: lbm/foundation/v1/foundation.proto

package foundation

import (
	fmt "fmt"
	types "github.com/Finschia/finschia-sdk/codec/types"
	github_com_Finschia_finschia_sdk_types "github.com/Finschia/finschia-sdk/types"
	types1 "github.com/Finschia/finschia-sdk/types"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "github.com/regen-network/cosmos-proto"
	_ "google.golang.org/protobuf/types/known/durationpb"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

// 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

type CensorshipAuthority int32

const (
	// CENSORSHIP_AUTHORITY_UNSPECIFIED defines an invalid authority.
	CensorshipAuthorityUnspecified CensorshipAuthority = 0
	// CENSORSHIP_AUTHORITY_GOVERNANCE defines x/gov authority.
	CensorshipAuthorityGovernance CensorshipAuthority = 1
	// CENSORSHIP_AUTHORITY_FOUNDATION defines x/foundation authority.
	CensorshipAuthorityFoundation CensorshipAuthority = 2
)

var CensorshipAuthority_name = map[int32]string{
	0: "CENSORSHIP_AUTHORITY_UNSPECIFIED",
	1: "CENSORSHIP_AUTHORITY_GOVERNANCE",
	2: "CENSORSHIP_AUTHORITY_FOUNDATION",
}

var CensorshipAuthority_value = map[string]int32{
	"CENSORSHIP_AUTHORITY_UNSPECIFIED": 0,
	"CENSORSHIP_AUTHORITY_GOVERNANCE":  1,
	"CENSORSHIP_AUTHORITY_FOUNDATION":  2,
}

func (x CensorshipAuthority) String() string {
	return proto.EnumName(CensorshipAuthority_name, int32(x))
}

func (CensorshipAuthority) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{0}
}

// VoteOption enumerates the valid vote options for a given proposal.
type VoteOption int32

const (
	// VOTE_OPTION_UNSPECIFIED defines a no-op vote option.
	VOTE_OPTION_UNSPECIFIED VoteOption = 0
	// VOTE_OPTION_YES defines a yes vote option.
	VOTE_OPTION_YES VoteOption = 1
	// VOTE_OPTION_ABSTAIN defines an abstain vote option.
	VOTE_OPTION_ABSTAIN VoteOption = 2
	// VOTE_OPTION_NO defines a no vote option.
	VOTE_OPTION_NO VoteOption = 3
	// VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.
	VOTE_OPTION_NO_WITH_VETO VoteOption = 4
)

var VoteOption_name = map[int32]string{
	0: "VOTE_OPTION_UNSPECIFIED",
	1: "VOTE_OPTION_YES",
	2: "VOTE_OPTION_ABSTAIN",
	3: "VOTE_OPTION_NO",
	4: "VOTE_OPTION_NO_WITH_VETO",
}

var VoteOption_value = map[string]int32{
	"VOTE_OPTION_UNSPECIFIED":  0,
	"VOTE_OPTION_YES":          1,
	"VOTE_OPTION_ABSTAIN":      2,
	"VOTE_OPTION_NO":           3,
	"VOTE_OPTION_NO_WITH_VETO": 4,
}

func (x VoteOption) String() string {
	return proto.EnumName(VoteOption_name, int32(x))
}

func (VoteOption) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{1}
}

// ProposalStatus defines proposal statuses.
type ProposalStatus int32

const (
	// An empty value is invalid and not allowed.
	PROPOSAL_STATUS_UNSPECIFIED ProposalStatus = 0
	// Initial status of a proposal when submitted.
	PROPOSAL_STATUS_SUBMITTED ProposalStatus = 1
	// Final status of a proposal when the final tally is done and the outcome
	// passes the foundation's decision policy.
	PROPOSAL_STATUS_ACCEPTED ProposalStatus = 2
	// Final status of a proposal when the final tally is done and the outcome
	// is rejected by the foundation's decision policy.
	PROPOSAL_STATUS_REJECTED ProposalStatus = 3
	// Final status of a proposal when the decision policy is modified before the
	// final tally.
	PROPOSAL_STATUS_ABORTED ProposalStatus = 4
	// A proposal can be withdrawn before the voting start time by the owner.
	// When this happens the final status is Withdrawn.
	PROPOSAL_STATUS_WITHDRAWN ProposalStatus = 5
)

var ProposalStatus_name = map[int32]string{
	0: "PROPOSAL_STATUS_UNSPECIFIED",
	1: "PROPOSAL_STATUS_SUBMITTED",
	2: "PROPOSAL_STATUS_ACCEPTED",
	3: "PROPOSAL_STATUS_REJECTED",
	4: "PROPOSAL_STATUS_ABORTED",
	5: "PROPOSAL_STATUS_WITHDRAWN",
}

var ProposalStatus_value = map[string]int32{
	"PROPOSAL_STATUS_UNSPECIFIED": 0,
	"PROPOSAL_STATUS_SUBMITTED":   1,
	"PROPOSAL_STATUS_ACCEPTED":    2,
	"PROPOSAL_STATUS_REJECTED":    3,
	"PROPOSAL_STATUS_ABORTED":     4,
	"PROPOSAL_STATUS_WITHDRAWN":   5,
}

func (x ProposalStatus) String() string {
	return proto.EnumName(ProposalStatus_name, int32(x))
}

func (ProposalStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{2}
}

// ProposalExecutorResult defines types of proposal executor results.
type ProposalExecutorResult int32

const (
	// An empty value is not allowed.
	PROPOSAL_EXECUTOR_RESULT_UNSPECIFIED ProposalExecutorResult = 0
	// We have not yet run the executor.
	PROPOSAL_EXECUTOR_RESULT_NOT_RUN ProposalExecutorResult = 1
	// The executor was successful and proposed action updated state.
	PROPOSAL_EXECUTOR_RESULT_SUCCESS ProposalExecutorResult = 2
	// The executor returned an error and proposed action didn't update state.
	PROPOSAL_EXECUTOR_RESULT_FAILURE ProposalExecutorResult = 3
)

var ProposalExecutorResult_name = map[int32]string{
	0: "PROPOSAL_EXECUTOR_RESULT_UNSPECIFIED",
	1: "PROPOSAL_EXECUTOR_RESULT_NOT_RUN",
	2: "PROPOSAL_EXECUTOR_RESULT_SUCCESS",
	3: "PROPOSAL_EXECUTOR_RESULT_FAILURE",
}

var ProposalExecutorResult_value = map[string]int32{
	"PROPOSAL_EXECUTOR_RESULT_UNSPECIFIED": 0,
	"PROPOSAL_EXECUTOR_RESULT_NOT_RUN":     1,
	"PROPOSAL_EXECUTOR_RESULT_SUCCESS":     2,
	"PROPOSAL_EXECUTOR_RESULT_FAILURE":     3,
}

func (x ProposalExecutorResult) String() string {
	return proto.EnumName(ProposalExecutorResult_name, int32(x))
}

func (ProposalExecutorResult) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{3}
}

// Params defines the parameters for the foundation module.
type Params struct {
	FoundationTax github_com_Finschia_finschia_sdk_types.Dec `protobuf:"bytes,1,opt,name=foundation_tax,json=foundationTax,proto3,customtype=github.com/Finschia/finschia-sdk/types.Dec" json:"foundation_tax"`
}

func (m *Params) Reset()         { *m = Params{} }
func (m *Params) String() string { return proto.CompactTextString(m) }
func (*Params) ProtoMessage()    {}
func (*Params) Descriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{0}
}
func (m *Params) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Params.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 *Params) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Params.Merge(m, src)
}
func (m *Params) XXX_Size() int {
	return m.Size()
}
func (m *Params) XXX_DiscardUnknown() {
	xxx_messageInfo_Params.DiscardUnknown(m)
}

var xxx_messageInfo_Params proto.InternalMessageInfo

type Censorship struct {
	MsgTypeUrl string              `protobuf:"bytes,1,opt,name=msg_type_url,json=msgTypeUrl,proto3" json:"msg_type_url,omitempty"`
	Authority  CensorshipAuthority `protobuf:"varint,2,opt,name=authority,proto3,enum=lbm.foundation.v1.CensorshipAuthority" json:"authority,omitempty"`
}

func (m *Censorship) Reset()         { *m = Censorship{} }
func (m *Censorship) String() string { return proto.CompactTextString(m) }
func (*Censorship) ProtoMessage()    {}
func (*Censorship) Descriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{1}
}
func (m *Censorship) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Censorship) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Censorship.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 *Censorship) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Censorship.Merge(m, src)
}
func (m *Censorship) XXX_Size() int {
	return m.Size()
}
func (m *Censorship) XXX_DiscardUnknown() {
	xxx_messageInfo_Censorship.DiscardUnknown(m)
}

var xxx_messageInfo_Censorship proto.InternalMessageInfo

func (m *Censorship) GetMsgTypeUrl() string {
	if m != nil {
		return m.MsgTypeUrl
	}
	return ""
}

func (m *Censorship) GetAuthority() CensorshipAuthority {
	if m != nil {
		return m.Authority
	}
	return CensorshipAuthorityUnspecified
}

// Member represents a foundation member with an account address and metadata.
type Member struct {
	// address is the member's account address.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// metadata is any arbitrary metadata to attached to the member.
	Metadata string `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// added_at is a timestamp specifying when a member was added.
	AddedAt time.Time `protobuf:"bytes,4,opt,name=added_at,json=addedAt,proto3,stdtime" json:"added_at"`
}

func (m *Member) Reset()         { *m = Member{} }
func (m *Member) String() string { return proto.CompactTextString(m) }
func (*Member) ProtoMessage()    {}
func (*Member) Descriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{2}
}
func (m *Member) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Member) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Member.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 *Member) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Member.Merge(m, src)
}
func (m *Member) XXX_Size() int {
	return m.Size()
}
func (m *Member) XXX_DiscardUnknown() {
	xxx_messageInfo_Member.DiscardUnknown(m)
}

var xxx_messageInfo_Member proto.InternalMessageInfo

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

func (m *Member) GetMetadata() string {
	if m != nil {
		return m.Metadata
	}
	return ""
}

func (m *Member) GetAddedAt() time.Time {
	if m != nil {
		return m.AddedAt
	}
	return time.Time{}
}

// MemberRequest represents a foundation member to be used in Msg server requests.
// Contrary to `Member`, it doesn't have any `added_at` field
// since this field cannot be set as part of requests.
type MemberRequest struct {
	// address is the member's account address.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// remove is the flag which allows one to remove the member by setting the flag to true.
	Remove bool `protobuf:"varint,2,opt,name=remove,proto3" json:"remove,omitempty"`
	// metadata is any arbitrary metadata attached to the member.
	Metadata string `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"`
}

func (m *MemberRequest) Reset()         { *m = MemberRequest{} }
func (m *MemberRequest) String() string { return proto.CompactTextString(m) }
func (*MemberRequest) ProtoMessage()    {}
func (*MemberRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{3}
}
func (m *MemberRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MemberRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MemberRequest.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 *MemberRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MemberRequest.Merge(m, src)
}
func (m *MemberRequest) XXX_Size() int {
	return m.Size()
}
func (m *MemberRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_MemberRequest.DiscardUnknown(m)
}

var xxx_messageInfo_MemberRequest proto.InternalMessageInfo

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

func (m *MemberRequest) GetRemove() bool {
	if m != nil {
		return m.Remove
	}
	return false
}

func (m *MemberRequest) GetMetadata() string {
	if m != nil {
		return m.Metadata
	}
	return ""
}

// ThresholdDecisionPolicy is a decision policy where a proposal passes when it
// satisfies the two following conditions:
// 1. The sum of all `YES` voters' weights is greater or equal than the defined
//    `threshold`.
// 2. The voting and execution periods of the proposal respect the parameters
//    given by `windows`.
type ThresholdDecisionPolicy struct {
	// threshold is the minimum sum of yes votes that must be met or exceeded for a proposal to succeed.
	Threshold github_com_Finschia_finschia_sdk_types.Dec `protobuf:"bytes,1,opt,name=threshold,proto3,customtype=github.com/Finschia/finschia-sdk/types.Dec" json:"threshold"`
	// windows defines the different windows for voting and execution.
	Windows *DecisionPolicyWindows `protobuf:"bytes,2,opt,name=windows,proto3" json:"windows,omitempty"`
}

func (m *ThresholdDecisionPolicy) Reset()         { *m = ThresholdDecisionPolicy{} }
func (m *ThresholdDecisionPolicy) String() string { return proto.CompactTextString(m) }
func (*ThresholdDecisionPolicy) ProtoMessage()    {}
func (*ThresholdDecisionPolicy) Descriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{4}
}
func (m *ThresholdDecisionPolicy) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ThresholdDecisionPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ThresholdDecisionPolicy.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 *ThresholdDecisionPolicy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ThresholdDecisionPolicy.Merge(m, src)
}
func (m *ThresholdDecisionPolicy) XXX_Size() int {
	return m.Size()
}
func (m *ThresholdDecisionPolicy) XXX_DiscardUnknown() {
	xxx_messageInfo_ThresholdDecisionPolicy.DiscardUnknown(m)
}

var xxx_messageInfo_ThresholdDecisionPolicy proto.InternalMessageInfo

func (m *ThresholdDecisionPolicy) GetWindows() *DecisionPolicyWindows {
	if m != nil {
		return m.Windows
	}
	return nil
}

// PercentageDecisionPolicy is a decision policy where a proposal passes when
// it satisfies the two following conditions:
// 1. The percentage of all `YES` voters' weights out of the total group weight
//    is greater or equal than the given `percentage`.
// 2. The voting and execution periods of the proposal respect the parameters
//    given by `windows`.
type PercentageDecisionPolicy struct {
	// percentage is the minimum percentage the sum of yes votes must meet for a proposal to succeed.
	Percentage github_com_Finschia_finschia_sdk_types.Dec `protobuf:"bytes,1,opt,name=percentage,proto3,customtype=github.com/Finschia/finschia-sdk/types.Dec" json:"percentage"`
	// windows defines the different windows for voting and execution.
	Windows *DecisionPolicyWindows `protobuf:"bytes,2,opt,name=windows,proto3" json:"windows,omitempty"`
}

func (m *PercentageDecisionPolicy) Reset()         { *m = PercentageDecisionPolicy{} }
func (m *PercentageDecisionPolicy) String() string { return proto.CompactTextString(m) }
func (*PercentageDecisionPolicy) ProtoMessage()    {}
func (*PercentageDecisionPolicy) Descriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{5}
}
func (m *PercentageDecisionPolicy) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PercentageDecisionPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PercentageDecisionPolicy.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 *PercentageDecisionPolicy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PercentageDecisionPolicy.Merge(m, src)
}
func (m *PercentageDecisionPolicy) XXX_Size() int {
	return m.Size()
}
func (m *PercentageDecisionPolicy) XXX_DiscardUnknown() {
	xxx_messageInfo_PercentageDecisionPolicy.DiscardUnknown(m)
}

var xxx_messageInfo_PercentageDecisionPolicy proto.InternalMessageInfo

func (m *PercentageDecisionPolicy) GetWindows() *DecisionPolicyWindows {
	if m != nil {
		return m.Windows
	}
	return nil
}

// DecisionPolicyWindows defines the different windows for voting and execution.
type DecisionPolicyWindows struct {
	// voting_period is the duration from submission of a proposal to the end of voting period
	// Within this times votes can be submitted with MsgVote.
	VotingPeriod time.Duration `protobuf:"bytes,1,opt,name=voting_period,json=votingPeriod,proto3,stdduration" json:"voting_period"`
	// min_execution_period is the minimum duration after the proposal submission
	// where members can start sending MsgExec. This means that the window for
	// sending a MsgExec transaction is:
	// `[ submission + min_execution_period ; submission + voting_period + max_execution_period]`
	// where max_execution_period is a app-specific config, defined in the keeper.
	// If not set, min_execution_period will default to 0.
	//
	// Please make sure to set a `min_execution_period` that is smaller than
	// `voting_period + max_execution_period`, or else the above execution window
	// is empty, meaning that all proposals created with this decision policy
	// won't be able to be executed.
	MinExecutionPeriod time.Duration `protobuf:"bytes,2,opt,name=min_execution_period,json=minExecutionPeriod,proto3,stdduration" json:"min_execution_period"`
}

func (m *DecisionPolicyWindows) Reset()         { *m = DecisionPolicyWindows{} }
func (m *DecisionPolicyWindows) String() string { return proto.CompactTextString(m) }
func (*DecisionPolicyWindows) ProtoMessage()    {}
func (*DecisionPolicyWindows) Descriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{6}
}
func (m *DecisionPolicyWindows) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DecisionPolicyWindows) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DecisionPolicyWindows.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 *DecisionPolicyWindows) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DecisionPolicyWindows.Merge(m, src)
}
func (m *DecisionPolicyWindows) XXX_Size() int {
	return m.Size()
}
func (m *DecisionPolicyWindows) XXX_DiscardUnknown() {
	xxx_messageInfo_DecisionPolicyWindows.DiscardUnknown(m)
}

var xxx_messageInfo_DecisionPolicyWindows proto.InternalMessageInfo

func (m *DecisionPolicyWindows) GetVotingPeriod() time.Duration {
	if m != nil {
		return m.VotingPeriod
	}
	return 0
}

func (m *DecisionPolicyWindows) GetMinExecutionPeriod() time.Duration {
	if m != nil {
		return m.MinExecutionPeriod
	}
	return 0
}

// OutsourcingDecisionPolicy is a dummy decision policy which is set after
// the proposal feature has been outsourced to x/group.
type OutsourcingDecisionPolicy struct {
	Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *OutsourcingDecisionPolicy) Reset()         { *m = OutsourcingDecisionPolicy{} }
func (m *OutsourcingDecisionPolicy) String() string { return proto.CompactTextString(m) }
func (*OutsourcingDecisionPolicy) ProtoMessage()    {}
func (*OutsourcingDecisionPolicy) Descriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{7}
}
func (m *OutsourcingDecisionPolicy) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OutsourcingDecisionPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OutsourcingDecisionPolicy.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 *OutsourcingDecisionPolicy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OutsourcingDecisionPolicy.Merge(m, src)
}
func (m *OutsourcingDecisionPolicy) XXX_Size() int {
	return m.Size()
}
func (m *OutsourcingDecisionPolicy) XXX_DiscardUnknown() {
	xxx_messageInfo_OutsourcingDecisionPolicy.DiscardUnknown(m)
}

var xxx_messageInfo_OutsourcingDecisionPolicy proto.InternalMessageInfo

func (m *OutsourcingDecisionPolicy) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

// FoundationInfo represents the high-level on-chain information for the foundation.
type FoundationInfo struct {
	// version is used to track changes to the foundation's membership structure that
	// would break existing proposals. Whenever any member is added or removed,
	// this version is incremented and will cause proposals based on older versions
	// of the foundation to fail
	Version uint64 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	// total_weight is the number of the foundation members.
	TotalWeight github_com_Finschia_finschia_sdk_types.Dec `protobuf:"bytes,2,opt,name=total_weight,json=totalWeight,proto3,customtype=github.com/Finschia/finschia-sdk/types.Dec" json:"total_weight"`
	// decision_policy specifies the foundation's decision policy.
	DecisionPolicy *types.Any `protobuf:"bytes,3,opt,name=decision_policy,json=decisionPolicy,proto3" json:"decision_policy,omitempty"`
}

func (m *FoundationInfo) Reset()         { *m = FoundationInfo{} }
func (m *FoundationInfo) String() string { return proto.CompactTextString(m) }
func (*FoundationInfo) ProtoMessage()    {}
func (*FoundationInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{8}
}
func (m *FoundationInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FoundationInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FoundationInfo.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 *FoundationInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FoundationInfo.Merge(m, src)
}
func (m *FoundationInfo) XXX_Size() int {
	return m.Size()
}
func (m *FoundationInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_FoundationInfo.DiscardUnknown(m)
}

var xxx_messageInfo_FoundationInfo proto.InternalMessageInfo

// Proposal defines a foundation proposal. Any member of the foundation can submit a proposal
// for a group policy to decide upon.
// A proposal consists of a set of `sdk.Msg`s that will be executed if the proposal
// passes as well as some optional metadata associated with the proposal.
type Proposal struct {
	// id is the unique id of the proposal.
	Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// metadata is any arbitrary metadata to attached to the proposal.
	Metadata string `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// proposers are the account addresses of the proposers.
	Proposers []string `protobuf:"bytes,3,rep,name=proposers,proto3" json:"proposers,omitempty"`
	// submit_time is a timestamp specifying when a proposal was submitted.
	SubmitTime time.Time `protobuf:"bytes,4,opt,name=submit_time,json=submitTime,proto3,stdtime" json:"submit_time"`
	// foundation_version tracks the version of the foundation that this proposal corresponds to.
	// When foundation info is changed, existing proposals from previous foundation versions will become invalid.
	FoundationVersion uint64 `protobuf:"varint,5,opt,name=foundation_version,json=foundationVersion,proto3" json:"foundation_version,omitempty"`
	// status represents the high level position in the life cycle of the proposal. Initial value is Submitted.
	Status ProposalStatus `protobuf:"varint,6,opt,name=status,proto3,enum=lbm.foundation.v1.ProposalStatus" json:"status,omitempty"`
	// final_tally_result contains the sums of all votes for this
	// proposal for each vote option, after tallying. When querying a proposal
	// via gRPC, this field is not populated until the proposal's voting period
	// has ended.
	FinalTallyResult TallyResult `protobuf:"bytes,7,opt,name=final_tally_result,json=finalTallyResult,proto3" json:"final_tally_result"`
	// voting_period_end is the timestamp before which voting must be done.
	// Unless a successfull MsgExec is called before (to execute a proposal whose
	// tally is successful before the voting period ends), tallying will be done
	// at this point, and the `final_tally_result`, as well
	// as `status` and `result` fields will be accordingly updated.
	VotingPeriodEnd time.Time `protobuf:"bytes,8,opt,name=voting_period_end,json=votingPeriodEnd,proto3,stdtime" json:"voting_period_end"`
	// executor_result is the final result based on the votes and election rule. Initial value is NotRun.
	ExecutorResult ProposalExecutorResult `protobuf:"varint,9,opt,name=executor_result,json=executorResult,proto3,enum=lbm.foundation.v1.ProposalExecutorResult" json:"executor_result,omitempty"`
	// messages is a list of Msgs that will be executed if the proposal passes.
	Messages []*types.Any `protobuf:"bytes,10,rep,name=messages,proto3" json:"messages,omitempty"`
}

func (m *Proposal) Reset()         { *m = Proposal{} }
func (m *Proposal) String() string { return proto.CompactTextString(m) }
func (*Proposal) ProtoMessage()    {}
func (*Proposal) Descriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{9}
}
func (m *Proposal) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Proposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Proposal.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 *Proposal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Proposal.Merge(m, src)
}
func (m *Proposal) XXX_Size() int {
	return m.Size()
}
func (m *Proposal) XXX_DiscardUnknown() {
	xxx_messageInfo_Proposal.DiscardUnknown(m)
}

var xxx_messageInfo_Proposal proto.InternalMessageInfo

// TallyResult represents the sum of votes for each vote option.
type TallyResult struct {
	// yes_count is the sum of yes votes.
	YesCount github_com_Finschia_finschia_sdk_types.Dec `protobuf:"bytes,1,opt,name=yes_count,json=yesCount,proto3,customtype=github.com/Finschia/finschia-sdk/types.Dec" json:"yes_count"`
	// abstain_count is the sum of abstainers.
	AbstainCount github_com_Finschia_finschia_sdk_types.Dec `protobuf:"bytes,2,opt,name=abstain_count,json=abstainCount,proto3,customtype=github.com/Finschia/finschia-sdk/types.Dec" json:"abstain_count"`
	// no is the sum of no votes.
	NoCount github_com_Finschia_finschia_sdk_types.Dec `protobuf:"bytes,3,opt,name=no_count,json=noCount,proto3,customtype=github.com/Finschia/finschia-sdk/types.Dec" json:"no_count"`
	// no_with_veto_count is the sum of veto.
	NoWithVetoCount github_com_Finschia_finschia_sdk_types.Dec `protobuf:"bytes,4,opt,name=no_with_veto_count,json=noWithVetoCount,proto3,customtype=github.com/Finschia/finschia-sdk/types.Dec" json:"no_with_veto_count"`
}

func (m *TallyResult) Reset()         { *m = TallyResult{} }
func (m *TallyResult) String() string { return proto.CompactTextString(m) }
func (*TallyResult) ProtoMessage()    {}
func (*TallyResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{10}
}
func (m *TallyResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TallyResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TallyResult.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 *TallyResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TallyResult.Merge(m, src)
}
func (m *TallyResult) XXX_Size() int {
	return m.Size()
}
func (m *TallyResult) XXX_DiscardUnknown() {
	xxx_messageInfo_TallyResult.DiscardUnknown(m)
}

var xxx_messageInfo_TallyResult proto.InternalMessageInfo

// Vote represents a vote for a proposal.
type Vote struct {
	// proposal is the unique ID of the proposal.
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
	// voter is the account address of the voter.
	Voter string `protobuf:"bytes,2,opt,name=voter,proto3" json:"voter,omitempty"`
	// option is the voter's choice on the proposal.
	Option VoteOption `protobuf:"varint,3,opt,name=option,proto3,enum=lbm.foundation.v1.VoteOption" json:"option,omitempty"`
	// metadata is any arbitrary metadata to attached to the vote.
	Metadata string `protobuf:"bytes,4,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// submit_time is the timestamp when the vote was submitted.
	SubmitTime time.Time `protobuf:"bytes,5,opt,name=submit_time,json=submitTime,proto3,stdtime" json:"submit_time"`
}

func (m *Vote) Reset()         { *m = Vote{} }
func (m *Vote) String() string { return proto.CompactTextString(m) }
func (*Vote) ProtoMessage()    {}
func (*Vote) Descriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{11}
}
func (m *Vote) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Vote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Vote.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 *Vote) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Vote.Merge(m, src)
}
func (m *Vote) XXX_Size() int {
	return m.Size()
}
func (m *Vote) XXX_DiscardUnknown() {
	xxx_messageInfo_Vote.DiscardUnknown(m)
}

var xxx_messageInfo_Vote proto.InternalMessageInfo

func (m *Vote) GetProposalId() uint64 {
	if m != nil {
		return m.ProposalId
	}
	return 0
}

func (m *Vote) GetVoter() string {
	if m != nil {
		return m.Voter
	}
	return ""
}

func (m *Vote) GetOption() VoteOption {
	if m != nil {
		return m.Option
	}
	return VOTE_OPTION_UNSPECIFIED
}

func (m *Vote) GetMetadata() string {
	if m != nil {
		return m.Metadata
	}
	return ""
}

func (m *Vote) GetSubmitTime() time.Time {
	if m != nil {
		return m.SubmitTime
	}
	return time.Time{}
}

// Pool is used for tracking treasury.
type Pool struct {
	Treasury github_com_Finschia_finschia_sdk_types.DecCoins `protobuf:"bytes,1,rep,name=treasury,proto3,castrepeated=github.com/Finschia/finschia-sdk/types.DecCoins" json:"treasury"`
}

func (m *Pool) Reset()         { *m = Pool{} }
func (m *Pool) String() string { return proto.CompactTextString(m) }
func (*Pool) ProtoMessage()    {}
func (*Pool) Descriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{12}
}
func (m *Pool) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Pool) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Pool.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 *Pool) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Pool.Merge(m, src)
}
func (m *Pool) XXX_Size() int {
	return m.Size()
}
func (m *Pool) XXX_DiscardUnknown() {
	xxx_messageInfo_Pool.DiscardUnknown(m)
}

var xxx_messageInfo_Pool proto.InternalMessageInfo

func (m *Pool) GetTreasury() github_com_Finschia_finschia_sdk_types.DecCoins {
	if m != nil {
		return m.Treasury
	}
	return nil
}

// FoundationExecProposal is x/gov proposal to trigger the x/foundation messages on behalf of x/gov.
type FoundationExecProposal struct {
	Title       string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	// x/foundation messages to execute
	// all the signers must be x/gov authority.
	Messages []*types.Any `protobuf:"bytes,3,rep,name=messages,proto3" json:"messages,omitempty"`
}

func (m *FoundationExecProposal) Reset()         { *m = FoundationExecProposal{} }
func (m *FoundationExecProposal) String() string { return proto.CompactTextString(m) }
func (*FoundationExecProposal) ProtoMessage()    {}
func (*FoundationExecProposal) Descriptor() ([]byte, []int) {
	return fileDescriptor_1980496a233f02f4, []int{13}
}
func (m *FoundationExecProposal) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FoundationExecProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FoundationExecProposal.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 *FoundationExecProposal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FoundationExecProposal.Merge(m, src)
}
func (m *FoundationExecProposal) XXX_Size() int {
	return m.Size()
}
func (m *FoundationExecProposal) XXX_DiscardUnknown() {
	xxx_messageInfo_FoundationExecProposal.DiscardUnknown(m)
}

var xxx_messageInfo_FoundationExecProposal proto.InternalMessageInfo

func (m *FoundationExecProposal) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *FoundationExecProposal) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *FoundationExecProposal) GetMessages() []*types.Any {
	if m != nil {
		return m.Messages
	}
	return nil
}

func init() {
	proto.RegisterEnum("lbm.foundation.v1.CensorshipAuthority", CensorshipAuthority_name, CensorshipAuthority_value)
	proto.RegisterEnum("lbm.foundation.v1.VoteOption", VoteOption_name, VoteOption_value)
	proto.RegisterEnum("lbm.foundation.v1.ProposalStatus", ProposalStatus_name, ProposalStatus_value)
	proto.RegisterEnum("lbm.foundation.v1.ProposalExecutorResult", ProposalExecutorResult_name, ProposalExecutorResult_value)
	proto.RegisterType((*Params)(nil), "lbm.foundation.v1.Params")
	proto.RegisterType((*Censorship)(nil), "lbm.foundation.v1.Censorship")
	proto.RegisterType((*Member)(nil), "lbm.foundation.v1.Member")
	proto.RegisterType((*MemberRequest)(nil), "lbm.foundation.v1.MemberRequest")
	proto.RegisterType((*ThresholdDecisionPolicy)(nil), "lbm.foundation.v1.ThresholdDecisionPolicy")
	proto.RegisterType((*PercentageDecisionPolicy)(nil), "lbm.foundation.v1.PercentageDecisionPolicy")
	proto.RegisterType((*DecisionPolicyWindows)(nil), "lbm.foundation.v1.DecisionPolicyWindows")
	proto.RegisterType((*OutsourcingDecisionPolicy)(nil), "lbm.foundation.v1.OutsourcingDecisionPolicy")
	proto.RegisterType((*FoundationInfo)(nil), "lbm.foundation.v1.FoundationInfo")
	proto.RegisterType((*Proposal)(nil), "lbm.foundation.v1.Proposal")
	proto.RegisterType((*TallyResult)(nil), "lbm.foundation.v1.TallyResult")
	proto.RegisterType((*Vote)(nil), "lbm.foundation.v1.Vote")
	proto.RegisterType((*Pool)(nil), "lbm.foundation.v1.Pool")
	proto.RegisterType((*FoundationExecProposal)(nil), "lbm.foundation.v1.FoundationExecProposal")
}

func init() {
	proto.RegisterFile("lbm/foundation/v1/foundation.proto", fileDescriptor_1980496a233f02f4)
}

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

func (this *Params) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Params)
	if !ok {
		that2, ok := that.(Params)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.FoundationTax.Equal(that1.FoundationTax) {
		return false
	}
	return true
}
func (this *Censorship) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Censorship)
	if !ok {
		that2, ok := that.(Censorship)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.MsgTypeUrl != that1.MsgTypeUrl {
		return false
	}
	if this.Authority != that1.Authority {
		return false
	}
	return true
}
func (this *Member) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Member)
	if !ok {
		that2, ok := that.(Member)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Address != that1.Address {
		return false
	}
	if this.Metadata != that1.Metadata {
		return false
	}
	if !this.AddedAt.Equal(that1.AddedAt) {
		return false
	}
	return true
}
func (this *MemberRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MemberRequest)
	if !ok {
		that2, ok := that.(MemberRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Address != that1.Address {
		return false
	}
	if this.Remove != that1.Remove {
		return false
	}
	if this.Metadata != that1.Metadata {
		return false
	}
	return true
}
func (this *ThresholdDecisionPolicy) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ThresholdDecisionPolicy)
	if !ok {
		that2, ok := that.(ThresholdDecisionPolicy)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Threshold.Equal(that1.Threshold) {
		return false
	}
	if !this.Windows.Equal(that1.Windows) {
		return false
	}
	return true
}
func (this *PercentageDecisionPolicy) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PercentageDecisionPolicy)
	if !ok {
		that2, ok := that.(PercentageDecisionPolicy)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Percentage.Equal(that1.Percentage) {
		return false
	}
	if !this.Windows.Equal(that1.Windows) {
		return false
	}
	return true
}
func (this *DecisionPolicyWindows) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DecisionPolicyWindows)
	if !ok {
		that2, ok := that.(DecisionPolicyWindows)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.VotingPeriod != that1.VotingPeriod {
		return false
	}
	if this.MinExecutionPeriod != that1.MinExecutionPeriod {
		return false
	}
	return true
}
func (this *OutsourcingDecisionPolicy) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OutsourcingDecisionPolicy)
	if !ok {
		that2, ok := that.(OutsourcingDecisionPolicy)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Description != that1.Description {
		return false
	}
	return true
}
func (this *FoundationInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*FoundationInfo)
	if !ok {
		that2, ok := that.(FoundationInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Version != that1.Version {
		return false
	}
	if !this.TotalWeight.Equal(that1.TotalWeight) {
		return false
	}
	if !this.DecisionPolicy.Equal(that1.DecisionPolicy) {
		return false
	}
	return true
}
func (this *Proposal) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Proposal)
	if !ok {
		that2, ok := that.(Proposal)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if this.Metadata != that1.Metadata {
		return false
	}
	if len(this.Proposers) != len(that1.Proposers) {
		return false
	}
	for i := range this.Proposers {
		if this.Proposers[i] != that1.Proposers[i] {
			return false
		}
	}
	if !this.SubmitTime.Equal(that1.SubmitTime) {
		return false
	}
	if this.FoundationVersion != that1.FoundationVersion {
		return false
	}
	if this.Status != that1.Status {
		return false
	}
	if !this.FinalTallyResult.Equal(&that1.FinalTallyResult) {
		return false
	}
	if !this.VotingPeriodEnd.Equal(that1.VotingPeriodEnd) {
		return false
	}
	if this.ExecutorResult != that1.ExecutorResult {
		return false
	}
	if len(this.Messages) != len(that1.Messages) {
		return false
	}
	for i := range this.Messages {
		if !this.Messages[i].Equal(that1.Messages[i]) {
			return false
		}
	}
	return true
}
func (this *TallyResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TallyResult)
	if !ok {
		that2, ok := that.(TallyResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.YesCount.Equal(that1.YesCount) {
		return false
	}
	if !this.AbstainCount.Equal(that1.AbstainCount) {
		return false
	}
	if !this.NoCount.Equal(that1.NoCount) {
		return false
	}
	if !this.NoWithVetoCount.Equal(that1.NoWithVetoCount) {
		return false
	}
	return true
}
func (this *Vote) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Vote)
	if !ok {
		that2, ok := that.(Vote)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ProposalId != that1.ProposalId {
		return false
	}
	if this.Voter != that1.Voter {
		return false
	}
	if this.Option != that1.Option {
		return false
	}
	if this.Metadata != that1.Metadata {
		return false
	}
	if !this.SubmitTime.Equal(that1.SubmitTime) {
		return false
	}
	return true
}
func (this *Pool) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Pool)
	if !ok {
		that2, ok := that.(Pool)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Treasury) != len(that1.Treasury) {
		return false
	}
	for i := range this.Treasury {
		if !this.Treasury[i].Equal(&that1.Treasury[i]) {
			return false
		}
	}
	return true
}
func (this *FoundationExecProposal) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*FoundationExecProposal)
	if !ok {
		that2, ok := that.(FoundationExecProposal)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Title != that1.Title {
		return false
	}
	if this.Description != that1.Description {
		return false
	}
	if len(this.Messages) != len(that1.Messages) {
		return false
	}
	for i := range this.Messages {
		if !this.Messages[i].Equal(that1.Messages[i]) {
			return false
		}
	}
	return true
}
func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *Censorship) 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 *Censorship) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *Member) 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 *Member) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Member) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.AddedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.AddedAt):])
	if err1 != nil {
		return 0, err1
	}
	i -= n1
	i = encodeVarintFoundation(dAtA, i, uint64(n1))
	i--
	dAtA[i] = 0x22
	if len(m.Metadata) > 0 {
		i -= len(m.Metadata)
		copy(dAtA[i:], m.Metadata)
		i = encodeVarintFoundation(dAtA, i, uint64(len(m.Metadata)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintFoundation(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MemberRequest) 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 *MemberRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MemberRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Metadata) > 0 {
		i -= len(m.Metadata)
		copy(dAtA[i:], m.Metadata)
		i = encodeVarintFoundation(dAtA, i, uint64(len(m.Metadata)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Remove {
		i--
		if m.Remove {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintFoundation(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ThresholdDecisionPolicy) 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 *ThresholdDecisionPolicy) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ThresholdDecisionPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Windows != nil {
		{
			size, err := m.Windows.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFoundation(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.Threshold.Size()
		i -= size
		if _, err := m.Threshold.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintFoundation(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *PercentageDecisionPolicy) 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 *PercentageDecisionPolicy) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PercentageDecisionPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Windows != nil {
		{
			size, err := m.Windows.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFoundation(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.Percentage.Size()
		i -= size
		if _, err := m.Percentage.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintFoundation(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *DecisionPolicyWindows) 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 *DecisionPolicyWindows) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DecisionPolicyWindows) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n4, err4 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MinExecutionPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MinExecutionPeriod):])
	if err4 != nil {
		return 0, err4
	}
	i -= n4
	i = encodeVarintFoundation(dAtA, i, uint64(n4))
	i--
	dAtA[i] = 0x12
	n5, err5 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.VotingPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.VotingPeriod):])
	if err5 != nil {
		return 0, err5
	}
	i -= n5
	i = encodeVarintFoundation(dAtA, i, uint64(n5))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *OutsourcingDecisionPolicy) 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 *OutsourcingDecisionPolicy) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *FoundationInfo) 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 *FoundationInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FoundationInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DecisionPolicy != nil {
		{
			size, err := m.DecisionPolicy.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFoundation(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.TotalWeight.Size()
		i -= size
		if _, err := m.TotalWeight.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintFoundation(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Version != 0 {
		i = encodeVarintFoundation(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Proposal) 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 *Proposal) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Messages) > 0 {
		for iNdEx := len(m.Messages) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Messages[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintFoundation(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if m.ExecutorResult != 0 {
		i = encodeVarintFoundation(dAtA, i, uint64(m.ExecutorResult))
		i--
		dAtA[i] = 0x48
	}
	n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.VotingPeriodEnd, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.VotingPeriodEnd):])
	if err7 != nil {
		return 0, err7
	}
	i -= n7
	i = encodeVarintFoundation(dAtA, i, uint64(n7))
	i--
	dAtA[i] = 0x42
	{
		size, err := m.FinalTallyResult.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintFoundation(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	if m.Status != 0 {
		i = encodeVarintFoundation(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x30
	}
	if m.FoundationVersion != 0 {
		i = encodeVarintFoundation(dAtA, i, uint64(m.FoundationVersion))
		i--
		dAtA[i] = 0x28
	}
	n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.SubmitTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.SubmitTime):])
	if err9 != nil {
		return 0, err9
	}
	i -= n9
	i = encodeVarintFoundation(dAtA, i, uint64(n9))
	i--
	dAtA[i] = 0x22
	if len(m.Proposers) > 0 {
		for iNdEx := len(m.Proposers) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Proposers[iNdEx])
			copy(dAtA[i:], m.Proposers[iNdEx])
			i = encodeVarintFoundation(dAtA, i, uint64(len(m.Proposers[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Metadata) > 0 {
		i -= len(m.Metadata)
		copy(dAtA[i:], m.Metadata)
		i = encodeVarintFoundation(dAtA, i, uint64(len(m.Metadata)))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = encodeVarintFoundation(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TallyResult) 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 *TallyResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TallyResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.NoWithVetoCount.Size()
		i -= size
		if _, err := m.NoWithVetoCount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintFoundation(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.NoCount.Size()
		i -= size
		if _, err := m.NoCount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintFoundation(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.AbstainCount.Size()
		i -= size
		if _, err := m.AbstainCount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintFoundation(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.YesCount.Size()
		i -= size
		if _, err := m.YesCount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintFoundation(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *Vote) 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 *Vote) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Vote) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.SubmitTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.SubmitTime):])
	if err10 != nil {
		return 0, err10
	}
	i -= n10
	i = encodeVarintFoundation(dAtA, i, uint64(n10))
	i--
	dAtA[i] = 0x2a
	if len(m.Metadata) > 0 {
		i -= len(m.Metadata)
		copy(dAtA[i:], m.Metadata)
		i = encodeVarintFoundation(dAtA, i, uint64(len(m.Metadata)))
		i--
		dAtA[i] = 0x22
	}
	if m.Option != 0 {
		i = encodeVarintFoundation(dAtA, i, uint64(m.Option))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Voter) > 0 {
		i -= len(m.Voter)
		copy(dAtA[i:], m.Voter)
		i = encodeVarintFoundation(dAtA, i, uint64(len(m.Voter)))
		i--
		dAtA[i] = 0x12
	}
	if m.ProposalId != 0 {
		i = encodeVarintFoundation(dAtA, i, uint64(m.ProposalId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Pool) 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 *Pool) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *FoundationExecProposal) 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 *FoundationExecProposal) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FoundationExecProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Messages) > 0 {
		for iNdEx := len(m.Messages) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Messages[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintFoundation(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintFoundation(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Title) > 0 {
		i -= len(m.Title)
		copy(dAtA[i:], m.Title)
		i = encodeVarintFoundation(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Censorship) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MsgTypeUrl)
	if l > 0 {
		n += 1 + l + sovFoundation(uint64(l))
	}
	if m.Authority != 0 {
		n += 1 + sovFoundation(uint64(m.Authority))
	}
	return n
}

func (m *Member) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovFoundation(uint64(l))
	}
	l = len(m.Metadata)
	if l > 0 {
		n += 1 + l + sovFoundation(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.AddedAt)
	n += 1 + l + sovFoundation(uint64(l))
	return n
}

func (m *MemberRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovFoundation(uint64(l))
	}
	if m.Remove {
		n += 2
	}
	l = len(m.Metadata)
	if l > 0 {
		n += 1 + l + sovFoundation(uint64(l))
	}
	return n
}

func (m *ThresholdDecisionPolicy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Threshold.Size()
	n += 1 + l + sovFoundation(uint64(l))
	if m.Windows != nil {
		l = m.Windows.Size()
		n += 1 + l + sovFoundation(uint64(l))
	}
	return n
}

func (m *PercentageDecisionPolicy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Percentage.Size()
	n += 1 + l + sovFoundation(uint64(l))
	if m.Windows != nil {
		l = m.Windows.Size()
		n += 1 + l + sovFoundation(uint64(l))
	}
	return n
}

func (m *DecisionPolicyWindows) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.VotingPeriod)
	n += 1 + l + sovFoundation(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.MinExecutionPeriod)
	n += 1 + l + sovFoundation(uint64(l))
	return n
}

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

func (m *FoundationInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Version != 0 {
		n += 1 + sovFoundation(uint64(m.Version))
	}
	l = m.TotalWeight.Size()
	n += 1 + l + sovFoundation(uint64(l))
	if m.DecisionPolicy != nil {
		l = m.DecisionPolicy.Size()
		n += 1 + l + sovFoundation(uint64(l))
	}
	return n
}

func (m *Proposal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovFoundation(uint64(m.Id))
	}
	l = len(m.Metadata)
	if l > 0 {
		n += 1 + l + sovFoundation(uint64(l))
	}
	if len(m.Proposers) > 0 {
		for _, s := range m.Proposers {
			l = len(s)
			n += 1 + l + sovFoundation(uint64(l))
		}
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.SubmitTime)
	n += 1 + l + sovFoundation(uint64(l))
	if m.FoundationVersion != 0 {
		n += 1 + sovFoundation(uint64(m.FoundationVersion))
	}
	if m.Status != 0 {
		n += 1 + sovFoundation(uint64(m.Status))
	}
	l = m.FinalTallyResult.Size()
	n += 1 + l + sovFoundation(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.VotingPeriodEnd)
	n += 1 + l + sovFoundation(uint64(l))
	if m.ExecutorResult != 0 {
		n += 1 + sovFoundation(uint64(m.ExecutorResult))
	}
	if len(m.Messages) > 0 {
		for _, e := range m.Messages {
			l = e.Size()
			n += 1 + l + sovFoundation(uint64(l))
		}
	}
	return n
}

func (m *TallyResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.YesCount.Size()
	n += 1 + l + sovFoundation(uint64(l))
	l = m.AbstainCount.Size()
	n += 1 + l + sovFoundation(uint64(l))
	l = m.NoCount.Size()
	n += 1 + l + sovFoundation(uint64(l))
	l = m.NoWithVetoCount.Size()
	n += 1 + l + sovFoundation(uint64(l))
	return n
}

func (m *Vote) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProposalId != 0 {
		n += 1 + sovFoundation(uint64(m.ProposalId))
	}
	l = len(m.Voter)
	if l > 0 {
		n += 1 + l + sovFoundation(uint64(l))
	}
	if m.Option != 0 {
		n += 1 + sovFoundation(uint64(m.Option))
	}
	l = len(m.Metadata)
	if l > 0 {
		n += 1 + l + sovFoundation(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.SubmitTime)
	n += 1 + l + sovFoundation(uint64(l))
	return n
}

func (m *Pool) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Treasury) > 0 {
		for _, e := range m.Treasury {
			l = e.Size()
			n += 1 + l + sovFoundation(uint64(l))
		}
	}
	return n
}

func (m *FoundationExecProposal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovFoundation(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovFoundation(uint64(l))
	}
	if len(m.Messages) > 0 {
		for _, e := range m.Messages {
			l = e.Size()
			n += 1 + l + sovFoundation(uint64(l))
		}
	}
	return n
}

func sovFoundation(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozFoundation(x uint64) (n int) {
	return sovFoundation(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Params) 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 ErrIntOverflowFoundation
			}
			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: Params: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FoundationTax", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.FoundationTax.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoundation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFoundation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Censorship) 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 ErrIntOverflowFoundation
			}
			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: Censorship: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Censorship: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgTypeUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MsgTypeUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
			}
			m.Authority = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Authority |= CensorshipAuthority(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipFoundation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFoundation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Member) 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 ErrIntOverflowFoundation
			}
			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: Member: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Member: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metadata = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.AddedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoundation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFoundation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MemberRequest) 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 ErrIntOverflowFoundation
			}
			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: MemberRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MemberRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Remove", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Remove = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metadata = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoundation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFoundation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ThresholdDecisionPolicy) 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 ErrIntOverflowFoundation
			}
			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: ThresholdDecisionPolicy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ThresholdDecisionPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Threshold", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Threshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Windows", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Windows == nil {
				m.Windows = &DecisionPolicyWindows{}
			}
			if err := m.Windows.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoundation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFoundation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PercentageDecisionPolicy) 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 ErrIntOverflowFoundation
			}
			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: PercentageDecisionPolicy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PercentageDecisionPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Percentage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Windows", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Windows == nil {
				m.Windows = &DecisionPolicyWindows{}
			}
			if err := m.Windows.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoundation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFoundation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DecisionPolicyWindows) 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 ErrIntOverflowFoundation
			}
			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: DecisionPolicyWindows: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DecisionPolicyWindows: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotingPeriod", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.VotingPeriod, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinExecutionPeriod", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.MinExecutionPeriod, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoundation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFoundation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutsourcingDecisionPolicy) 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 ErrIntOverflowFoundation
			}
			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: OutsourcingDecisionPolicy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutsourcingDecisionPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoundation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFoundation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FoundationInfo) 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 ErrIntOverflowFoundation
			}
			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: FoundationInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FoundationInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalWeight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TotalWeight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DecisionPolicy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DecisionPolicy == nil {
				m.DecisionPolicy = &types.Any{}
			}
			if err := m.DecisionPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoundation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFoundation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Proposal) 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 ErrIntOverflowFoundation
			}
			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: Proposal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Proposal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metadata = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proposers", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Proposers = append(m.Proposers, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubmitTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.SubmitTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FoundationVersion", wireType)
			}
			m.FoundationVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FoundationVersion |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= ProposalStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FinalTallyResult", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.FinalTallyResult.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotingPeriodEnd", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.VotingPeriodEnd, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecutorResult", wireType)
			}
			m.ExecutorResult = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExecutorResult |= ProposalExecutorResult(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Messages", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Messages = append(m.Messages, &types.Any{})
			if err := m.Messages[len(m.Messages)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoundation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFoundation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TallyResult) 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 ErrIntOverflowFoundation
			}
			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: TallyResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TallyResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field YesCount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.YesCount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AbstainCount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.AbstainCount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoCount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NoCount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoWithVetoCount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NoWithVetoCount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoundation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFoundation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Vote) 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 ErrIntOverflowFoundation
			}
			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: Vote: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Vote: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType)
			}
			m.ProposalId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProposalId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Voter", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Voter = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Option", wireType)
			}
			m.Option = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Option |= VoteOption(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metadata = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubmitTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.SubmitTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoundation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFoundation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Pool) 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 ErrIntOverflowFoundation
			}
			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: Pool: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Pool: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Treasury", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Treasury = append(m.Treasury, types1.DecCoin{})
			if err := m.Treasury[len(m.Treasury)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoundation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFoundation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FoundationExecProposal) 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 ErrIntOverflowFoundation
			}
			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: FoundationExecProposal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FoundationExecProposal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				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 ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Messages", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoundation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoundation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFoundation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Messages = append(m.Messages, &types.Any{})
			if err := m.Messages[len(m.Messages)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoundation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFoundation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipFoundation(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, ErrIntOverflowFoundation
			}
			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, ErrIntOverflowFoundation
				}
				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, ErrIntOverflowFoundation
				}
				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, ErrInvalidLengthFoundation
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupFoundation
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthFoundation
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthFoundation        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowFoundation          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupFoundation = fmt.Errorf("proto: unexpected end of group")
)