Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

types

package

Go to main page

Versions in this module

v0

v0.8.5

Dec 2, 2021

v0.8.4

Oct 29, 2021

v0.8.3

Oct 26, 2021

v0.8.2

Oct 25, 2021

Changes in this version

+ type Link__LotusActorV6Head = *_Link__LotusActorV6Head

+ func (Link__LotusActorV6Head) AsBool() (bool, error)

+ func (Link__LotusActorV6Head) AsBytes() ([]byte, error)

+ func (Link__LotusActorV6Head) AsFloat() (float64, error)

+ func (Link__LotusActorV6Head) AsInt() (int64, error)

+ func (Link__LotusActorV6Head) AsString() (string, error)

+ func (Link__LotusActorV6Head) IsAbsent() bool

+ func (Link__LotusActorV6Head) IsNull() bool

+ func (Link__LotusActorV6Head) Kind() datamodel.Kind

+ func (Link__LotusActorV6Head) Length() int64

+ func (Link__LotusActorV6Head) LinkTargetNodePrototype() datamodel.NodePrototype

+ func (Link__LotusActorV6Head) ListIterator() datamodel.ListIterator

+ func (Link__LotusActorV6Head) LookupByIndex(idx int64) (datamodel.Node, error)

+ func (Link__LotusActorV6Head) LookupByNode(datamodel.Node) (datamodel.Node, error)

+ func (Link__LotusActorV6Head) LookupBySegment(seg datamodel.PathSegment) (datamodel.Node, error)

+ func (Link__LotusActorV6Head) LookupByString(string) (datamodel.Node, error)

+ func (Link__LotusActorV6Head) MapIterator() datamodel.MapIterator

+ func (Link__LotusActorV6Head) Prototype() datamodel.NodePrototype

+ func (Link__LotusActorV6Head) Type() schema.Type

+ func (n Link__LotusActorV6Head) AsLink() (datamodel.Link, error)

+ func (n Link__LotusActorV6Head) Link() datamodel.Link

+ func (n Link__LotusActorV6Head) Representation() datamodel.Node

+ type LotusActorV6Head = *_LotusActorV6Head

+ func (LotusActorV6Head) AsBool() (bool, error)

+ func (LotusActorV6Head) AsBytes() ([]byte, error)

+ func (LotusActorV6Head) AsFloat() (float64, error)

+ func (LotusActorV6Head) AsInt() (int64, error)

+ func (LotusActorV6Head) AsLink() (datamodel.Link, error)

+ func (LotusActorV6Head) AsString() (string, error)

+ func (LotusActorV6Head) IsAbsent() bool

+ func (LotusActorV6Head) IsNull() bool

+ func (LotusActorV6Head) Kind() datamodel.Kind

+ func (LotusActorV6Head) Length() int64

+ func (LotusActorV6Head) ListIterator() datamodel.ListIterator

+ func (LotusActorV6Head) LookupByIndex(idx int64) (datamodel.Node, error)

+ func (LotusActorV6Head) Prototype() datamodel.NodePrototype

+ func (LotusActorV6Head) Type() schema.Type

+ func (n LotusActorV6Head) LookupByNode(key datamodel.Node) (datamodel.Node, error)

+ func (n LotusActorV6Head) LookupBySegment(seg datamodel.PathSegment) (datamodel.Node, error)

+ func (n LotusActorV6Head) LookupByString(key string) (datamodel.Node, error)

+ func (n LotusActorV6Head) MapIterator() datamodel.MapIterator

+ func (n LotusActorV6Head) Representation() datamodel.Node

+ type MaybeLink__LotusActorV6Head = *_Link__LotusActorV6Head__Maybe

+ func (m MaybeLink__LotusActorV6Head) AsNode() datamodel.Node

+ func (m MaybeLink__LotusActorV6Head) Exists() bool

+ func (m MaybeLink__LotusActorV6Head) IsAbsent() bool

+ func (m MaybeLink__LotusActorV6Head) IsNull() bool

+ func (m MaybeLink__LotusActorV6Head) Must() Link__LotusActorV6Head

+ type MaybeLotusActorV6Head = *_LotusActorV6Head__Maybe

+ func (m MaybeLotusActorV6Head) AsNode() datamodel.Node

+ func (m MaybeLotusActorV6Head) Exists() bool

+ func (m MaybeLotusActorV6Head) IsAbsent() bool

+ func (m MaybeLotusActorV6Head) IsNull() bool

+ func (m MaybeLotusActorV6Head) Must() LotusActorV6Head

v0.8.1

Sep 23, 2021

v0.8.0

Aug 31, 2021

Changes in this version

+ var Type typeSlab

+ type AccountV0State = *_AccountV0State

+ func (AccountV0State) AsBool() (bool, error)

+ func (AccountV0State) AsBytes() ([]byte, error)

+ func (AccountV0State) AsFloat() (float64, error)

+ func (AccountV0State) AsInt() (int64, error)

+ func (AccountV0State) AsLink() (ipld.Link, error)

+ func (AccountV0State) AsString() (string, error)

+ func (AccountV0State) IsAbsent() bool

+ func (AccountV0State) IsNull() bool

+ func (AccountV0State) Kind() ipld.Kind

+ func (AccountV0State) Length() int64

+ func (AccountV0State) ListIterator() ipld.ListIterator

+ func (AccountV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (AccountV0State) Prototype() ipld.NodePrototype

+ func (AccountV0State) Type() schema.Type

+ func (n AccountV0State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n AccountV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n AccountV0State) LookupByString(key string) (ipld.Node, error)

+ func (n AccountV0State) MapIterator() ipld.MapIterator

+ func (n AccountV0State) Representation() ipld.Node

+ type ActorID = *_ActorID

+ func (ActorID) AsBool() (bool, error)

+ func (ActorID) AsBytes() ([]byte, error)

+ func (ActorID) AsFloat() (float64, error)

+ func (ActorID) AsLink() (ipld.Link, error)

+ func (ActorID) AsString() (string, error)

+ func (ActorID) IsAbsent() bool

+ func (ActorID) IsNull() bool

+ func (ActorID) Kind() ipld.Kind

+ func (ActorID) Length() int64

+ func (ActorID) ListIterator() ipld.ListIterator

+ func (ActorID) LookupByIndex(idx int64) (ipld.Node, error)

+ func (ActorID) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (ActorID) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (ActorID) LookupByString(string) (ipld.Node, error)

+ func (ActorID) MapIterator() ipld.MapIterator

+ func (ActorID) Prototype() ipld.NodePrototype

+ func (ActorID) Type() schema.Type

+ func (n ActorID) AsInt() (int64, error)

+ func (n ActorID) Int() int64

+ func (n ActorID) Representation() ipld.Node

+ type Address = *_Address

+ func (Address) AsBool() (bool, error)

+ func (Address) AsFloat() (float64, error)

+ func (Address) AsInt() (int64, error)

+ func (Address) AsLink() (ipld.Link, error)

+ func (Address) AsString() (string, error)

+ func (Address) IsAbsent() bool

+ func (Address) IsNull() bool

+ func (Address) Kind() ipld.Kind

+ func (Address) Length() int64

+ func (Address) ListIterator() ipld.ListIterator

+ func (Address) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Address) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Address) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Address) LookupByString(string) (ipld.Node, error)

+ func (Address) MapIterator() ipld.MapIterator

+ func (Address) Prototype() ipld.NodePrototype

+ func (Address) Type() schema.Type

+ func (n Address) AsBytes() ([]byte, error)

+ func (n Address) Bytes() []byte

+ func (n Address) Representation() ipld.Node

+ type Any = *_Any

+ func (Any) AsBool() (bool, error)

+ func (Any) AsBytes() ([]byte, error)

+ func (Any) AsFloat() (float64, error)

+ func (Any) AsInt() (int64, error)

+ func (Any) AsLink() (ipld.Link, error)

+ func (Any) AsString() (string, error)

+ func (Any) IsAbsent() bool

+ func (Any) IsNull() bool

+ func (Any) Kind() ipld.Kind

+ func (Any) Length() int64

+ func (Any) ListIterator() ipld.ListIterator

+ func (Any) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Any) Prototype() ipld.NodePrototype

+ func (Any) Type() schema.Type

+ func (n Any) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n Any) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Any) LookupByString(key string) (ipld.Node, error)

+ func (n Any) MapIterator() ipld.MapIterator

+ func (n Any) Representation() ipld.Node

+ type ApplyRewardParams = *_ApplyRewardParams

+ func (ApplyRewardParams) AsBool() (bool, error)

+ func (ApplyRewardParams) AsBytes() ([]byte, error)

+ func (ApplyRewardParams) AsFloat() (float64, error)

+ func (ApplyRewardParams) AsInt() (int64, error)

+ func (ApplyRewardParams) AsLink() (ipld.Link, error)

+ func (ApplyRewardParams) AsString() (string, error)

+ func (ApplyRewardParams) IsAbsent() bool

+ func (ApplyRewardParams) IsNull() bool

+ func (ApplyRewardParams) Kind() ipld.Kind

+ func (ApplyRewardParams) Length() int64

+ func (ApplyRewardParams) ListIterator() ipld.ListIterator

+ func (ApplyRewardParams) LookupByIndex(idx int64) (ipld.Node, error)

+ func (ApplyRewardParams) Prototype() ipld.NodePrototype

+ func (ApplyRewardParams) Type() schema.Type

+ func (n ApplyRewardParams) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n ApplyRewardParams) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n ApplyRewardParams) LookupByString(key string) (ipld.Node, error)

+ func (n ApplyRewardParams) MapIterator() ipld.MapIterator

+ func (n ApplyRewardParams) Representation() ipld.Node

+ type BigInt = *_BigInt

+ func (BigInt) AsBool() (bool, error)

+ func (BigInt) AsFloat() (float64, error)

+ func (BigInt) AsInt() (int64, error)

+ func (BigInt) AsLink() (ipld.Link, error)

+ func (BigInt) AsString() (string, error)

+ func (BigInt) IsAbsent() bool

+ func (BigInt) IsNull() bool

+ func (BigInt) Kind() ipld.Kind

+ func (BigInt) Length() int64

+ func (BigInt) ListIterator() ipld.ListIterator

+ func (BigInt) LookupByIndex(idx int64) (ipld.Node, error)

+ func (BigInt) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (BigInt) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (BigInt) LookupByString(string) (ipld.Node, error)

+ func (BigInt) MapIterator() ipld.MapIterator

+ func (BigInt) Prototype() ipld.NodePrototype

+ func (BigInt) Type() schema.Type

+ func (n BigInt) AsBytes() ([]byte, error)

+ func (n BigInt) Bytes() []byte

+ func (n BigInt) Representation() ipld.Node

+ type BitField = *_BitField

+ func (BitField) AsBool() (bool, error)

+ func (BitField) AsFloat() (float64, error)

+ func (BitField) AsInt() (int64, error)

+ func (BitField) AsLink() (ipld.Link, error)

+ func (BitField) AsString() (string, error)

+ func (BitField) IsAbsent() bool

+ func (BitField) IsNull() bool

+ func (BitField) Kind() ipld.Kind

+ func (BitField) Length() int64

+ func (BitField) ListIterator() ipld.ListIterator

+ func (BitField) LookupByIndex(idx int64) (ipld.Node, error)

+ func (BitField) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (BitField) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (BitField) LookupByString(string) (ipld.Node, error)

+ func (BitField) MapIterator() ipld.MapIterator

+ func (BitField) Prototype() ipld.NodePrototype

+ func (BitField) Type() schema.Type

+ func (n BitField) AsBytes() ([]byte, error)

+ func (n BitField) Bytes() []byte

+ func (n BitField) Representation() ipld.Node

+ type Bool = *_Bool

+ func (Bool) AsBytes() ([]byte, error)

+ func (Bool) AsFloat() (float64, error)

+ func (Bool) AsInt() (int64, error)

+ func (Bool) AsLink() (ipld.Link, error)

+ func (Bool) AsString() (string, error)

+ func (Bool) IsAbsent() bool

+ func (Bool) IsNull() bool

+ func (Bool) Kind() ipld.Kind

+ func (Bool) Length() int64

+ func (Bool) ListIterator() ipld.ListIterator

+ func (Bool) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Bool) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Bool) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Bool) LookupByString(string) (ipld.Node, error)

+ func (Bool) MapIterator() ipld.MapIterator

+ func (Bool) Prototype() ipld.NodePrototype

+ func (Bool) Type() schema.Type

+ func (n Bool) AsBool() (bool, error)

+ func (n Bool) Bool() bool

+ func (n Bool) Representation() ipld.Node

+ type Bytes = *_Bytes

+ func (Bytes) AsBool() (bool, error)

+ func (Bytes) AsFloat() (float64, error)

+ func (Bytes) AsInt() (int64, error)

+ func (Bytes) AsLink() (ipld.Link, error)

+ func (Bytes) AsString() (string, error)

+ func (Bytes) IsAbsent() bool

+ func (Bytes) IsNull() bool

+ func (Bytes) Kind() ipld.Kind

+ func (Bytes) Length() int64

+ func (Bytes) ListIterator() ipld.ListIterator

+ func (Bytes) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Bytes) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Bytes) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Bytes) LookupByString(string) (ipld.Node, error)

+ func (Bytes) MapIterator() ipld.MapIterator

+ func (Bytes) Prototype() ipld.NodePrototype

+ func (Bytes) Type() schema.Type

+ func (n Bytes) AsBytes() ([]byte, error)

+ func (n Bytes) Bytes() []byte

+ func (n Bytes) Representation() ipld.Node

+ type ChainEpoch = *_ChainEpoch

+ func (ChainEpoch) AsBool() (bool, error)

+ func (ChainEpoch) AsBytes() ([]byte, error)

+ func (ChainEpoch) AsFloat() (float64, error)

+ func (ChainEpoch) AsLink() (ipld.Link, error)

+ func (ChainEpoch) AsString() (string, error)

+ func (ChainEpoch) IsAbsent() bool

+ func (ChainEpoch) IsNull() bool

+ func (ChainEpoch) Kind() ipld.Kind

+ func (ChainEpoch) Length() int64

+ func (ChainEpoch) ListIterator() ipld.ListIterator

+ func (ChainEpoch) LookupByIndex(idx int64) (ipld.Node, error)

+ func (ChainEpoch) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (ChainEpoch) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (ChainEpoch) LookupByString(string) (ipld.Node, error)

+ func (ChainEpoch) MapIterator() ipld.MapIterator

+ func (ChainEpoch) Prototype() ipld.NodePrototype

+ func (ChainEpoch) Type() schema.Type

+ func (n ChainEpoch) AsInt() (int64, error)

+ func (n ChainEpoch) Int() int64

+ func (n ChainEpoch) Representation() ipld.Node

+ type CidString = *_CidString

+ func (CidString) AsBool() (bool, error)

+ func (CidString) AsBytes() ([]byte, error)

+ func (CidString) AsFloat() (float64, error)

+ func (CidString) AsInt() (int64, error)

+ func (CidString) AsLink() (ipld.Link, error)

+ func (CidString) IsAbsent() bool

+ func (CidString) IsNull() bool

+ func (CidString) Kind() ipld.Kind

+ func (CidString) Length() int64

+ func (CidString) ListIterator() ipld.ListIterator

+ func (CidString) LookupByIndex(idx int64) (ipld.Node, error)

+ func (CidString) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (CidString) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (CidString) LookupByString(string) (ipld.Node, error)

+ func (CidString) MapIterator() ipld.MapIterator

+ func (CidString) Prototype() ipld.NodePrototype

+ func (CidString) Type() schema.Type

+ func (n CidString) AsString() (string, error)

+ func (n CidString) Representation() ipld.Node

+ func (n CidString) String() string

+ type CronV0Entry = *_CronV0Entry

+ func (CronV0Entry) AsBool() (bool, error)

+ func (CronV0Entry) AsBytes() ([]byte, error)

+ func (CronV0Entry) AsFloat() (float64, error)

+ func (CronV0Entry) AsInt() (int64, error)

+ func (CronV0Entry) AsLink() (ipld.Link, error)

+ func (CronV0Entry) AsString() (string, error)

+ func (CronV0Entry) IsAbsent() bool

+ func (CronV0Entry) IsNull() bool

+ func (CronV0Entry) Kind() ipld.Kind

+ func (CronV0Entry) Length() int64

+ func (CronV0Entry) ListIterator() ipld.ListIterator

+ func (CronV0Entry) LookupByIndex(idx int64) (ipld.Node, error)

+ func (CronV0Entry) Prototype() ipld.NodePrototype

+ func (CronV0Entry) Type() schema.Type

+ func (n CronV0Entry) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n CronV0Entry) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n CronV0Entry) LookupByString(key string) (ipld.Node, error)

+ func (n CronV0Entry) MapIterator() ipld.MapIterator

+ func (n CronV0Entry) Representation() ipld.Node

+ type CronV0State = *_CronV0State

+ func (CronV0State) AsBool() (bool, error)

+ func (CronV0State) AsBytes() ([]byte, error)

+ func (CronV0State) AsFloat() (float64, error)

+ func (CronV0State) AsInt() (int64, error)

+ func (CronV0State) AsLink() (ipld.Link, error)

+ func (CronV0State) AsString() (string, error)

+ func (CronV0State) IsAbsent() bool

+ func (CronV0State) IsNull() bool

+ func (CronV0State) Kind() ipld.Kind

+ func (CronV0State) Length() int64

+ func (CronV0State) ListIterator() ipld.ListIterator

+ func (CronV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (CronV0State) Prototype() ipld.NodePrototype

+ func (CronV0State) Type() schema.Type

+ func (n CronV0State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n CronV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n CronV0State) LookupByString(key string) (ipld.Node, error)

+ func (n CronV0State) MapIterator() ipld.MapIterator

+ func (n CronV0State) Representation() ipld.Node

+ type DealID = *_DealID

+ func (DealID) AsBool() (bool, error)

+ func (DealID) AsBytes() ([]byte, error)

+ func (DealID) AsFloat() (float64, error)

+ func (DealID) AsLink() (ipld.Link, error)

+ func (DealID) AsString() (string, error)

+ func (DealID) IsAbsent() bool

+ func (DealID) IsNull() bool

+ func (DealID) Kind() ipld.Kind

+ func (DealID) Length() int64

+ func (DealID) ListIterator() ipld.ListIterator

+ func (DealID) LookupByIndex(idx int64) (ipld.Node, error)

+ func (DealID) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (DealID) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (DealID) LookupByString(string) (ipld.Node, error)

+ func (DealID) MapIterator() ipld.MapIterator

+ func (DealID) Prototype() ipld.NodePrototype

+ func (DealID) Type() schema.Type

+ func (n DealID) AsInt() (int64, error)

+ func (n DealID) Int() int64

+ func (n DealID) Representation() ipld.Node

+ type Float = *_Float

+ func (Float) AsBool() (bool, error)

+ func (Float) AsBytes() ([]byte, error)

+ func (Float) AsInt() (int64, error)

+ func (Float) AsLink() (ipld.Link, error)

+ func (Float) AsString() (string, error)

+ func (Float) IsAbsent() bool

+ func (Float) IsNull() bool

+ func (Float) Kind() ipld.Kind

+ func (Float) Length() int64

+ func (Float) ListIterator() ipld.ListIterator

+ func (Float) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Float) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Float) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Float) LookupByString(string) (ipld.Node, error)

+ func (Float) MapIterator() ipld.MapIterator

+ func (Float) Prototype() ipld.NodePrototype

+ func (Float) Type() schema.Type

+ func (n Float) AsFloat() (float64, error)

+ func (n Float) Float() float64

+ func (n Float) Representation() ipld.Node

+ type InitV0State = *_InitV0State

+ func (InitV0State) AsBool() (bool, error)

+ func (InitV0State) AsBytes() ([]byte, error)

+ func (InitV0State) AsFloat() (float64, error)

+ func (InitV0State) AsInt() (int64, error)

+ func (InitV0State) AsLink() (ipld.Link, error)

+ func (InitV0State) AsString() (string, error)

+ func (InitV0State) IsAbsent() bool

+ func (InitV0State) IsNull() bool

+ func (InitV0State) Kind() ipld.Kind

+ func (InitV0State) Length() int64

+ func (InitV0State) ListIterator() ipld.ListIterator

+ func (InitV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (InitV0State) Prototype() ipld.NodePrototype

+ func (InitV0State) Type() schema.Type

+ func (n InitV0State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n InitV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n InitV0State) LookupByString(key string) (ipld.Node, error)

+ func (n InitV0State) MapIterator() ipld.MapIterator

+ func (n InitV0State) Representation() ipld.Node

+ type InitV3State = *_InitV3State

+ func (InitV3State) AsBool() (bool, error)

+ func (InitV3State) AsBytes() ([]byte, error)

+ func (InitV3State) AsFloat() (float64, error)

+ func (InitV3State) AsInt() (int64, error)

+ func (InitV3State) AsLink() (ipld.Link, error)

+ func (InitV3State) AsString() (string, error)

+ func (InitV3State) IsAbsent() bool

+ func (InitV3State) IsNull() bool

+ func (InitV3State) Kind() ipld.Kind

+ func (InitV3State) Length() int64

+ func (InitV3State) ListIterator() ipld.ListIterator

+ func (InitV3State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (InitV3State) Prototype() ipld.NodePrototype

+ func (InitV3State) Type() schema.Type

+ func (n InitV3State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n InitV3State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n InitV3State) LookupByString(key string) (ipld.Node, error)

+ func (n InitV3State) MapIterator() ipld.MapIterator

+ func (n InitV3State) Representation() ipld.Node

+ type Int = *_Int

+ func (Int) AsBool() (bool, error)

+ func (Int) AsBytes() ([]byte, error)

+ func (Int) AsFloat() (float64, error)

+ func (Int) AsLink() (ipld.Link, error)

+ func (Int) AsString() (string, error)

+ func (Int) IsAbsent() bool

+ func (Int) IsNull() bool

+ func (Int) Kind() ipld.Kind

+ func (Int) Length() int64

+ func (Int) ListIterator() ipld.ListIterator

+ func (Int) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Int) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Int) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Int) LookupByString(string) (ipld.Node, error)

+ func (Int) MapIterator() ipld.MapIterator

+ func (Int) Prototype() ipld.NodePrototype

+ func (Int) Type() schema.Type

+ func (n Int) AsInt() (int64, error)

+ func (n Int) Int() int64

+ func (n Int) Representation() ipld.Node

+ type Link = *_Link

+ func (Link) AsBool() (bool, error)

+ func (Link) AsBytes() ([]byte, error)

+ func (Link) AsFloat() (float64, error)

+ func (Link) AsInt() (int64, error)

+ func (Link) AsString() (string, error)

+ func (Link) IsAbsent() bool

+ func (Link) IsNull() bool

+ func (Link) Kind() ipld.Kind

+ func (Link) Length() int64

+ func (Link) ListIterator() ipld.ListIterator

+ func (Link) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link) LookupByString(string) (ipld.Node, error)

+ func (Link) MapIterator() ipld.MapIterator

+ func (Link) Prototype() ipld.NodePrototype

+ func (Link) Type() schema.Type

+ func (n Link) AsLink() (ipld.Link, error)

+ func (n Link) Link() ipld.Link

+ func (n Link) Representation() ipld.Node

+ type Link__AccountV0State = *_Link__AccountV0State

+ func (Link__AccountV0State) AsBool() (bool, error)

+ func (Link__AccountV0State) AsBytes() ([]byte, error)

+ func (Link__AccountV0State) AsFloat() (float64, error)

+ func (Link__AccountV0State) AsInt() (int64, error)

+ func (Link__AccountV0State) AsString() (string, error)

+ func (Link__AccountV0State) IsAbsent() bool

+ func (Link__AccountV0State) IsNull() bool

+ func (Link__AccountV0State) Kind() ipld.Kind

+ func (Link__AccountV0State) Length() int64

+ func (Link__AccountV0State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__AccountV0State) ListIterator() ipld.ListIterator

+ func (Link__AccountV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__AccountV0State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__AccountV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__AccountV0State) LookupByString(string) (ipld.Node, error)

+ func (Link__AccountV0State) MapIterator() ipld.MapIterator

+ func (Link__AccountV0State) Prototype() ipld.NodePrototype

+ func (Link__AccountV0State) Type() schema.Type

+ func (n Link__AccountV0State) AsLink() (ipld.Link, error)

+ func (n Link__AccountV0State) Link() ipld.Link

+ func (n Link__AccountV0State) Representation() ipld.Node

+ type Link__BalanceTable = *_Link__BalanceTable

+ func (Link__BalanceTable) AsBool() (bool, error)

+ func (Link__BalanceTable) AsBytes() ([]byte, error)

+ func (Link__BalanceTable) AsFloat() (float64, error)

+ func (Link__BalanceTable) AsInt() (int64, error)

+ func (Link__BalanceTable) AsString() (string, error)

+ func (Link__BalanceTable) IsAbsent() bool

+ func (Link__BalanceTable) IsNull() bool

+ func (Link__BalanceTable) Kind() ipld.Kind

+ func (Link__BalanceTable) Length() int64

+ func (Link__BalanceTable) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__BalanceTable) ListIterator() ipld.ListIterator

+ func (Link__BalanceTable) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__BalanceTable) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__BalanceTable) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__BalanceTable) LookupByString(string) (ipld.Node, error)

+ func (Link__BalanceTable) MapIterator() ipld.MapIterator

+ func (Link__BalanceTable) Prototype() ipld.NodePrototype

+ func (Link__BalanceTable) Type() schema.Type

+ func (n Link__BalanceTable) AsLink() (ipld.Link, error)

+ func (n Link__BalanceTable) Link() ipld.Link

+ func (n Link__BalanceTable) Representation() ipld.Node

+ type Link__BitField = *_Link__BitField

+ func (Link__BitField) AsBool() (bool, error)

+ func (Link__BitField) AsBytes() ([]byte, error)

+ func (Link__BitField) AsFloat() (float64, error)

+ func (Link__BitField) AsInt() (int64, error)

+ func (Link__BitField) AsString() (string, error)

+ func (Link__BitField) IsAbsent() bool

+ func (Link__BitField) IsNull() bool

+ func (Link__BitField) Kind() ipld.Kind

+ func (Link__BitField) Length() int64

+ func (Link__BitField) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__BitField) ListIterator() ipld.ListIterator

+ func (Link__BitField) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__BitField) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__BitField) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__BitField) LookupByString(string) (ipld.Node, error)

+ func (Link__BitField) MapIterator() ipld.MapIterator

+ func (Link__BitField) Prototype() ipld.NodePrototype

+ func (Link__BitField) Type() schema.Type

+ func (n Link__BitField) AsLink() (ipld.Link, error)

+ func (n Link__BitField) Link() ipld.Link

+ func (n Link__BitField) Representation() ipld.Node

+ type Link__CronV0State = *_Link__CronV0State

+ func (Link__CronV0State) AsBool() (bool, error)

+ func (Link__CronV0State) AsBytes() ([]byte, error)

+ func (Link__CronV0State) AsFloat() (float64, error)

+ func (Link__CronV0State) AsInt() (int64, error)

+ func (Link__CronV0State) AsString() (string, error)

+ func (Link__CronV0State) IsAbsent() bool

+ func (Link__CronV0State) IsNull() bool

+ func (Link__CronV0State) Kind() ipld.Kind

+ func (Link__CronV0State) Length() int64

+ func (Link__CronV0State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__CronV0State) ListIterator() ipld.ListIterator

+ func (Link__CronV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__CronV0State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__CronV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__CronV0State) LookupByString(string) (ipld.Node, error)

+ func (Link__CronV0State) MapIterator() ipld.MapIterator

+ func (Link__CronV0State) Prototype() ipld.NodePrototype

+ func (Link__CronV0State) Type() schema.Type

+ func (n Link__CronV0State) AsLink() (ipld.Link, error)

+ func (n Link__CronV0State) Link() ipld.Link

+ func (n Link__CronV0State) Representation() ipld.Node

+ type Link__DataCap = *_Link__DataCap

+ func (Link__DataCap) AsBool() (bool, error)

+ func (Link__DataCap) AsBytes() ([]byte, error)

+ func (Link__DataCap) AsFloat() (float64, error)

+ func (Link__DataCap) AsInt() (int64, error)

+ func (Link__DataCap) AsString() (string, error)

+ func (Link__DataCap) IsAbsent() bool

+ func (Link__DataCap) IsNull() bool

+ func (Link__DataCap) Kind() ipld.Kind

+ func (Link__DataCap) Length() int64

+ func (Link__DataCap) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__DataCap) ListIterator() ipld.ListIterator

+ func (Link__DataCap) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__DataCap) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__DataCap) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__DataCap) LookupByString(string) (ipld.Node, error)

+ func (Link__DataCap) MapIterator() ipld.MapIterator

+ func (Link__DataCap) Prototype() ipld.NodePrototype

+ func (Link__DataCap) Type() schema.Type

+ func (n Link__DataCap) AsLink() (ipld.Link, error)

+ func (n Link__DataCap) Link() ipld.Link

+ func (n Link__DataCap) Representation() ipld.Node

+ type Link__InitV0State = *_Link__InitV0State

+ func (Link__InitV0State) AsBool() (bool, error)

+ func (Link__InitV0State) AsBytes() ([]byte, error)

+ func (Link__InitV0State) AsFloat() (float64, error)

+ func (Link__InitV0State) AsInt() (int64, error)

+ func (Link__InitV0State) AsString() (string, error)

+ func (Link__InitV0State) IsAbsent() bool

+ func (Link__InitV0State) IsNull() bool

+ func (Link__InitV0State) Kind() ipld.Kind

+ func (Link__InitV0State) Length() int64

+ func (Link__InitV0State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__InitV0State) ListIterator() ipld.ListIterator

+ func (Link__InitV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__InitV0State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__InitV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__InitV0State) LookupByString(string) (ipld.Node, error)

+ func (Link__InitV0State) MapIterator() ipld.MapIterator

+ func (Link__InitV0State) Prototype() ipld.NodePrototype

+ func (Link__InitV0State) Type() schema.Type

+ func (n Link__InitV0State) AsLink() (ipld.Link, error)

+ func (n Link__InitV0State) Link() ipld.Link

+ func (n Link__InitV0State) Representation() ipld.Node

+ type Link__InitV3State = *_Link__InitV3State

+ func (Link__InitV3State) AsBool() (bool, error)

+ func (Link__InitV3State) AsBytes() ([]byte, error)

+ func (Link__InitV3State) AsFloat() (float64, error)

+ func (Link__InitV3State) AsInt() (int64, error)

+ func (Link__InitV3State) AsString() (string, error)

+ func (Link__InitV3State) IsAbsent() bool

+ func (Link__InitV3State) IsNull() bool

+ func (Link__InitV3State) Kind() ipld.Kind

+ func (Link__InitV3State) Length() int64

+ func (Link__InitV3State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__InitV3State) ListIterator() ipld.ListIterator

+ func (Link__InitV3State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__InitV3State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__InitV3State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__InitV3State) LookupByString(string) (ipld.Node, error)

+ func (Link__InitV3State) MapIterator() ipld.MapIterator

+ func (Link__InitV3State) Prototype() ipld.NodePrototype

+ func (Link__InitV3State) Type() schema.Type

+ func (n Link__InitV3State) AsLink() (ipld.Link, error)

+ func (n Link__InitV3State) Link() ipld.Link

+ func (n Link__InitV3State) Representation() ipld.Node

+ type Link__ListLotusMessage = *_Link__ListLotusMessage

+ func (Link__ListLotusMessage) AsBool() (bool, error)

+ func (Link__ListLotusMessage) AsBytes() ([]byte, error)

+ func (Link__ListLotusMessage) AsFloat() (float64, error)

+ func (Link__ListLotusMessage) AsInt() (int64, error)

+ func (Link__ListLotusMessage) AsString() (string, error)

+ func (Link__ListLotusMessage) IsAbsent() bool

+ func (Link__ListLotusMessage) IsNull() bool

+ func (Link__ListLotusMessage) Kind() ipld.Kind

+ func (Link__ListLotusMessage) Length() int64

+ func (Link__ListLotusMessage) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__ListLotusMessage) ListIterator() ipld.ListIterator

+ func (Link__ListLotusMessage) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__ListLotusMessage) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__ListLotusMessage) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__ListLotusMessage) LookupByString(string) (ipld.Node, error)

+ func (Link__ListLotusMessage) MapIterator() ipld.MapIterator

+ func (Link__ListLotusMessage) Prototype() ipld.NodePrototype

+ func (Link__ListLotusMessage) Type() schema.Type

+ func (n Link__ListLotusMessage) AsLink() (ipld.Link, error)

+ func (n Link__ListLotusMessage) Link() ipld.Link

+ func (n Link__ListLotusMessage) Representation() ipld.Node

+ type Link__LotusActorV2Head = *_Link__LotusActorV2Head

+ func (Link__LotusActorV2Head) AsBool() (bool, error)

+ func (Link__LotusActorV2Head) AsBytes() ([]byte, error)

+ func (Link__LotusActorV2Head) AsFloat() (float64, error)

+ func (Link__LotusActorV2Head) AsInt() (int64, error)

+ func (Link__LotusActorV2Head) AsString() (string, error)

+ func (Link__LotusActorV2Head) IsAbsent() bool

+ func (Link__LotusActorV2Head) IsNull() bool

+ func (Link__LotusActorV2Head) Kind() ipld.Kind

+ func (Link__LotusActorV2Head) Length() int64

+ func (Link__LotusActorV2Head) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__LotusActorV2Head) ListIterator() ipld.ListIterator

+ func (Link__LotusActorV2Head) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__LotusActorV2Head) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__LotusActorV2Head) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__LotusActorV2Head) LookupByString(string) (ipld.Node, error)

+ func (Link__LotusActorV2Head) MapIterator() ipld.MapIterator

+ func (Link__LotusActorV2Head) Prototype() ipld.NodePrototype

+ func (Link__LotusActorV2Head) Type() schema.Type

+ func (n Link__LotusActorV2Head) AsLink() (ipld.Link, error)

+ func (n Link__LotusActorV2Head) Link() ipld.Link

+ func (n Link__LotusActorV2Head) Representation() ipld.Node

+ type Link__LotusActorV3Head = *_Link__LotusActorV3Head

+ func (Link__LotusActorV3Head) AsBool() (bool, error)

+ func (Link__LotusActorV3Head) AsBytes() ([]byte, error)

+ func (Link__LotusActorV3Head) AsFloat() (float64, error)

+ func (Link__LotusActorV3Head) AsInt() (int64, error)

+ func (Link__LotusActorV3Head) AsString() (string, error)

+ func (Link__LotusActorV3Head) IsAbsent() bool

+ func (Link__LotusActorV3Head) IsNull() bool

+ func (Link__LotusActorV3Head) Kind() ipld.Kind

+ func (Link__LotusActorV3Head) Length() int64

+ func (Link__LotusActorV3Head) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__LotusActorV3Head) ListIterator() ipld.ListIterator

+ func (Link__LotusActorV3Head) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__LotusActorV3Head) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__LotusActorV3Head) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__LotusActorV3Head) LookupByString(string) (ipld.Node, error)

+ func (Link__LotusActorV3Head) MapIterator() ipld.MapIterator

+ func (Link__LotusActorV3Head) Prototype() ipld.NodePrototype

+ func (Link__LotusActorV3Head) Type() schema.Type

+ func (n Link__LotusActorV3Head) AsLink() (ipld.Link, error)

+ func (n Link__LotusActorV3Head) Link() ipld.Link

+ func (n Link__LotusActorV3Head) Representation() ipld.Node

+ type Link__LotusActorV4Head = *_Link__LotusActorV4Head

+ func (Link__LotusActorV4Head) AsBool() (bool, error)

+ func (Link__LotusActorV4Head) AsBytes() ([]byte, error)

+ func (Link__LotusActorV4Head) AsFloat() (float64, error)

+ func (Link__LotusActorV4Head) AsInt() (int64, error)

+ func (Link__LotusActorV4Head) AsString() (string, error)

+ func (Link__LotusActorV4Head) IsAbsent() bool

+ func (Link__LotusActorV4Head) IsNull() bool

+ func (Link__LotusActorV4Head) Kind() ipld.Kind

+ func (Link__LotusActorV4Head) Length() int64

+ func (Link__LotusActorV4Head) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__LotusActorV4Head) ListIterator() ipld.ListIterator

+ func (Link__LotusActorV4Head) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__LotusActorV4Head) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__LotusActorV4Head) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__LotusActorV4Head) LookupByString(string) (ipld.Node, error)

+ func (Link__LotusActorV4Head) MapIterator() ipld.MapIterator

+ func (Link__LotusActorV4Head) Prototype() ipld.NodePrototype

+ func (Link__LotusActorV4Head) Type() schema.Type

+ func (n Link__LotusActorV4Head) AsLink() (ipld.Link, error)

+ func (n Link__LotusActorV4Head) Link() ipld.Link

+ func (n Link__LotusActorV4Head) Representation() ipld.Node

+ type Link__LotusActorV5Head = *_Link__LotusActorV5Head

+ func (Link__LotusActorV5Head) AsBool() (bool, error)

+ func (Link__LotusActorV5Head) AsBytes() ([]byte, error)

+ func (Link__LotusActorV5Head) AsFloat() (float64, error)

+ func (Link__LotusActorV5Head) AsInt() (int64, error)

+ func (Link__LotusActorV5Head) AsString() (string, error)

+ func (Link__LotusActorV5Head) IsAbsent() bool

+ func (Link__LotusActorV5Head) IsNull() bool

+ func (Link__LotusActorV5Head) Kind() ipld.Kind

+ func (Link__LotusActorV5Head) Length() int64

+ func (Link__LotusActorV5Head) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__LotusActorV5Head) ListIterator() ipld.ListIterator

+ func (Link__LotusActorV5Head) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__LotusActorV5Head) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__LotusActorV5Head) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__LotusActorV5Head) LookupByString(string) (ipld.Node, error)

+ func (Link__LotusActorV5Head) MapIterator() ipld.MapIterator

+ func (Link__LotusActorV5Head) Prototype() ipld.NodePrototype

+ func (Link__LotusActorV5Head) Type() schema.Type

+ func (n Link__LotusActorV5Head) AsLink() (ipld.Link, error)

+ func (n Link__LotusActorV5Head) Link() ipld.Link

+ func (n Link__LotusActorV5Head) Representation() ipld.Node

+ type Link__LotusActors = *_Link__LotusActors

+ func (Link__LotusActors) AsBool() (bool, error)

+ func (Link__LotusActors) AsBytes() ([]byte, error)

+ func (Link__LotusActors) AsFloat() (float64, error)

+ func (Link__LotusActors) AsInt() (int64, error)

+ func (Link__LotusActors) AsString() (string, error)

+ func (Link__LotusActors) IsAbsent() bool

+ func (Link__LotusActors) IsNull() bool

+ func (Link__LotusActors) Kind() ipld.Kind

+ func (Link__LotusActors) Length() int64

+ func (Link__LotusActors) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__LotusActors) ListIterator() ipld.ListIterator

+ func (Link__LotusActors) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__LotusActors) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__LotusActors) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__LotusActors) LookupByString(string) (ipld.Node, error)

+ func (Link__LotusActors) MapIterator() ipld.MapIterator

+ func (Link__LotusActors) Prototype() ipld.NodePrototype

+ func (Link__LotusActors) Type() schema.Type

+ func (n Link__LotusActors) AsLink() (ipld.Link, error)

+ func (n Link__LotusActors) Link() ipld.Link

+ func (n Link__LotusActors) Representation() ipld.Node

+ type Link__LotusMessage = *_Link__LotusMessage

+ func (Link__LotusMessage) AsBool() (bool, error)

+ func (Link__LotusMessage) AsBytes() ([]byte, error)

+ func (Link__LotusMessage) AsFloat() (float64, error)

+ func (Link__LotusMessage) AsInt() (int64, error)

+ func (Link__LotusMessage) AsString() (string, error)

+ func (Link__LotusMessage) IsAbsent() bool

+ func (Link__LotusMessage) IsNull() bool

+ func (Link__LotusMessage) Kind() ipld.Kind

+ func (Link__LotusMessage) Length() int64

+ func (Link__LotusMessage) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__LotusMessage) ListIterator() ipld.ListIterator

+ func (Link__LotusMessage) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__LotusMessage) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__LotusMessage) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__LotusMessage) LookupByString(string) (ipld.Node, error)

+ func (Link__LotusMessage) MapIterator() ipld.MapIterator

+ func (Link__LotusMessage) Prototype() ipld.NodePrototype

+ func (Link__LotusMessage) Type() schema.Type

+ func (n Link__LotusMessage) AsLink() (ipld.Link, error)

+ func (n Link__LotusMessage) Link() ipld.Link

+ func (n Link__LotusMessage) Representation() ipld.Node

+ type Link__LotusMsgMeta = *_Link__LotusMsgMeta

+ func (Link__LotusMsgMeta) AsBool() (bool, error)

+ func (Link__LotusMsgMeta) AsBytes() ([]byte, error)

+ func (Link__LotusMsgMeta) AsFloat() (float64, error)

+ func (Link__LotusMsgMeta) AsInt() (int64, error)

+ func (Link__LotusMsgMeta) AsString() (string, error)

+ func (Link__LotusMsgMeta) IsAbsent() bool

+ func (Link__LotusMsgMeta) IsNull() bool

+ func (Link__LotusMsgMeta) Kind() ipld.Kind

+ func (Link__LotusMsgMeta) Length() int64

+ func (Link__LotusMsgMeta) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__LotusMsgMeta) ListIterator() ipld.ListIterator

+ func (Link__LotusMsgMeta) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__LotusMsgMeta) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__LotusMsgMeta) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__LotusMsgMeta) LookupByString(string) (ipld.Node, error)

+ func (Link__LotusMsgMeta) MapIterator() ipld.MapIterator

+ func (Link__LotusMsgMeta) Prototype() ipld.NodePrototype

+ func (Link__LotusMsgMeta) Type() schema.Type

+ func (n Link__LotusMsgMeta) AsLink() (ipld.Link, error)

+ func (n Link__LotusMsgMeta) Link() ipld.Link

+ func (n Link__LotusMsgMeta) Representation() ipld.Node

+ type Link__LotusStateRoot = *_Link__LotusStateRoot

+ func (Link__LotusStateRoot) AsBool() (bool, error)

+ func (Link__LotusStateRoot) AsBytes() ([]byte, error)

+ func (Link__LotusStateRoot) AsFloat() (float64, error)

+ func (Link__LotusStateRoot) AsInt() (int64, error)

+ func (Link__LotusStateRoot) AsString() (string, error)

+ func (Link__LotusStateRoot) IsAbsent() bool

+ func (Link__LotusStateRoot) IsNull() bool

+ func (Link__LotusStateRoot) Kind() ipld.Kind

+ func (Link__LotusStateRoot) Length() int64

+ func (Link__LotusStateRoot) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__LotusStateRoot) ListIterator() ipld.ListIterator

+ func (Link__LotusStateRoot) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__LotusStateRoot) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__LotusStateRoot) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__LotusStateRoot) LookupByString(string) (ipld.Node, error)

+ func (Link__LotusStateRoot) MapIterator() ipld.MapIterator

+ func (Link__LotusStateRoot) Prototype() ipld.NodePrototype

+ func (Link__LotusStateRoot) Type() schema.Type

+ func (n Link__LotusStateRoot) AsLink() (ipld.Link, error)

+ func (n Link__LotusStateRoot) Link() ipld.Link

+ func (n Link__LotusStateRoot) Representation() ipld.Node

+ type Link__MapActorID = *_Link__MapActorID

+ func (Link__MapActorID) AsBool() (bool, error)

+ func (Link__MapActorID) AsBytes() ([]byte, error)

+ func (Link__MapActorID) AsFloat() (float64, error)

+ func (Link__MapActorID) AsInt() (int64, error)

+ func (Link__MapActorID) AsString() (string, error)

+ func (Link__MapActorID) IsAbsent() bool

+ func (Link__MapActorID) IsNull() bool

+ func (Link__MapActorID) Kind() ipld.Kind

+ func (Link__MapActorID) Length() int64

+ func (Link__MapActorID) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MapActorID) ListIterator() ipld.ListIterator

+ func (Link__MapActorID) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MapActorID) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MapActorID) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MapActorID) LookupByString(string) (ipld.Node, error)

+ func (Link__MapActorID) MapIterator() ipld.MapIterator

+ func (Link__MapActorID) Prototype() ipld.NodePrototype

+ func (Link__MapActorID) Type() schema.Type

+ func (n Link__MapActorID) AsLink() (ipld.Link, error)

+ func (n Link__MapActorID) Link() ipld.Link

+ func (n Link__MapActorID) Representation() ipld.Node

+ type Link__MarketV0DealProposal = *_Link__MarketV0DealProposal

+ func (Link__MarketV0DealProposal) AsBool() (bool, error)

+ func (Link__MarketV0DealProposal) AsBytes() ([]byte, error)

+ func (Link__MarketV0DealProposal) AsFloat() (float64, error)

+ func (Link__MarketV0DealProposal) AsInt() (int64, error)

+ func (Link__MarketV0DealProposal) AsString() (string, error)

+ func (Link__MarketV0DealProposal) IsAbsent() bool

+ func (Link__MarketV0DealProposal) IsNull() bool

+ func (Link__MarketV0DealProposal) Kind() ipld.Kind

+ func (Link__MarketV0DealProposal) Length() int64

+ func (Link__MarketV0DealProposal) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MarketV0DealProposal) ListIterator() ipld.ListIterator

+ func (Link__MarketV0DealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MarketV0DealProposal) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MarketV0DealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MarketV0DealProposal) LookupByString(string) (ipld.Node, error)

+ func (Link__MarketV0DealProposal) MapIterator() ipld.MapIterator

+ func (Link__MarketV0DealProposal) Prototype() ipld.NodePrototype

+ func (Link__MarketV0DealProposal) Type() schema.Type

+ func (n Link__MarketV0DealProposal) AsLink() (ipld.Link, error)

+ func (n Link__MarketV0DealProposal) Link() ipld.Link

+ func (n Link__MarketV0DealProposal) Representation() ipld.Node

+ type Link__MarketV0DealState = *_Link__MarketV0DealState

+ func (Link__MarketV0DealState) AsBool() (bool, error)

+ func (Link__MarketV0DealState) AsBytes() ([]byte, error)

+ func (Link__MarketV0DealState) AsFloat() (float64, error)

+ func (Link__MarketV0DealState) AsInt() (int64, error)

+ func (Link__MarketV0DealState) AsString() (string, error)

+ func (Link__MarketV0DealState) IsAbsent() bool

+ func (Link__MarketV0DealState) IsNull() bool

+ func (Link__MarketV0DealState) Kind() ipld.Kind

+ func (Link__MarketV0DealState) Length() int64

+ func (Link__MarketV0DealState) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MarketV0DealState) ListIterator() ipld.ListIterator

+ func (Link__MarketV0DealState) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MarketV0DealState) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MarketV0DealState) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MarketV0DealState) LookupByString(string) (ipld.Node, error)

+ func (Link__MarketV0DealState) MapIterator() ipld.MapIterator

+ func (Link__MarketV0DealState) Prototype() ipld.NodePrototype

+ func (Link__MarketV0DealState) Type() schema.Type

+ func (n Link__MarketV0DealState) AsLink() (ipld.Link, error)

+ func (n Link__MarketV0DealState) Link() ipld.Link

+ func (n Link__MarketV0DealState) Representation() ipld.Node

+ type Link__MarketV0RawDealProposal = *_Link__MarketV0RawDealProposal

+ func (Link__MarketV0RawDealProposal) AsBool() (bool, error)

+ func (Link__MarketV0RawDealProposal) AsBytes() ([]byte, error)

+ func (Link__MarketV0RawDealProposal) AsFloat() (float64, error)

+ func (Link__MarketV0RawDealProposal) AsInt() (int64, error)

+ func (Link__MarketV0RawDealProposal) AsString() (string, error)

+ func (Link__MarketV0RawDealProposal) IsAbsent() bool

+ func (Link__MarketV0RawDealProposal) IsNull() bool

+ func (Link__MarketV0RawDealProposal) Kind() ipld.Kind

+ func (Link__MarketV0RawDealProposal) Length() int64

+ func (Link__MarketV0RawDealProposal) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MarketV0RawDealProposal) ListIterator() ipld.ListIterator

+ func (Link__MarketV0RawDealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MarketV0RawDealProposal) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MarketV0RawDealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MarketV0RawDealProposal) LookupByString(string) (ipld.Node, error)

+ func (Link__MarketV0RawDealProposal) MapIterator() ipld.MapIterator

+ func (Link__MarketV0RawDealProposal) Prototype() ipld.NodePrototype

+ func (Link__MarketV0RawDealProposal) Type() schema.Type

+ func (n Link__MarketV0RawDealProposal) AsLink() (ipld.Link, error)

+ func (n Link__MarketV0RawDealProposal) Link() ipld.Link

+ func (n Link__MarketV0RawDealProposal) Representation() ipld.Node

+ type Link__MarketV0State = *_Link__MarketV0State

+ func (Link__MarketV0State) AsBool() (bool, error)

+ func (Link__MarketV0State) AsBytes() ([]byte, error)

+ func (Link__MarketV0State) AsFloat() (float64, error)

+ func (Link__MarketV0State) AsInt() (int64, error)

+ func (Link__MarketV0State) AsString() (string, error)

+ func (Link__MarketV0State) IsAbsent() bool

+ func (Link__MarketV0State) IsNull() bool

+ func (Link__MarketV0State) Kind() ipld.Kind

+ func (Link__MarketV0State) Length() int64

+ func (Link__MarketV0State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MarketV0State) ListIterator() ipld.ListIterator

+ func (Link__MarketV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MarketV0State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MarketV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MarketV0State) LookupByString(string) (ipld.Node, error)

+ func (Link__MarketV0State) MapIterator() ipld.MapIterator

+ func (Link__MarketV0State) Prototype() ipld.NodePrototype

+ func (Link__MarketV0State) Type() schema.Type

+ func (n Link__MarketV0State) AsLink() (ipld.Link, error)

+ func (n Link__MarketV0State) Link() ipld.Link

+ func (n Link__MarketV0State) Representation() ipld.Node

+ type Link__MarketV2DealProposal = *_Link__MarketV2DealProposal

+ func (Link__MarketV2DealProposal) AsBool() (bool, error)

+ func (Link__MarketV2DealProposal) AsBytes() ([]byte, error)

+ func (Link__MarketV2DealProposal) AsFloat() (float64, error)

+ func (Link__MarketV2DealProposal) AsInt() (int64, error)

+ func (Link__MarketV2DealProposal) AsString() (string, error)

+ func (Link__MarketV2DealProposal) IsAbsent() bool

+ func (Link__MarketV2DealProposal) IsNull() bool

+ func (Link__MarketV2DealProposal) Kind() ipld.Kind

+ func (Link__MarketV2DealProposal) Length() int64

+ func (Link__MarketV2DealProposal) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MarketV2DealProposal) ListIterator() ipld.ListIterator

+ func (Link__MarketV2DealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MarketV2DealProposal) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MarketV2DealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MarketV2DealProposal) LookupByString(string) (ipld.Node, error)

+ func (Link__MarketV2DealProposal) MapIterator() ipld.MapIterator

+ func (Link__MarketV2DealProposal) Prototype() ipld.NodePrototype

+ func (Link__MarketV2DealProposal) Type() schema.Type

+ func (n Link__MarketV2DealProposal) AsLink() (ipld.Link, error)

+ func (n Link__MarketV2DealProposal) Link() ipld.Link

+ func (n Link__MarketV2DealProposal) Representation() ipld.Node

+ type Link__MarketV2RawDealProposal = *_Link__MarketV2RawDealProposal

+ func (Link__MarketV2RawDealProposal) AsBool() (bool, error)

+ func (Link__MarketV2RawDealProposal) AsBytes() ([]byte, error)

+ func (Link__MarketV2RawDealProposal) AsFloat() (float64, error)

+ func (Link__MarketV2RawDealProposal) AsInt() (int64, error)

+ func (Link__MarketV2RawDealProposal) AsString() (string, error)

+ func (Link__MarketV2RawDealProposal) IsAbsent() bool

+ func (Link__MarketV2RawDealProposal) IsNull() bool

+ func (Link__MarketV2RawDealProposal) Kind() ipld.Kind

+ func (Link__MarketV2RawDealProposal) Length() int64

+ func (Link__MarketV2RawDealProposal) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MarketV2RawDealProposal) ListIterator() ipld.ListIterator

+ func (Link__MarketV2RawDealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MarketV2RawDealProposal) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MarketV2RawDealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MarketV2RawDealProposal) LookupByString(string) (ipld.Node, error)

+ func (Link__MarketV2RawDealProposal) MapIterator() ipld.MapIterator

+ func (Link__MarketV2RawDealProposal) Prototype() ipld.NodePrototype

+ func (Link__MarketV2RawDealProposal) Type() schema.Type

+ func (n Link__MarketV2RawDealProposal) AsLink() (ipld.Link, error)

+ func (n Link__MarketV2RawDealProposal) Link() ipld.Link

+ func (n Link__MarketV2RawDealProposal) Representation() ipld.Node

+ type Link__MarketV2State = *_Link__MarketV2State

+ func (Link__MarketV2State) AsBool() (bool, error)

+ func (Link__MarketV2State) AsBytes() ([]byte, error)

+ func (Link__MarketV2State) AsFloat() (float64, error)

+ func (Link__MarketV2State) AsInt() (int64, error)

+ func (Link__MarketV2State) AsString() (string, error)

+ func (Link__MarketV2State) IsAbsent() bool

+ func (Link__MarketV2State) IsNull() bool

+ func (Link__MarketV2State) Kind() ipld.Kind

+ func (Link__MarketV2State) Length() int64

+ func (Link__MarketV2State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MarketV2State) ListIterator() ipld.ListIterator

+ func (Link__MarketV2State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MarketV2State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MarketV2State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MarketV2State) LookupByString(string) (ipld.Node, error)

+ func (Link__MarketV2State) MapIterator() ipld.MapIterator

+ func (Link__MarketV2State) Prototype() ipld.NodePrototype

+ func (Link__MarketV2State) Type() schema.Type

+ func (n Link__MarketV2State) AsLink() (ipld.Link, error)

+ func (n Link__MarketV2State) Link() ipld.Link

+ func (n Link__MarketV2State) Representation() ipld.Node

+ type Link__MarketV3DealProposal = *_Link__MarketV3DealProposal

+ func (Link__MarketV3DealProposal) AsBool() (bool, error)

+ func (Link__MarketV3DealProposal) AsBytes() ([]byte, error)

+ func (Link__MarketV3DealProposal) AsFloat() (float64, error)

+ func (Link__MarketV3DealProposal) AsInt() (int64, error)

+ func (Link__MarketV3DealProposal) AsString() (string, error)

+ func (Link__MarketV3DealProposal) IsAbsent() bool

+ func (Link__MarketV3DealProposal) IsNull() bool

+ func (Link__MarketV3DealProposal) Kind() ipld.Kind

+ func (Link__MarketV3DealProposal) Length() int64

+ func (Link__MarketV3DealProposal) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MarketV3DealProposal) ListIterator() ipld.ListIterator

+ func (Link__MarketV3DealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MarketV3DealProposal) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MarketV3DealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MarketV3DealProposal) LookupByString(string) (ipld.Node, error)

+ func (Link__MarketV3DealProposal) MapIterator() ipld.MapIterator

+ func (Link__MarketV3DealProposal) Prototype() ipld.NodePrototype

+ func (Link__MarketV3DealProposal) Type() schema.Type

+ func (n Link__MarketV3DealProposal) AsLink() (ipld.Link, error)

+ func (n Link__MarketV3DealProposal) Link() ipld.Link

+ func (n Link__MarketV3DealProposal) Representation() ipld.Node

+ type Link__MarketV3DealState = *_Link__MarketV3DealState

+ func (Link__MarketV3DealState) AsBool() (bool, error)

+ func (Link__MarketV3DealState) AsBytes() ([]byte, error)

+ func (Link__MarketV3DealState) AsFloat() (float64, error)

+ func (Link__MarketV3DealState) AsInt() (int64, error)

+ func (Link__MarketV3DealState) AsString() (string, error)

+ func (Link__MarketV3DealState) IsAbsent() bool

+ func (Link__MarketV3DealState) IsNull() bool

+ func (Link__MarketV3DealState) Kind() ipld.Kind

+ func (Link__MarketV3DealState) Length() int64

+ func (Link__MarketV3DealState) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MarketV3DealState) ListIterator() ipld.ListIterator

+ func (Link__MarketV3DealState) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MarketV3DealState) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MarketV3DealState) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MarketV3DealState) LookupByString(string) (ipld.Node, error)

+ func (Link__MarketV3DealState) MapIterator() ipld.MapIterator

+ func (Link__MarketV3DealState) Prototype() ipld.NodePrototype

+ func (Link__MarketV3DealState) Type() schema.Type

+ func (n Link__MarketV3DealState) AsLink() (ipld.Link, error)

+ func (n Link__MarketV3DealState) Link() ipld.Link

+ func (n Link__MarketV3DealState) Representation() ipld.Node

+ type Link__MarketV3MultimapDealID = *_Link__MarketV3MultimapDealID

+ func (Link__MarketV3MultimapDealID) AsBool() (bool, error)

+ func (Link__MarketV3MultimapDealID) AsBytes() ([]byte, error)

+ func (Link__MarketV3MultimapDealID) AsFloat() (float64, error)

+ func (Link__MarketV3MultimapDealID) AsInt() (int64, error)

+ func (Link__MarketV3MultimapDealID) AsString() (string, error)

+ func (Link__MarketV3MultimapDealID) IsAbsent() bool

+ func (Link__MarketV3MultimapDealID) IsNull() bool

+ func (Link__MarketV3MultimapDealID) Kind() ipld.Kind

+ func (Link__MarketV3MultimapDealID) Length() int64

+ func (Link__MarketV3MultimapDealID) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MarketV3MultimapDealID) ListIterator() ipld.ListIterator

+ func (Link__MarketV3MultimapDealID) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MarketV3MultimapDealID) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MarketV3MultimapDealID) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MarketV3MultimapDealID) LookupByString(string) (ipld.Node, error)

+ func (Link__MarketV3MultimapDealID) MapIterator() ipld.MapIterator

+ func (Link__MarketV3MultimapDealID) Prototype() ipld.NodePrototype

+ func (Link__MarketV3MultimapDealID) Type() schema.Type

+ func (n Link__MarketV3MultimapDealID) AsLink() (ipld.Link, error)

+ func (n Link__MarketV3MultimapDealID) Link() ipld.Link

+ func (n Link__MarketV3MultimapDealID) Representation() ipld.Node

+ type Link__MarketV3RawDealProposal = *_Link__MarketV3RawDealProposal

+ func (Link__MarketV3RawDealProposal) AsBool() (bool, error)

+ func (Link__MarketV3RawDealProposal) AsBytes() ([]byte, error)

+ func (Link__MarketV3RawDealProposal) AsFloat() (float64, error)

+ func (Link__MarketV3RawDealProposal) AsInt() (int64, error)

+ func (Link__MarketV3RawDealProposal) AsString() (string, error)

+ func (Link__MarketV3RawDealProposal) IsAbsent() bool

+ func (Link__MarketV3RawDealProposal) IsNull() bool

+ func (Link__MarketV3RawDealProposal) Kind() ipld.Kind

+ func (Link__MarketV3RawDealProposal) Length() int64

+ func (Link__MarketV3RawDealProposal) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MarketV3RawDealProposal) ListIterator() ipld.ListIterator

+ func (Link__MarketV3RawDealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MarketV3RawDealProposal) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MarketV3RawDealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MarketV3RawDealProposal) LookupByString(string) (ipld.Node, error)

+ func (Link__MarketV3RawDealProposal) MapIterator() ipld.MapIterator

+ func (Link__MarketV3RawDealProposal) Prototype() ipld.NodePrototype

+ func (Link__MarketV3RawDealProposal) Type() schema.Type

+ func (n Link__MarketV3RawDealProposal) AsLink() (ipld.Link, error)

+ func (n Link__MarketV3RawDealProposal) Link() ipld.Link

+ func (n Link__MarketV3RawDealProposal) Representation() ipld.Node

+ type Link__MarketV3State = *_Link__MarketV3State

+ func (Link__MarketV3State) AsBool() (bool, error)

+ func (Link__MarketV3State) AsBytes() ([]byte, error)

+ func (Link__MarketV3State) AsFloat() (float64, error)

+ func (Link__MarketV3State) AsInt() (int64, error)

+ func (Link__MarketV3State) AsString() (string, error)

+ func (Link__MarketV3State) IsAbsent() bool

+ func (Link__MarketV3State) IsNull() bool

+ func (Link__MarketV3State) Kind() ipld.Kind

+ func (Link__MarketV3State) Length() int64

+ func (Link__MarketV3State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MarketV3State) ListIterator() ipld.ListIterator

+ func (Link__MarketV3State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MarketV3State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MarketV3State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MarketV3State) LookupByString(string) (ipld.Node, error)

+ func (Link__MarketV3State) MapIterator() ipld.MapIterator

+ func (Link__MarketV3State) Prototype() ipld.NodePrototype

+ func (Link__MarketV3State) Type() schema.Type

+ func (n Link__MarketV3State) AsLink() (ipld.Link, error)

+ func (n Link__MarketV3State) Link() ipld.Link

+ func (n Link__MarketV3State) Representation() ipld.Node

+ type Link__MarketV5State = *_Link__MarketV5State

+ func (Link__MarketV5State) AsBool() (bool, error)

+ func (Link__MarketV5State) AsBytes() ([]byte, error)

+ func (Link__MarketV5State) AsFloat() (float64, error)

+ func (Link__MarketV5State) AsInt() (int64, error)

+ func (Link__MarketV5State) AsString() (string, error)

+ func (Link__MarketV5State) IsAbsent() bool

+ func (Link__MarketV5State) IsNull() bool

+ func (Link__MarketV5State) Kind() ipld.Kind

+ func (Link__MarketV5State) Length() int64

+ func (Link__MarketV5State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MarketV5State) ListIterator() ipld.ListIterator

+ func (Link__MarketV5State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MarketV5State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MarketV5State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MarketV5State) LookupByString(string) (ipld.Node, error)

+ func (Link__MarketV5State) MapIterator() ipld.MapIterator

+ func (Link__MarketV5State) Prototype() ipld.NodePrototype

+ func (Link__MarketV5State) Type() schema.Type

+ func (n Link__MarketV5State) AsLink() (ipld.Link, error)

+ func (n Link__MarketV5State) Link() ipld.Link

+ func (n Link__MarketV5State) Representation() ipld.Node

+ type Link__MinerV0Deadline = *_Link__MinerV0Deadline

+ func (Link__MinerV0Deadline) AsBool() (bool, error)

+ func (Link__MinerV0Deadline) AsBytes() ([]byte, error)

+ func (Link__MinerV0Deadline) AsFloat() (float64, error)

+ func (Link__MinerV0Deadline) AsInt() (int64, error)

+ func (Link__MinerV0Deadline) AsString() (string, error)

+ func (Link__MinerV0Deadline) IsAbsent() bool

+ func (Link__MinerV0Deadline) IsNull() bool

+ func (Link__MinerV0Deadline) Kind() ipld.Kind

+ func (Link__MinerV0Deadline) Length() int64

+ func (Link__MinerV0Deadline) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV0Deadline) ListIterator() ipld.ListIterator

+ func (Link__MinerV0Deadline) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV0Deadline) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV0Deadline) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV0Deadline) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV0Deadline) MapIterator() ipld.MapIterator

+ func (Link__MinerV0Deadline) Prototype() ipld.NodePrototype

+ func (Link__MinerV0Deadline) Type() schema.Type

+ func (n Link__MinerV0Deadline) AsLink() (ipld.Link, error)

+ func (n Link__MinerV0Deadline) Link() ipld.Link

+ func (n Link__MinerV0Deadline) Representation() ipld.Node

+ type Link__MinerV0Deadlines = *_Link__MinerV0Deadlines

+ func (Link__MinerV0Deadlines) AsBool() (bool, error)

+ func (Link__MinerV0Deadlines) AsBytes() ([]byte, error)

+ func (Link__MinerV0Deadlines) AsFloat() (float64, error)

+ func (Link__MinerV0Deadlines) AsInt() (int64, error)

+ func (Link__MinerV0Deadlines) AsString() (string, error)

+ func (Link__MinerV0Deadlines) IsAbsent() bool

+ func (Link__MinerV0Deadlines) IsNull() bool

+ func (Link__MinerV0Deadlines) Kind() ipld.Kind

+ func (Link__MinerV0Deadlines) Length() int64

+ func (Link__MinerV0Deadlines) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV0Deadlines) ListIterator() ipld.ListIterator

+ func (Link__MinerV0Deadlines) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV0Deadlines) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV0Deadlines) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV0Deadlines) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV0Deadlines) MapIterator() ipld.MapIterator

+ func (Link__MinerV0Deadlines) Prototype() ipld.NodePrototype

+ func (Link__MinerV0Deadlines) Type() schema.Type

+ func (n Link__MinerV0Deadlines) AsLink() (ipld.Link, error)

+ func (n Link__MinerV0Deadlines) Link() ipld.Link

+ func (n Link__MinerV0Deadlines) Representation() ipld.Node

+ type Link__MinerV0ExpirationSet = *_Link__MinerV0ExpirationSet

+ func (Link__MinerV0ExpirationSet) AsBool() (bool, error)

+ func (Link__MinerV0ExpirationSet) AsBytes() ([]byte, error)

+ func (Link__MinerV0ExpirationSet) AsFloat() (float64, error)

+ func (Link__MinerV0ExpirationSet) AsInt() (int64, error)

+ func (Link__MinerV0ExpirationSet) AsString() (string, error)

+ func (Link__MinerV0ExpirationSet) IsAbsent() bool

+ func (Link__MinerV0ExpirationSet) IsNull() bool

+ func (Link__MinerV0ExpirationSet) Kind() ipld.Kind

+ func (Link__MinerV0ExpirationSet) Length() int64

+ func (Link__MinerV0ExpirationSet) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV0ExpirationSet) ListIterator() ipld.ListIterator

+ func (Link__MinerV0ExpirationSet) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV0ExpirationSet) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV0ExpirationSet) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV0ExpirationSet) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV0ExpirationSet) MapIterator() ipld.MapIterator

+ func (Link__MinerV0ExpirationSet) Prototype() ipld.NodePrototype

+ func (Link__MinerV0ExpirationSet) Type() schema.Type

+ func (n Link__MinerV0ExpirationSet) AsLink() (ipld.Link, error)

+ func (n Link__MinerV0ExpirationSet) Link() ipld.Link

+ func (n Link__MinerV0ExpirationSet) Representation() ipld.Node

+ type Link__MinerV0Info = *_Link__MinerV0Info

+ func (Link__MinerV0Info) AsBool() (bool, error)

+ func (Link__MinerV0Info) AsBytes() ([]byte, error)

+ func (Link__MinerV0Info) AsFloat() (float64, error)

+ func (Link__MinerV0Info) AsInt() (int64, error)

+ func (Link__MinerV0Info) AsString() (string, error)

+ func (Link__MinerV0Info) IsAbsent() bool

+ func (Link__MinerV0Info) IsNull() bool

+ func (Link__MinerV0Info) Kind() ipld.Kind

+ func (Link__MinerV0Info) Length() int64

+ func (Link__MinerV0Info) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV0Info) ListIterator() ipld.ListIterator

+ func (Link__MinerV0Info) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV0Info) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV0Info) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV0Info) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV0Info) MapIterator() ipld.MapIterator

+ func (Link__MinerV0Info) Prototype() ipld.NodePrototype

+ func (Link__MinerV0Info) Type() schema.Type

+ func (n Link__MinerV0Info) AsLink() (ipld.Link, error)

+ func (n Link__MinerV0Info) Link() ipld.Link

+ func (n Link__MinerV0Info) Representation() ipld.Node

+ type Link__MinerV0Partition = *_Link__MinerV0Partition

+ func (Link__MinerV0Partition) AsBool() (bool, error)

+ func (Link__MinerV0Partition) AsBytes() ([]byte, error)

+ func (Link__MinerV0Partition) AsFloat() (float64, error)

+ func (Link__MinerV0Partition) AsInt() (int64, error)

+ func (Link__MinerV0Partition) AsString() (string, error)

+ func (Link__MinerV0Partition) IsAbsent() bool

+ func (Link__MinerV0Partition) IsNull() bool

+ func (Link__MinerV0Partition) Kind() ipld.Kind

+ func (Link__MinerV0Partition) Length() int64

+ func (Link__MinerV0Partition) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV0Partition) ListIterator() ipld.ListIterator

+ func (Link__MinerV0Partition) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV0Partition) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV0Partition) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV0Partition) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV0Partition) MapIterator() ipld.MapIterator

+ func (Link__MinerV0Partition) Prototype() ipld.NodePrototype

+ func (Link__MinerV0Partition) Type() schema.Type

+ func (n Link__MinerV0Partition) AsLink() (ipld.Link, error)

+ func (n Link__MinerV0Partition) Link() ipld.Link

+ func (n Link__MinerV0Partition) Representation() ipld.Node

+ type Link__MinerV0SectorInfo = *_Link__MinerV0SectorInfo

+ func (Link__MinerV0SectorInfo) AsBool() (bool, error)

+ func (Link__MinerV0SectorInfo) AsBytes() ([]byte, error)

+ func (Link__MinerV0SectorInfo) AsFloat() (float64, error)

+ func (Link__MinerV0SectorInfo) AsInt() (int64, error)

+ func (Link__MinerV0SectorInfo) AsString() (string, error)

+ func (Link__MinerV0SectorInfo) IsAbsent() bool

+ func (Link__MinerV0SectorInfo) IsNull() bool

+ func (Link__MinerV0SectorInfo) Kind() ipld.Kind

+ func (Link__MinerV0SectorInfo) Length() int64

+ func (Link__MinerV0SectorInfo) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV0SectorInfo) ListIterator() ipld.ListIterator

+ func (Link__MinerV0SectorInfo) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV0SectorInfo) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV0SectorInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV0SectorInfo) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV0SectorInfo) MapIterator() ipld.MapIterator

+ func (Link__MinerV0SectorInfo) Prototype() ipld.NodePrototype

+ func (Link__MinerV0SectorInfo) Type() schema.Type

+ func (n Link__MinerV0SectorInfo) AsLink() (ipld.Link, error)

+ func (n Link__MinerV0SectorInfo) Link() ipld.Link

+ func (n Link__MinerV0SectorInfo) Representation() ipld.Node

+ type Link__MinerV0SectorPreCommits = *_Link__MinerV0SectorPreCommits

+ func (Link__MinerV0SectorPreCommits) AsBool() (bool, error)

+ func (Link__MinerV0SectorPreCommits) AsBytes() ([]byte, error)

+ func (Link__MinerV0SectorPreCommits) AsFloat() (float64, error)

+ func (Link__MinerV0SectorPreCommits) AsInt() (int64, error)

+ func (Link__MinerV0SectorPreCommits) AsString() (string, error)

+ func (Link__MinerV0SectorPreCommits) IsAbsent() bool

+ func (Link__MinerV0SectorPreCommits) IsNull() bool

+ func (Link__MinerV0SectorPreCommits) Kind() ipld.Kind

+ func (Link__MinerV0SectorPreCommits) Length() int64

+ func (Link__MinerV0SectorPreCommits) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV0SectorPreCommits) ListIterator() ipld.ListIterator

+ func (Link__MinerV0SectorPreCommits) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV0SectorPreCommits) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV0SectorPreCommits) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV0SectorPreCommits) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV0SectorPreCommits) MapIterator() ipld.MapIterator

+ func (Link__MinerV0SectorPreCommits) Prototype() ipld.NodePrototype

+ func (Link__MinerV0SectorPreCommits) Type() schema.Type

+ func (n Link__MinerV0SectorPreCommits) AsLink() (ipld.Link, error)

+ func (n Link__MinerV0SectorPreCommits) Link() ipld.Link

+ func (n Link__MinerV0SectorPreCommits) Representation() ipld.Node

+ type Link__MinerV0State = *_Link__MinerV0State

+ func (Link__MinerV0State) AsBool() (bool, error)

+ func (Link__MinerV0State) AsBytes() ([]byte, error)

+ func (Link__MinerV0State) AsFloat() (float64, error)

+ func (Link__MinerV0State) AsInt() (int64, error)

+ func (Link__MinerV0State) AsString() (string, error)

+ func (Link__MinerV0State) IsAbsent() bool

+ func (Link__MinerV0State) IsNull() bool

+ func (Link__MinerV0State) Kind() ipld.Kind

+ func (Link__MinerV0State) Length() int64

+ func (Link__MinerV0State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV0State) ListIterator() ipld.ListIterator

+ func (Link__MinerV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV0State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV0State) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV0State) MapIterator() ipld.MapIterator

+ func (Link__MinerV0State) Prototype() ipld.NodePrototype

+ func (Link__MinerV0State) Type() schema.Type

+ func (n Link__MinerV0State) AsLink() (ipld.Link, error)

+ func (n Link__MinerV0State) Link() ipld.Link

+ func (n Link__MinerV0State) Representation() ipld.Node

+ type Link__MinerV0VestingFunds = *_Link__MinerV0VestingFunds

+ func (Link__MinerV0VestingFunds) AsBool() (bool, error)

+ func (Link__MinerV0VestingFunds) AsBytes() ([]byte, error)

+ func (Link__MinerV0VestingFunds) AsFloat() (float64, error)

+ func (Link__MinerV0VestingFunds) AsInt() (int64, error)

+ func (Link__MinerV0VestingFunds) AsString() (string, error)

+ func (Link__MinerV0VestingFunds) IsAbsent() bool

+ func (Link__MinerV0VestingFunds) IsNull() bool

+ func (Link__MinerV0VestingFunds) Kind() ipld.Kind

+ func (Link__MinerV0VestingFunds) Length() int64

+ func (Link__MinerV0VestingFunds) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV0VestingFunds) ListIterator() ipld.ListIterator

+ func (Link__MinerV0VestingFunds) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV0VestingFunds) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV0VestingFunds) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV0VestingFunds) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV0VestingFunds) MapIterator() ipld.MapIterator

+ func (Link__MinerV0VestingFunds) Prototype() ipld.NodePrototype

+ func (Link__MinerV0VestingFunds) Type() schema.Type

+ func (n Link__MinerV0VestingFunds) AsLink() (ipld.Link, error)

+ func (n Link__MinerV0VestingFunds) Link() ipld.Link

+ func (n Link__MinerV0VestingFunds) Representation() ipld.Node

+ type Link__MinerV2Deadline = *_Link__MinerV2Deadline

+ func (Link__MinerV2Deadline) AsBool() (bool, error)

+ func (Link__MinerV2Deadline) AsBytes() ([]byte, error)

+ func (Link__MinerV2Deadline) AsFloat() (float64, error)

+ func (Link__MinerV2Deadline) AsInt() (int64, error)

+ func (Link__MinerV2Deadline) AsString() (string, error)

+ func (Link__MinerV2Deadline) IsAbsent() bool

+ func (Link__MinerV2Deadline) IsNull() bool

+ func (Link__MinerV2Deadline) Kind() ipld.Kind

+ func (Link__MinerV2Deadline) Length() int64

+ func (Link__MinerV2Deadline) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV2Deadline) ListIterator() ipld.ListIterator

+ func (Link__MinerV2Deadline) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV2Deadline) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV2Deadline) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV2Deadline) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV2Deadline) MapIterator() ipld.MapIterator

+ func (Link__MinerV2Deadline) Prototype() ipld.NodePrototype

+ func (Link__MinerV2Deadline) Type() schema.Type

+ func (n Link__MinerV2Deadline) AsLink() (ipld.Link, error)

+ func (n Link__MinerV2Deadline) Link() ipld.Link

+ func (n Link__MinerV2Deadline) Representation() ipld.Node

+ type Link__MinerV2Deadlines = *_Link__MinerV2Deadlines

+ func (Link__MinerV2Deadlines) AsBool() (bool, error)

+ func (Link__MinerV2Deadlines) AsBytes() ([]byte, error)

+ func (Link__MinerV2Deadlines) AsFloat() (float64, error)

+ func (Link__MinerV2Deadlines) AsInt() (int64, error)

+ func (Link__MinerV2Deadlines) AsString() (string, error)

+ func (Link__MinerV2Deadlines) IsAbsent() bool

+ func (Link__MinerV2Deadlines) IsNull() bool

+ func (Link__MinerV2Deadlines) Kind() ipld.Kind

+ func (Link__MinerV2Deadlines) Length() int64

+ func (Link__MinerV2Deadlines) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV2Deadlines) ListIterator() ipld.ListIterator

+ func (Link__MinerV2Deadlines) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV2Deadlines) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV2Deadlines) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV2Deadlines) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV2Deadlines) MapIterator() ipld.MapIterator

+ func (Link__MinerV2Deadlines) Prototype() ipld.NodePrototype

+ func (Link__MinerV2Deadlines) Type() schema.Type

+ func (n Link__MinerV2Deadlines) AsLink() (ipld.Link, error)

+ func (n Link__MinerV2Deadlines) Link() ipld.Link

+ func (n Link__MinerV2Deadlines) Representation() ipld.Node

+ type Link__MinerV2Info = *_Link__MinerV2Info

+ func (Link__MinerV2Info) AsBool() (bool, error)

+ func (Link__MinerV2Info) AsBytes() ([]byte, error)

+ func (Link__MinerV2Info) AsFloat() (float64, error)

+ func (Link__MinerV2Info) AsInt() (int64, error)

+ func (Link__MinerV2Info) AsString() (string, error)

+ func (Link__MinerV2Info) IsAbsent() bool

+ func (Link__MinerV2Info) IsNull() bool

+ func (Link__MinerV2Info) Kind() ipld.Kind

+ func (Link__MinerV2Info) Length() int64

+ func (Link__MinerV2Info) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV2Info) ListIterator() ipld.ListIterator

+ func (Link__MinerV2Info) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV2Info) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV2Info) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV2Info) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV2Info) MapIterator() ipld.MapIterator

+ func (Link__MinerV2Info) Prototype() ipld.NodePrototype

+ func (Link__MinerV2Info) Type() schema.Type

+ func (n Link__MinerV2Info) AsLink() (ipld.Link, error)

+ func (n Link__MinerV2Info) Link() ipld.Link

+ func (n Link__MinerV2Info) Representation() ipld.Node

+ type Link__MinerV2Partition = *_Link__MinerV2Partition

+ func (Link__MinerV2Partition) AsBool() (bool, error)

+ func (Link__MinerV2Partition) AsBytes() ([]byte, error)

+ func (Link__MinerV2Partition) AsFloat() (float64, error)

+ func (Link__MinerV2Partition) AsInt() (int64, error)

+ func (Link__MinerV2Partition) AsString() (string, error)

+ func (Link__MinerV2Partition) IsAbsent() bool

+ func (Link__MinerV2Partition) IsNull() bool

+ func (Link__MinerV2Partition) Kind() ipld.Kind

+ func (Link__MinerV2Partition) Length() int64

+ func (Link__MinerV2Partition) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV2Partition) ListIterator() ipld.ListIterator

+ func (Link__MinerV2Partition) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV2Partition) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV2Partition) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV2Partition) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV2Partition) MapIterator() ipld.MapIterator

+ func (Link__MinerV2Partition) Prototype() ipld.NodePrototype

+ func (Link__MinerV2Partition) Type() schema.Type

+ func (n Link__MinerV2Partition) AsLink() (ipld.Link, error)

+ func (n Link__MinerV2Partition) Link() ipld.Link

+ func (n Link__MinerV2Partition) Representation() ipld.Node

+ type Link__MinerV2SectorInfo = *_Link__MinerV2SectorInfo

+ func (Link__MinerV2SectorInfo) AsBool() (bool, error)

+ func (Link__MinerV2SectorInfo) AsBytes() ([]byte, error)

+ func (Link__MinerV2SectorInfo) AsFloat() (float64, error)

+ func (Link__MinerV2SectorInfo) AsInt() (int64, error)

+ func (Link__MinerV2SectorInfo) AsString() (string, error)

+ func (Link__MinerV2SectorInfo) IsAbsent() bool

+ func (Link__MinerV2SectorInfo) IsNull() bool

+ func (Link__MinerV2SectorInfo) Kind() ipld.Kind

+ func (Link__MinerV2SectorInfo) Length() int64

+ func (Link__MinerV2SectorInfo) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV2SectorInfo) ListIterator() ipld.ListIterator

+ func (Link__MinerV2SectorInfo) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV2SectorInfo) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV2SectorInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV2SectorInfo) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV2SectorInfo) MapIterator() ipld.MapIterator

+ func (Link__MinerV2SectorInfo) Prototype() ipld.NodePrototype

+ func (Link__MinerV2SectorInfo) Type() schema.Type

+ func (n Link__MinerV2SectorInfo) AsLink() (ipld.Link, error)

+ func (n Link__MinerV2SectorInfo) Link() ipld.Link

+ func (n Link__MinerV2SectorInfo) Representation() ipld.Node

+ type Link__MinerV2State = *_Link__MinerV2State

+ func (Link__MinerV2State) AsBool() (bool, error)

+ func (Link__MinerV2State) AsBytes() ([]byte, error)

+ func (Link__MinerV2State) AsFloat() (float64, error)

+ func (Link__MinerV2State) AsInt() (int64, error)

+ func (Link__MinerV2State) AsString() (string, error)

+ func (Link__MinerV2State) IsAbsent() bool

+ func (Link__MinerV2State) IsNull() bool

+ func (Link__MinerV2State) Kind() ipld.Kind

+ func (Link__MinerV2State) Length() int64

+ func (Link__MinerV2State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV2State) ListIterator() ipld.ListIterator

+ func (Link__MinerV2State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV2State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV2State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV2State) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV2State) MapIterator() ipld.MapIterator

+ func (Link__MinerV2State) Prototype() ipld.NodePrototype

+ func (Link__MinerV2State) Type() schema.Type

+ func (n Link__MinerV2State) AsLink() (ipld.Link, error)

+ func (n Link__MinerV2State) Link() ipld.Link

+ func (n Link__MinerV2State) Representation() ipld.Node

+ type Link__MinerV3Deadline = *_Link__MinerV3Deadline

+ func (Link__MinerV3Deadline) AsBool() (bool, error)

+ func (Link__MinerV3Deadline) AsBytes() ([]byte, error)

+ func (Link__MinerV3Deadline) AsFloat() (float64, error)

+ func (Link__MinerV3Deadline) AsInt() (int64, error)

+ func (Link__MinerV3Deadline) AsString() (string, error)

+ func (Link__MinerV3Deadline) IsAbsent() bool

+ func (Link__MinerV3Deadline) IsNull() bool

+ func (Link__MinerV3Deadline) Kind() ipld.Kind

+ func (Link__MinerV3Deadline) Length() int64

+ func (Link__MinerV3Deadline) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV3Deadline) ListIterator() ipld.ListIterator

+ func (Link__MinerV3Deadline) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV3Deadline) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV3Deadline) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV3Deadline) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV3Deadline) MapIterator() ipld.MapIterator

+ func (Link__MinerV3Deadline) Prototype() ipld.NodePrototype

+ func (Link__MinerV3Deadline) Type() schema.Type

+ func (n Link__MinerV3Deadline) AsLink() (ipld.Link, error)

+ func (n Link__MinerV3Deadline) Link() ipld.Link

+ func (n Link__MinerV3Deadline) Representation() ipld.Node

+ type Link__MinerV3Deadlines = *_Link__MinerV3Deadlines

+ func (Link__MinerV3Deadlines) AsBool() (bool, error)

+ func (Link__MinerV3Deadlines) AsBytes() ([]byte, error)

+ func (Link__MinerV3Deadlines) AsFloat() (float64, error)

+ func (Link__MinerV3Deadlines) AsInt() (int64, error)

+ func (Link__MinerV3Deadlines) AsString() (string, error)

+ func (Link__MinerV3Deadlines) IsAbsent() bool

+ func (Link__MinerV3Deadlines) IsNull() bool

+ func (Link__MinerV3Deadlines) Kind() ipld.Kind

+ func (Link__MinerV3Deadlines) Length() int64

+ func (Link__MinerV3Deadlines) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV3Deadlines) ListIterator() ipld.ListIterator

+ func (Link__MinerV3Deadlines) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV3Deadlines) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV3Deadlines) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV3Deadlines) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV3Deadlines) MapIterator() ipld.MapIterator

+ func (Link__MinerV3Deadlines) Prototype() ipld.NodePrototype

+ func (Link__MinerV3Deadlines) Type() schema.Type

+ func (n Link__MinerV3Deadlines) AsLink() (ipld.Link, error)

+ func (n Link__MinerV3Deadlines) Link() ipld.Link

+ func (n Link__MinerV3Deadlines) Representation() ipld.Node

+ type Link__MinerV3ExpirationSet = *_Link__MinerV3ExpirationSet

+ func (Link__MinerV3ExpirationSet) AsBool() (bool, error)

+ func (Link__MinerV3ExpirationSet) AsBytes() ([]byte, error)

+ func (Link__MinerV3ExpirationSet) AsFloat() (float64, error)

+ func (Link__MinerV3ExpirationSet) AsInt() (int64, error)

+ func (Link__MinerV3ExpirationSet) AsString() (string, error)

+ func (Link__MinerV3ExpirationSet) IsAbsent() bool

+ func (Link__MinerV3ExpirationSet) IsNull() bool

+ func (Link__MinerV3ExpirationSet) Kind() ipld.Kind

+ func (Link__MinerV3ExpirationSet) Length() int64

+ func (Link__MinerV3ExpirationSet) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV3ExpirationSet) ListIterator() ipld.ListIterator

+ func (Link__MinerV3ExpirationSet) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV3ExpirationSet) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV3ExpirationSet) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV3ExpirationSet) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV3ExpirationSet) MapIterator() ipld.MapIterator

+ func (Link__MinerV3ExpirationSet) Prototype() ipld.NodePrototype

+ func (Link__MinerV3ExpirationSet) Type() schema.Type

+ func (n Link__MinerV3ExpirationSet) AsLink() (ipld.Link, error)

+ func (n Link__MinerV3ExpirationSet) Link() ipld.Link

+ func (n Link__MinerV3ExpirationSet) Representation() ipld.Node

+ type Link__MinerV3Partition = *_Link__MinerV3Partition

+ func (Link__MinerV3Partition) AsBool() (bool, error)

+ func (Link__MinerV3Partition) AsBytes() ([]byte, error)

+ func (Link__MinerV3Partition) AsFloat() (float64, error)

+ func (Link__MinerV3Partition) AsInt() (int64, error)

+ func (Link__MinerV3Partition) AsString() (string, error)

+ func (Link__MinerV3Partition) IsAbsent() bool

+ func (Link__MinerV3Partition) IsNull() bool

+ func (Link__MinerV3Partition) Kind() ipld.Kind

+ func (Link__MinerV3Partition) Length() int64

+ func (Link__MinerV3Partition) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV3Partition) ListIterator() ipld.ListIterator

+ func (Link__MinerV3Partition) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV3Partition) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV3Partition) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV3Partition) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV3Partition) MapIterator() ipld.MapIterator

+ func (Link__MinerV3Partition) Prototype() ipld.NodePrototype

+ func (Link__MinerV3Partition) Type() schema.Type

+ func (n Link__MinerV3Partition) AsLink() (ipld.Link, error)

+ func (n Link__MinerV3Partition) Link() ipld.Link

+ func (n Link__MinerV3Partition) Representation() ipld.Node

+ type Link__MinerV3SectorInfo = *_Link__MinerV3SectorInfo

+ func (Link__MinerV3SectorInfo) AsBool() (bool, error)

+ func (Link__MinerV3SectorInfo) AsBytes() ([]byte, error)

+ func (Link__MinerV3SectorInfo) AsFloat() (float64, error)

+ func (Link__MinerV3SectorInfo) AsInt() (int64, error)

+ func (Link__MinerV3SectorInfo) AsString() (string, error)

+ func (Link__MinerV3SectorInfo) IsAbsent() bool

+ func (Link__MinerV3SectorInfo) IsNull() bool

+ func (Link__MinerV3SectorInfo) Kind() ipld.Kind

+ func (Link__MinerV3SectorInfo) Length() int64

+ func (Link__MinerV3SectorInfo) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV3SectorInfo) ListIterator() ipld.ListIterator

+ func (Link__MinerV3SectorInfo) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV3SectorInfo) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV3SectorInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV3SectorInfo) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV3SectorInfo) MapIterator() ipld.MapIterator

+ func (Link__MinerV3SectorInfo) Prototype() ipld.NodePrototype

+ func (Link__MinerV3SectorInfo) Type() schema.Type

+ func (n Link__MinerV3SectorInfo) AsLink() (ipld.Link, error)

+ func (n Link__MinerV3SectorInfo) Link() ipld.Link

+ func (n Link__MinerV3SectorInfo) Representation() ipld.Node

+ type Link__MinerV3SectorPreCommits = *_Link__MinerV3SectorPreCommits

+ func (Link__MinerV3SectorPreCommits) AsBool() (bool, error)

+ func (Link__MinerV3SectorPreCommits) AsBytes() ([]byte, error)

+ func (Link__MinerV3SectorPreCommits) AsFloat() (float64, error)

+ func (Link__MinerV3SectorPreCommits) AsInt() (int64, error)

+ func (Link__MinerV3SectorPreCommits) AsString() (string, error)

+ func (Link__MinerV3SectorPreCommits) IsAbsent() bool

+ func (Link__MinerV3SectorPreCommits) IsNull() bool

+ func (Link__MinerV3SectorPreCommits) Kind() ipld.Kind

+ func (Link__MinerV3SectorPreCommits) Length() int64

+ func (Link__MinerV3SectorPreCommits) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV3SectorPreCommits) ListIterator() ipld.ListIterator

+ func (Link__MinerV3SectorPreCommits) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV3SectorPreCommits) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV3SectorPreCommits) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV3SectorPreCommits) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV3SectorPreCommits) MapIterator() ipld.MapIterator

+ func (Link__MinerV3SectorPreCommits) Prototype() ipld.NodePrototype

+ func (Link__MinerV3SectorPreCommits) Type() schema.Type

+ func (n Link__MinerV3SectorPreCommits) AsLink() (ipld.Link, error)

+ func (n Link__MinerV3SectorPreCommits) Link() ipld.Link

+ func (n Link__MinerV3SectorPreCommits) Representation() ipld.Node

+ type Link__MinerV3State = *_Link__MinerV3State

+ func (Link__MinerV3State) AsBool() (bool, error)

+ func (Link__MinerV3State) AsBytes() ([]byte, error)

+ func (Link__MinerV3State) AsFloat() (float64, error)

+ func (Link__MinerV3State) AsInt() (int64, error)

+ func (Link__MinerV3State) AsString() (string, error)

+ func (Link__MinerV3State) IsAbsent() bool

+ func (Link__MinerV3State) IsNull() bool

+ func (Link__MinerV3State) Kind() ipld.Kind

+ func (Link__MinerV3State) Length() int64

+ func (Link__MinerV3State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV3State) ListIterator() ipld.ListIterator

+ func (Link__MinerV3State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV3State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV3State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV3State) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV3State) MapIterator() ipld.MapIterator

+ func (Link__MinerV3State) Prototype() ipld.NodePrototype

+ func (Link__MinerV3State) Type() schema.Type

+ func (n Link__MinerV3State) AsLink() (ipld.Link, error)

+ func (n Link__MinerV3State) Link() ipld.Link

+ func (n Link__MinerV3State) Representation() ipld.Node

+ type Link__MinerV4State = *_Link__MinerV4State

+ func (Link__MinerV4State) AsBool() (bool, error)

+ func (Link__MinerV4State) AsBytes() ([]byte, error)

+ func (Link__MinerV4State) AsFloat() (float64, error)

+ func (Link__MinerV4State) AsInt() (int64, error)

+ func (Link__MinerV4State) AsString() (string, error)

+ func (Link__MinerV4State) IsAbsent() bool

+ func (Link__MinerV4State) IsNull() bool

+ func (Link__MinerV4State) Kind() ipld.Kind

+ func (Link__MinerV4State) Length() int64

+ func (Link__MinerV4State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV4State) ListIterator() ipld.ListIterator

+ func (Link__MinerV4State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV4State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV4State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV4State) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV4State) MapIterator() ipld.MapIterator

+ func (Link__MinerV4State) Prototype() ipld.NodePrototype

+ func (Link__MinerV4State) Type() schema.Type

+ func (n Link__MinerV4State) AsLink() (ipld.Link, error)

+ func (n Link__MinerV4State) Link() ipld.Link

+ func (n Link__MinerV4State) Representation() ipld.Node

+ type Link__MinerV5State = *_Link__MinerV5State

+ func (Link__MinerV5State) AsBool() (bool, error)

+ func (Link__MinerV5State) AsBytes() ([]byte, error)

+ func (Link__MinerV5State) AsFloat() (float64, error)

+ func (Link__MinerV5State) AsInt() (int64, error)

+ func (Link__MinerV5State) AsString() (string, error)

+ func (Link__MinerV5State) IsAbsent() bool

+ func (Link__MinerV5State) IsNull() bool

+ func (Link__MinerV5State) Kind() ipld.Kind

+ func (Link__MinerV5State) Length() int64

+ func (Link__MinerV5State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MinerV5State) ListIterator() ipld.ListIterator

+ func (Link__MinerV5State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MinerV5State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MinerV5State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MinerV5State) LookupByString(string) (ipld.Node, error)

+ func (Link__MinerV5State) MapIterator() ipld.MapIterator

+ func (Link__MinerV5State) Prototype() ipld.NodePrototype

+ func (Link__MinerV5State) Type() schema.Type

+ func (n Link__MinerV5State) AsLink() (ipld.Link, error)

+ func (n Link__MinerV5State) Link() ipld.Link

+ func (n Link__MinerV5State) Representation() ipld.Node

+ type Link__MultimapDealID = *_Link__MultimapDealID

+ func (Link__MultimapDealID) AsBool() (bool, error)

+ func (Link__MultimapDealID) AsBytes() ([]byte, error)

+ func (Link__MultimapDealID) AsFloat() (float64, error)

+ func (Link__MultimapDealID) AsInt() (int64, error)

+ func (Link__MultimapDealID) AsString() (string, error)

+ func (Link__MultimapDealID) IsAbsent() bool

+ func (Link__MultimapDealID) IsNull() bool

+ func (Link__MultimapDealID) Kind() ipld.Kind

+ func (Link__MultimapDealID) Length() int64

+ func (Link__MultimapDealID) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MultimapDealID) ListIterator() ipld.ListIterator

+ func (Link__MultimapDealID) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MultimapDealID) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MultimapDealID) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MultimapDealID) LookupByString(string) (ipld.Node, error)

+ func (Link__MultimapDealID) MapIterator() ipld.MapIterator

+ func (Link__MultimapDealID) Prototype() ipld.NodePrototype

+ func (Link__MultimapDealID) Type() schema.Type

+ func (n Link__MultimapDealID) AsLink() (ipld.Link, error)

+ func (n Link__MultimapDealID) Link() ipld.Link

+ func (n Link__MultimapDealID) Representation() ipld.Node

+ type Link__MultisigV0State = *_Link__MultisigV0State

+ func (Link__MultisigV0State) AsBool() (bool, error)

+ func (Link__MultisigV0State) AsBytes() ([]byte, error)

+ func (Link__MultisigV0State) AsFloat() (float64, error)

+ func (Link__MultisigV0State) AsInt() (int64, error)

+ func (Link__MultisigV0State) AsString() (string, error)

+ func (Link__MultisigV0State) IsAbsent() bool

+ func (Link__MultisigV0State) IsNull() bool

+ func (Link__MultisigV0State) Kind() ipld.Kind

+ func (Link__MultisigV0State) Length() int64

+ func (Link__MultisigV0State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MultisigV0State) ListIterator() ipld.ListIterator

+ func (Link__MultisigV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MultisigV0State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MultisigV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MultisigV0State) LookupByString(string) (ipld.Node, error)

+ func (Link__MultisigV0State) MapIterator() ipld.MapIterator

+ func (Link__MultisigV0State) Prototype() ipld.NodePrototype

+ func (Link__MultisigV0State) Type() schema.Type

+ func (n Link__MultisigV0State) AsLink() (ipld.Link, error)

+ func (n Link__MultisigV0State) Link() ipld.Link

+ func (n Link__MultisigV0State) Representation() ipld.Node

+ type Link__MultisigV0Transaction = *_Link__MultisigV0Transaction

+ func (Link__MultisigV0Transaction) AsBool() (bool, error)

+ func (Link__MultisigV0Transaction) AsBytes() ([]byte, error)

+ func (Link__MultisigV0Transaction) AsFloat() (float64, error)

+ func (Link__MultisigV0Transaction) AsInt() (int64, error)

+ func (Link__MultisigV0Transaction) AsString() (string, error)

+ func (Link__MultisigV0Transaction) IsAbsent() bool

+ func (Link__MultisigV0Transaction) IsNull() bool

+ func (Link__MultisigV0Transaction) Kind() ipld.Kind

+ func (Link__MultisigV0Transaction) Length() int64

+ func (Link__MultisigV0Transaction) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MultisigV0Transaction) ListIterator() ipld.ListIterator

+ func (Link__MultisigV0Transaction) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MultisigV0Transaction) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MultisigV0Transaction) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MultisigV0Transaction) LookupByString(string) (ipld.Node, error)

+ func (Link__MultisigV0Transaction) MapIterator() ipld.MapIterator

+ func (Link__MultisigV0Transaction) Prototype() ipld.NodePrototype

+ func (Link__MultisigV0Transaction) Type() schema.Type

+ func (n Link__MultisigV0Transaction) AsLink() (ipld.Link, error)

+ func (n Link__MultisigV0Transaction) Link() ipld.Link

+ func (n Link__MultisigV0Transaction) Representation() ipld.Node

+ type Link__MultisigV3State = *_Link__MultisigV3State

+ func (Link__MultisigV3State) AsBool() (bool, error)

+ func (Link__MultisigV3State) AsBytes() ([]byte, error)

+ func (Link__MultisigV3State) AsFloat() (float64, error)

+ func (Link__MultisigV3State) AsInt() (int64, error)

+ func (Link__MultisigV3State) AsString() (string, error)

+ func (Link__MultisigV3State) IsAbsent() bool

+ func (Link__MultisigV3State) IsNull() bool

+ func (Link__MultisigV3State) Kind() ipld.Kind

+ func (Link__MultisigV3State) Length() int64

+ func (Link__MultisigV3State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MultisigV3State) ListIterator() ipld.ListIterator

+ func (Link__MultisigV3State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MultisigV3State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MultisigV3State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MultisigV3State) LookupByString(string) (ipld.Node, error)

+ func (Link__MultisigV3State) MapIterator() ipld.MapIterator

+ func (Link__MultisigV3State) Prototype() ipld.NodePrototype

+ func (Link__MultisigV3State) Type() schema.Type

+ func (n Link__MultisigV3State) AsLink() (ipld.Link, error)

+ func (n Link__MultisigV3State) Link() ipld.Link

+ func (n Link__MultisigV3State) Representation() ipld.Node

+ type Link__MultisigV3Transaction = *_Link__MultisigV3Transaction

+ func (Link__MultisigV3Transaction) AsBool() (bool, error)

+ func (Link__MultisigV3Transaction) AsBytes() ([]byte, error)

+ func (Link__MultisigV3Transaction) AsFloat() (float64, error)

+ func (Link__MultisigV3Transaction) AsInt() (int64, error)

+ func (Link__MultisigV3Transaction) AsString() (string, error)

+ func (Link__MultisigV3Transaction) IsAbsent() bool

+ func (Link__MultisigV3Transaction) IsNull() bool

+ func (Link__MultisigV3Transaction) Kind() ipld.Kind

+ func (Link__MultisigV3Transaction) Length() int64

+ func (Link__MultisigV3Transaction) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__MultisigV3Transaction) ListIterator() ipld.ListIterator

+ func (Link__MultisigV3Transaction) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__MultisigV3Transaction) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__MultisigV3Transaction) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__MultisigV3Transaction) LookupByString(string) (ipld.Node, error)

+ func (Link__MultisigV3Transaction) MapIterator() ipld.MapIterator

+ func (Link__MultisigV3Transaction) Prototype() ipld.NodePrototype

+ func (Link__MultisigV3Transaction) Type() schema.Type

+ func (n Link__MultisigV3Transaction) AsLink() (ipld.Link, error)

+ func (n Link__MultisigV3Transaction) Link() ipld.Link

+ func (n Link__MultisigV3Transaction) Representation() ipld.Node

+ type Link__PaychV0LaneState = *_Link__PaychV0LaneState

+ func (Link__PaychV0LaneState) AsBool() (bool, error)

+ func (Link__PaychV0LaneState) AsBytes() ([]byte, error)

+ func (Link__PaychV0LaneState) AsFloat() (float64, error)

+ func (Link__PaychV0LaneState) AsInt() (int64, error)

+ func (Link__PaychV0LaneState) AsString() (string, error)

+ func (Link__PaychV0LaneState) IsAbsent() bool

+ func (Link__PaychV0LaneState) IsNull() bool

+ func (Link__PaychV0LaneState) Kind() ipld.Kind

+ func (Link__PaychV0LaneState) Length() int64

+ func (Link__PaychV0LaneState) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__PaychV0LaneState) ListIterator() ipld.ListIterator

+ func (Link__PaychV0LaneState) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__PaychV0LaneState) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__PaychV0LaneState) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__PaychV0LaneState) LookupByString(string) (ipld.Node, error)

+ func (Link__PaychV0LaneState) MapIterator() ipld.MapIterator

+ func (Link__PaychV0LaneState) Prototype() ipld.NodePrototype

+ func (Link__PaychV0LaneState) Type() schema.Type

+ func (n Link__PaychV0LaneState) AsLink() (ipld.Link, error)

+ func (n Link__PaychV0LaneState) Link() ipld.Link

+ func (n Link__PaychV0LaneState) Representation() ipld.Node

+ type Link__PaychV0State = *_Link__PaychV0State

+ func (Link__PaychV0State) AsBool() (bool, error)

+ func (Link__PaychV0State) AsBytes() ([]byte, error)

+ func (Link__PaychV0State) AsFloat() (float64, error)

+ func (Link__PaychV0State) AsInt() (int64, error)

+ func (Link__PaychV0State) AsString() (string, error)

+ func (Link__PaychV0State) IsAbsent() bool

+ func (Link__PaychV0State) IsNull() bool

+ func (Link__PaychV0State) Kind() ipld.Kind

+ func (Link__PaychV0State) Length() int64

+ func (Link__PaychV0State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__PaychV0State) ListIterator() ipld.ListIterator

+ func (Link__PaychV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__PaychV0State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__PaychV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__PaychV0State) LookupByString(string) (ipld.Node, error)

+ func (Link__PaychV0State) MapIterator() ipld.MapIterator

+ func (Link__PaychV0State) Prototype() ipld.NodePrototype

+ func (Link__PaychV0State) Type() schema.Type

+ func (n Link__PaychV0State) AsLink() (ipld.Link, error)

+ func (n Link__PaychV0State) Link() ipld.Link

+ func (n Link__PaychV0State) Representation() ipld.Node

+ type Link__PaychV3LaneState = *_Link__PaychV3LaneState

+ func (Link__PaychV3LaneState) AsBool() (bool, error)

+ func (Link__PaychV3LaneState) AsBytes() ([]byte, error)

+ func (Link__PaychV3LaneState) AsFloat() (float64, error)

+ func (Link__PaychV3LaneState) AsInt() (int64, error)

+ func (Link__PaychV3LaneState) AsString() (string, error)

+ func (Link__PaychV3LaneState) IsAbsent() bool

+ func (Link__PaychV3LaneState) IsNull() bool

+ func (Link__PaychV3LaneState) Kind() ipld.Kind

+ func (Link__PaychV3LaneState) Length() int64

+ func (Link__PaychV3LaneState) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__PaychV3LaneState) ListIterator() ipld.ListIterator

+ func (Link__PaychV3LaneState) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__PaychV3LaneState) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__PaychV3LaneState) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__PaychV3LaneState) LookupByString(string) (ipld.Node, error)

+ func (Link__PaychV3LaneState) MapIterator() ipld.MapIterator

+ func (Link__PaychV3LaneState) Prototype() ipld.NodePrototype

+ func (Link__PaychV3LaneState) Type() schema.Type

+ func (n Link__PaychV3LaneState) AsLink() (ipld.Link, error)

+ func (n Link__PaychV3LaneState) Link() ipld.Link

+ func (n Link__PaychV3LaneState) Representation() ipld.Node

+ type Link__PaychV3State = *_Link__PaychV3State

+ func (Link__PaychV3State) AsBool() (bool, error)

+ func (Link__PaychV3State) AsBytes() ([]byte, error)

+ func (Link__PaychV3State) AsFloat() (float64, error)

+ func (Link__PaychV3State) AsInt() (int64, error)

+ func (Link__PaychV3State) AsString() (string, error)

+ func (Link__PaychV3State) IsAbsent() bool

+ func (Link__PaychV3State) IsNull() bool

+ func (Link__PaychV3State) Kind() ipld.Kind

+ func (Link__PaychV3State) Length() int64

+ func (Link__PaychV3State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__PaychV3State) ListIterator() ipld.ListIterator

+ func (Link__PaychV3State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__PaychV3State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__PaychV3State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__PaychV3State) LookupByString(string) (ipld.Node, error)

+ func (Link__PaychV3State) MapIterator() ipld.MapIterator

+ func (Link__PaychV3State) Prototype() ipld.NodePrototype

+ func (Link__PaychV3State) Type() schema.Type

+ func (n Link__PaychV3State) AsLink() (ipld.Link, error)

+ func (n Link__PaychV3State) Link() ipld.Link

+ func (n Link__PaychV3State) Representation() ipld.Node

+ type Link__PowerV0Claim = *_Link__PowerV0Claim

+ func (Link__PowerV0Claim) AsBool() (bool, error)

+ func (Link__PowerV0Claim) AsBytes() ([]byte, error)

+ func (Link__PowerV0Claim) AsFloat() (float64, error)

+ func (Link__PowerV0Claim) AsInt() (int64, error)

+ func (Link__PowerV0Claim) AsString() (string, error)

+ func (Link__PowerV0Claim) IsAbsent() bool

+ func (Link__PowerV0Claim) IsNull() bool

+ func (Link__PowerV0Claim) Kind() ipld.Kind

+ func (Link__PowerV0Claim) Length() int64

+ func (Link__PowerV0Claim) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__PowerV0Claim) ListIterator() ipld.ListIterator

+ func (Link__PowerV0Claim) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__PowerV0Claim) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__PowerV0Claim) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__PowerV0Claim) LookupByString(string) (ipld.Node, error)

+ func (Link__PowerV0Claim) MapIterator() ipld.MapIterator

+ func (Link__PowerV0Claim) Prototype() ipld.NodePrototype

+ func (Link__PowerV0Claim) Type() schema.Type

+ func (n Link__PowerV0Claim) AsLink() (ipld.Link, error)

+ func (n Link__PowerV0Claim) Link() ipld.Link

+ func (n Link__PowerV0Claim) Representation() ipld.Node

+ type Link__PowerV0CronEvent = *_Link__PowerV0CronEvent

+ func (Link__PowerV0CronEvent) AsBool() (bool, error)

+ func (Link__PowerV0CronEvent) AsBytes() ([]byte, error)

+ func (Link__PowerV0CronEvent) AsFloat() (float64, error)

+ func (Link__PowerV0CronEvent) AsInt() (int64, error)

+ func (Link__PowerV0CronEvent) AsString() (string, error)

+ func (Link__PowerV0CronEvent) IsAbsent() bool

+ func (Link__PowerV0CronEvent) IsNull() bool

+ func (Link__PowerV0CronEvent) Kind() ipld.Kind

+ func (Link__PowerV0CronEvent) Length() int64

+ func (Link__PowerV0CronEvent) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__PowerV0CronEvent) ListIterator() ipld.ListIterator

+ func (Link__PowerV0CronEvent) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__PowerV0CronEvent) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__PowerV0CronEvent) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__PowerV0CronEvent) LookupByString(string) (ipld.Node, error)

+ func (Link__PowerV0CronEvent) MapIterator() ipld.MapIterator

+ func (Link__PowerV0CronEvent) Prototype() ipld.NodePrototype

+ func (Link__PowerV0CronEvent) Type() schema.Type

+ func (n Link__PowerV0CronEvent) AsLink() (ipld.Link, error)

+ func (n Link__PowerV0CronEvent) Link() ipld.Link

+ func (n Link__PowerV0CronEvent) Representation() ipld.Node

+ type Link__PowerV0State = *_Link__PowerV0State

+ func (Link__PowerV0State) AsBool() (bool, error)

+ func (Link__PowerV0State) AsBytes() ([]byte, error)

+ func (Link__PowerV0State) AsFloat() (float64, error)

+ func (Link__PowerV0State) AsInt() (int64, error)

+ func (Link__PowerV0State) AsString() (string, error)

+ func (Link__PowerV0State) IsAbsent() bool

+ func (Link__PowerV0State) IsNull() bool

+ func (Link__PowerV0State) Kind() ipld.Kind

+ func (Link__PowerV0State) Length() int64

+ func (Link__PowerV0State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__PowerV0State) ListIterator() ipld.ListIterator

+ func (Link__PowerV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__PowerV0State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__PowerV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__PowerV0State) LookupByString(string) (ipld.Node, error)

+ func (Link__PowerV0State) MapIterator() ipld.MapIterator

+ func (Link__PowerV0State) Prototype() ipld.NodePrototype

+ func (Link__PowerV0State) Type() schema.Type

+ func (n Link__PowerV0State) AsLink() (ipld.Link, error)

+ func (n Link__PowerV0State) Link() ipld.Link

+ func (n Link__PowerV0State) Representation() ipld.Node

+ type Link__PowerV2Claim = *_Link__PowerV2Claim

+ func (Link__PowerV2Claim) AsBool() (bool, error)

+ func (Link__PowerV2Claim) AsBytes() ([]byte, error)

+ func (Link__PowerV2Claim) AsFloat() (float64, error)

+ func (Link__PowerV2Claim) AsInt() (int64, error)

+ func (Link__PowerV2Claim) AsString() (string, error)

+ func (Link__PowerV2Claim) IsAbsent() bool

+ func (Link__PowerV2Claim) IsNull() bool

+ func (Link__PowerV2Claim) Kind() ipld.Kind

+ func (Link__PowerV2Claim) Length() int64

+ func (Link__PowerV2Claim) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__PowerV2Claim) ListIterator() ipld.ListIterator

+ func (Link__PowerV2Claim) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__PowerV2Claim) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__PowerV2Claim) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__PowerV2Claim) LookupByString(string) (ipld.Node, error)

+ func (Link__PowerV2Claim) MapIterator() ipld.MapIterator

+ func (Link__PowerV2Claim) Prototype() ipld.NodePrototype

+ func (Link__PowerV2Claim) Type() schema.Type

+ func (n Link__PowerV2Claim) AsLink() (ipld.Link, error)

+ func (n Link__PowerV2Claim) Link() ipld.Link

+ func (n Link__PowerV2Claim) Representation() ipld.Node

+ type Link__PowerV2State = *_Link__PowerV2State

+ func (Link__PowerV2State) AsBool() (bool, error)

+ func (Link__PowerV2State) AsBytes() ([]byte, error)

+ func (Link__PowerV2State) AsFloat() (float64, error)

+ func (Link__PowerV2State) AsInt() (int64, error)

+ func (Link__PowerV2State) AsString() (string, error)

+ func (Link__PowerV2State) IsAbsent() bool

+ func (Link__PowerV2State) IsNull() bool

+ func (Link__PowerV2State) Kind() ipld.Kind

+ func (Link__PowerV2State) Length() int64

+ func (Link__PowerV2State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__PowerV2State) ListIterator() ipld.ListIterator

+ func (Link__PowerV2State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__PowerV2State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__PowerV2State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__PowerV2State) LookupByString(string) (ipld.Node, error)

+ func (Link__PowerV2State) MapIterator() ipld.MapIterator

+ func (Link__PowerV2State) Prototype() ipld.NodePrototype

+ func (Link__PowerV2State) Type() schema.Type

+ func (n Link__PowerV2State) AsLink() (ipld.Link, error)

+ func (n Link__PowerV2State) Link() ipld.Link

+ func (n Link__PowerV2State) Representation() ipld.Node

+ type Link__PowerV3Claim = *_Link__PowerV3Claim

+ func (Link__PowerV3Claim) AsBool() (bool, error)

+ func (Link__PowerV3Claim) AsBytes() ([]byte, error)

+ func (Link__PowerV3Claim) AsFloat() (float64, error)

+ func (Link__PowerV3Claim) AsInt() (int64, error)

+ func (Link__PowerV3Claim) AsString() (string, error)

+ func (Link__PowerV3Claim) IsAbsent() bool

+ func (Link__PowerV3Claim) IsNull() bool

+ func (Link__PowerV3Claim) Kind() ipld.Kind

+ func (Link__PowerV3Claim) Length() int64

+ func (Link__PowerV3Claim) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__PowerV3Claim) ListIterator() ipld.ListIterator

+ func (Link__PowerV3Claim) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__PowerV3Claim) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__PowerV3Claim) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__PowerV3Claim) LookupByString(string) (ipld.Node, error)

+ func (Link__PowerV3Claim) MapIterator() ipld.MapIterator

+ func (Link__PowerV3Claim) Prototype() ipld.NodePrototype

+ func (Link__PowerV3Claim) Type() schema.Type

+ func (n Link__PowerV3Claim) AsLink() (ipld.Link, error)

+ func (n Link__PowerV3Claim) Link() ipld.Link

+ func (n Link__PowerV3Claim) Representation() ipld.Node

+ type Link__PowerV3CronEvent = *_Link__PowerV3CronEvent

+ func (Link__PowerV3CronEvent) AsBool() (bool, error)

+ func (Link__PowerV3CronEvent) AsBytes() ([]byte, error)

+ func (Link__PowerV3CronEvent) AsFloat() (float64, error)

+ func (Link__PowerV3CronEvent) AsInt() (int64, error)

+ func (Link__PowerV3CronEvent) AsString() (string, error)

+ func (Link__PowerV3CronEvent) IsAbsent() bool

+ func (Link__PowerV3CronEvent) IsNull() bool

+ func (Link__PowerV3CronEvent) Kind() ipld.Kind

+ func (Link__PowerV3CronEvent) Length() int64

+ func (Link__PowerV3CronEvent) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__PowerV3CronEvent) ListIterator() ipld.ListIterator

+ func (Link__PowerV3CronEvent) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__PowerV3CronEvent) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__PowerV3CronEvent) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__PowerV3CronEvent) LookupByString(string) (ipld.Node, error)

+ func (Link__PowerV3CronEvent) MapIterator() ipld.MapIterator

+ func (Link__PowerV3CronEvent) Prototype() ipld.NodePrototype

+ func (Link__PowerV3CronEvent) Type() schema.Type

+ func (n Link__PowerV3CronEvent) AsLink() (ipld.Link, error)

+ func (n Link__PowerV3CronEvent) Link() ipld.Link

+ func (n Link__PowerV3CronEvent) Representation() ipld.Node

+ type Link__PowerV3State = *_Link__PowerV3State

+ func (Link__PowerV3State) AsBool() (bool, error)

+ func (Link__PowerV3State) AsBytes() ([]byte, error)

+ func (Link__PowerV3State) AsFloat() (float64, error)

+ func (Link__PowerV3State) AsInt() (int64, error)

+ func (Link__PowerV3State) AsString() (string, error)

+ func (Link__PowerV3State) IsAbsent() bool

+ func (Link__PowerV3State) IsNull() bool

+ func (Link__PowerV3State) Kind() ipld.Kind

+ func (Link__PowerV3State) Length() int64

+ func (Link__PowerV3State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__PowerV3State) ListIterator() ipld.ListIterator

+ func (Link__PowerV3State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__PowerV3State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__PowerV3State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__PowerV3State) LookupByString(string) (ipld.Node, error)

+ func (Link__PowerV3State) MapIterator() ipld.MapIterator

+ func (Link__PowerV3State) Prototype() ipld.NodePrototype

+ func (Link__PowerV3State) Type() schema.Type

+ func (n Link__PowerV3State) AsLink() (ipld.Link, error)

+ func (n Link__PowerV3State) Link() ipld.Link

+ func (n Link__PowerV3State) Representation() ipld.Node

+ type Link__RewardV0State = *_Link__RewardV0State

+ func (Link__RewardV0State) AsBool() (bool, error)

+ func (Link__RewardV0State) AsBytes() ([]byte, error)

+ func (Link__RewardV0State) AsFloat() (float64, error)

+ func (Link__RewardV0State) AsInt() (int64, error)

+ func (Link__RewardV0State) AsString() (string, error)

+ func (Link__RewardV0State) IsAbsent() bool

+ func (Link__RewardV0State) IsNull() bool

+ func (Link__RewardV0State) Kind() ipld.Kind

+ func (Link__RewardV0State) Length() int64

+ func (Link__RewardV0State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__RewardV0State) ListIterator() ipld.ListIterator

+ func (Link__RewardV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__RewardV0State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__RewardV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__RewardV0State) LookupByString(string) (ipld.Node, error)

+ func (Link__RewardV0State) MapIterator() ipld.MapIterator

+ func (Link__RewardV0State) Prototype() ipld.NodePrototype

+ func (Link__RewardV0State) Type() schema.Type

+ func (n Link__RewardV0State) AsLink() (ipld.Link, error)

+ func (n Link__RewardV0State) Link() ipld.Link

+ func (n Link__RewardV0State) Representation() ipld.Node

+ type Link__RewardV2State = *_Link__RewardV2State

+ func (Link__RewardV2State) AsBool() (bool, error)

+ func (Link__RewardV2State) AsBytes() ([]byte, error)

+ func (Link__RewardV2State) AsFloat() (float64, error)

+ func (Link__RewardV2State) AsInt() (int64, error)

+ func (Link__RewardV2State) AsString() (string, error)

+ func (Link__RewardV2State) IsAbsent() bool

+ func (Link__RewardV2State) IsNull() bool

+ func (Link__RewardV2State) Kind() ipld.Kind

+ func (Link__RewardV2State) Length() int64

+ func (Link__RewardV2State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__RewardV2State) ListIterator() ipld.ListIterator

+ func (Link__RewardV2State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__RewardV2State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__RewardV2State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__RewardV2State) LookupByString(string) (ipld.Node, error)

+ func (Link__RewardV2State) MapIterator() ipld.MapIterator

+ func (Link__RewardV2State) Prototype() ipld.NodePrototype

+ func (Link__RewardV2State) Type() schema.Type

+ func (n Link__RewardV2State) AsLink() (ipld.Link, error)

+ func (n Link__RewardV2State) Link() ipld.Link

+ func (n Link__RewardV2State) Representation() ipld.Node

+ type Link__V3BalanceTable = *_Link__V3BalanceTable

+ func (Link__V3BalanceTable) AsBool() (bool, error)

+ func (Link__V3BalanceTable) AsBytes() ([]byte, error)

+ func (Link__V3BalanceTable) AsFloat() (float64, error)

+ func (Link__V3BalanceTable) AsInt() (int64, error)

+ func (Link__V3BalanceTable) AsString() (string, error)

+ func (Link__V3BalanceTable) IsAbsent() bool

+ func (Link__V3BalanceTable) IsNull() bool

+ func (Link__V3BalanceTable) Kind() ipld.Kind

+ func (Link__V3BalanceTable) Length() int64

+ func (Link__V3BalanceTable) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__V3BalanceTable) ListIterator() ipld.ListIterator

+ func (Link__V3BalanceTable) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__V3BalanceTable) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__V3BalanceTable) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__V3BalanceTable) LookupByString(string) (ipld.Node, error)

+ func (Link__V3BalanceTable) MapIterator() ipld.MapIterator

+ func (Link__V3BalanceTable) Prototype() ipld.NodePrototype

+ func (Link__V3BalanceTable) Type() schema.Type

+ func (n Link__V3BalanceTable) AsLink() (ipld.Link, error)

+ func (n Link__V3BalanceTable) Link() ipld.Link

+ func (n Link__V3BalanceTable) Representation() ipld.Node

+ type Link__V3DataCap = *_Link__V3DataCap

+ func (Link__V3DataCap) AsBool() (bool, error)

+ func (Link__V3DataCap) AsBytes() ([]byte, error)

+ func (Link__V3DataCap) AsFloat() (float64, error)

+ func (Link__V3DataCap) AsInt() (int64, error)

+ func (Link__V3DataCap) AsString() (string, error)

+ func (Link__V3DataCap) IsAbsent() bool

+ func (Link__V3DataCap) IsNull() bool

+ func (Link__V3DataCap) Kind() ipld.Kind

+ func (Link__V3DataCap) Length() int64

+ func (Link__V3DataCap) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__V3DataCap) ListIterator() ipld.ListIterator

+ func (Link__V3DataCap) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__V3DataCap) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__V3DataCap) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__V3DataCap) LookupByString(string) (ipld.Node, error)

+ func (Link__V3DataCap) MapIterator() ipld.MapIterator

+ func (Link__V3DataCap) Prototype() ipld.NodePrototype

+ func (Link__V3DataCap) Type() schema.Type

+ func (n Link__V3DataCap) AsLink() (ipld.Link, error)

+ func (n Link__V3DataCap) Link() ipld.Link

+ func (n Link__V3DataCap) Representation() ipld.Node

+ type Link__V3MapActorID = *_Link__V3MapActorID

+ func (Link__V3MapActorID) AsBool() (bool, error)

+ func (Link__V3MapActorID) AsBytes() ([]byte, error)

+ func (Link__V3MapActorID) AsFloat() (float64, error)

+ func (Link__V3MapActorID) AsInt() (int64, error)

+ func (Link__V3MapActorID) AsString() (string, error)

+ func (Link__V3MapActorID) IsAbsent() bool

+ func (Link__V3MapActorID) IsNull() bool

+ func (Link__V3MapActorID) Kind() ipld.Kind

+ func (Link__V3MapActorID) Length() int64

+ func (Link__V3MapActorID) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__V3MapActorID) ListIterator() ipld.ListIterator

+ func (Link__V3MapActorID) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__V3MapActorID) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__V3MapActorID) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__V3MapActorID) LookupByString(string) (ipld.Node, error)

+ func (Link__V3MapActorID) MapIterator() ipld.MapIterator

+ func (Link__V3MapActorID) Prototype() ipld.NodePrototype

+ func (Link__V3MapActorID) Type() schema.Type

+ func (n Link__V3MapActorID) AsLink() (ipld.Link, error)

+ func (n Link__V3MapActorID) Link() ipld.Link

+ func (n Link__V3MapActorID) Representation() ipld.Node

+ type Link__VerifregV0State = *_Link__VerifregV0State

+ func (Link__VerifregV0State) AsBool() (bool, error)

+ func (Link__VerifregV0State) AsBytes() ([]byte, error)

+ func (Link__VerifregV0State) AsFloat() (float64, error)

+ func (Link__VerifregV0State) AsInt() (int64, error)

+ func (Link__VerifregV0State) AsString() (string, error)

+ func (Link__VerifregV0State) IsAbsent() bool

+ func (Link__VerifregV0State) IsNull() bool

+ func (Link__VerifregV0State) Kind() ipld.Kind

+ func (Link__VerifregV0State) Length() int64

+ func (Link__VerifregV0State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__VerifregV0State) ListIterator() ipld.ListIterator

+ func (Link__VerifregV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__VerifregV0State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__VerifregV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__VerifregV0State) LookupByString(string) (ipld.Node, error)

+ func (Link__VerifregV0State) MapIterator() ipld.MapIterator

+ func (Link__VerifregV0State) Prototype() ipld.NodePrototype

+ func (Link__VerifregV0State) Type() schema.Type

+ func (n Link__VerifregV0State) AsLink() (ipld.Link, error)

+ func (n Link__VerifregV0State) Link() ipld.Link

+ func (n Link__VerifregV0State) Representation() ipld.Node

+ type Link__VerifregV3State = *_Link__VerifregV3State

+ func (Link__VerifregV3State) AsBool() (bool, error)

+ func (Link__VerifregV3State) AsBytes() ([]byte, error)

+ func (Link__VerifregV3State) AsFloat() (float64, error)

+ func (Link__VerifregV3State) AsInt() (int64, error)

+ func (Link__VerifregV3State) AsString() (string, error)

+ func (Link__VerifregV3State) IsAbsent() bool

+ func (Link__VerifregV3State) IsNull() bool

+ func (Link__VerifregV3State) Kind() ipld.Kind

+ func (Link__VerifregV3State) Length() int64

+ func (Link__VerifregV3State) LinkTargetNodePrototype() ipld.NodePrototype

+ func (Link__VerifregV3State) ListIterator() ipld.ListIterator

+ func (Link__VerifregV3State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Link__VerifregV3State) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Link__VerifregV3State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Link__VerifregV3State) LookupByString(string) (ipld.Node, error)

+ func (Link__VerifregV3State) MapIterator() ipld.MapIterator

+ func (Link__VerifregV3State) Prototype() ipld.NodePrototype

+ func (Link__VerifregV3State) Type() schema.Type

+ func (n Link__VerifregV3State) AsLink() (ipld.Link, error)

+ func (n Link__VerifregV3State) Link() ipld.Link

+ func (n Link__VerifregV3State) Representation() ipld.Node

+ type List = *_List

+ func (List) AsBool() (bool, error)

+ func (List) AsBytes() ([]byte, error)

+ func (List) AsFloat() (float64, error)

+ func (List) AsInt() (int64, error)

+ func (List) AsLink() (ipld.Link, error)

+ func (List) AsString() (string, error)

+ func (List) IsAbsent() bool

+ func (List) IsNull() bool

+ func (List) Kind() ipld.Kind

+ func (List) LookupByString(string) (ipld.Node, error)

+ func (List) MapIterator() ipld.MapIterator

+ func (List) Prototype() ipld.NodePrototype

+ func (List) Type() schema.Type

+ func (n List) Iterator() *List__Itr

+ func (n List) Length() int64

+ func (n List) ListIterator() ipld.ListIterator

+ func (n List) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List) Representation() ipld.Node

+ type List__Address = *_List__Address

+ func (List__Address) AsBool() (bool, error)

+ func (List__Address) AsBytes() ([]byte, error)

+ func (List__Address) AsFloat() (float64, error)

+ func (List__Address) AsInt() (int64, error)

+ func (List__Address) AsLink() (ipld.Link, error)

+ func (List__Address) AsString() (string, error)

+ func (List__Address) IsAbsent() bool

+ func (List__Address) IsNull() bool

+ func (List__Address) Kind() ipld.Kind

+ func (List__Address) LookupByString(string) (ipld.Node, error)

+ func (List__Address) MapIterator() ipld.MapIterator

+ func (List__Address) Prototype() ipld.NodePrototype

+ func (List__Address) Type() schema.Type

+ func (n List__Address) Iterator() *List__Address__Itr

+ func (n List__Address) Length() int64

+ func (n List__Address) ListIterator() ipld.ListIterator

+ func (n List__Address) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__Address) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__Address) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__Address) Representation() ipld.Node

+ type List__Address__Itr struct

+ func (itr *List__Address__Itr) Done() bool

+ func (itr *List__Address__Itr) Next() (idx int64, v MaybeAddress)

+ type List__ClientDealProposal = *_List__ClientDealProposal

+ func (List__ClientDealProposal) AsBool() (bool, error)

+ func (List__ClientDealProposal) AsBytes() ([]byte, error)

+ func (List__ClientDealProposal) AsFloat() (float64, error)

+ func (List__ClientDealProposal) AsInt() (int64, error)

+ func (List__ClientDealProposal) AsLink() (ipld.Link, error)

+ func (List__ClientDealProposal) AsString() (string, error)

+ func (List__ClientDealProposal) IsAbsent() bool

+ func (List__ClientDealProposal) IsNull() bool

+ func (List__ClientDealProposal) Kind() ipld.Kind

+ func (List__ClientDealProposal) LookupByString(string) (ipld.Node, error)

+ func (List__ClientDealProposal) MapIterator() ipld.MapIterator

+ func (List__ClientDealProposal) Prototype() ipld.NodePrototype

+ func (List__ClientDealProposal) Type() schema.Type

+ func (n List__ClientDealProposal) Iterator() *List__ClientDealProposal__Itr

+ func (n List__ClientDealProposal) Length() int64

+ func (n List__ClientDealProposal) ListIterator() ipld.ListIterator

+ func (n List__ClientDealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__ClientDealProposal) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__ClientDealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__ClientDealProposal) Representation() ipld.Node

+ type List__ClientDealProposal__Itr struct

+ func (itr *List__ClientDealProposal__Itr) Done() bool

+ func (itr *List__ClientDealProposal__Itr) Next() (idx int64, v MarketClientDealProposal)

+ type List__CronV0Entry = *_List__CronV0Entry

+ func (List__CronV0Entry) AsBool() (bool, error)

+ func (List__CronV0Entry) AsBytes() ([]byte, error)

+ func (List__CronV0Entry) AsFloat() (float64, error)

+ func (List__CronV0Entry) AsInt() (int64, error)

+ func (List__CronV0Entry) AsLink() (ipld.Link, error)

+ func (List__CronV0Entry) AsString() (string, error)

+ func (List__CronV0Entry) IsAbsent() bool

+ func (List__CronV0Entry) IsNull() bool

+ func (List__CronV0Entry) Kind() ipld.Kind

+ func (List__CronV0Entry) LookupByString(string) (ipld.Node, error)

+ func (List__CronV0Entry) MapIterator() ipld.MapIterator

+ func (List__CronV0Entry) Prototype() ipld.NodePrototype

+ func (List__CronV0Entry) Type() schema.Type

+ func (n List__CronV0Entry) Iterator() *List__CronV0Entry__Itr

+ func (n List__CronV0Entry) Length() int64

+ func (n List__CronV0Entry) ListIterator() ipld.ListIterator

+ func (n List__CronV0Entry) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__CronV0Entry) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__CronV0Entry) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__CronV0Entry) Representation() ipld.Node

+ type List__CronV0Entry__Itr struct

+ func (itr *List__CronV0Entry__Itr) Done() bool

+ func (itr *List__CronV0Entry__Itr) Next() (idx int64, v CronV0Entry)

+ type List__DealID = *_List__DealID

+ func (List__DealID) AsBool() (bool, error)

+ func (List__DealID) AsBytes() ([]byte, error)

+ func (List__DealID) AsFloat() (float64, error)

+ func (List__DealID) AsInt() (int64, error)

+ func (List__DealID) AsLink() (ipld.Link, error)

+ func (List__DealID) AsString() (string, error)

+ func (List__DealID) IsAbsent() bool

+ func (List__DealID) IsNull() bool

+ func (List__DealID) Kind() ipld.Kind

+ func (List__DealID) LookupByString(string) (ipld.Node, error)

+ func (List__DealID) MapIterator() ipld.MapIterator

+ func (List__DealID) Prototype() ipld.NodePrototype

+ func (List__DealID) Type() schema.Type

+ func (n List__DealID) Iterator() *List__DealID__Itr

+ func (n List__DealID) Length() int64

+ func (n List__DealID) ListIterator() ipld.ListIterator

+ func (n List__DealID) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__DealID) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__DealID) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__DealID) Representation() ipld.Node

+ type List__DealID__Itr struct

+ func (itr *List__DealID__Itr) Done() bool

+ func (itr *List__DealID__Itr) Next() (idx int64, v MaybeDealID)

+ type List__Itr struct

+ func (itr *List__Itr) Done() bool

+ func (itr *List__Itr) Next() (idx int64, v MaybeAny)

+ type List__Link = *_List__Link

+ func (List__Link) AsBool() (bool, error)

+ func (List__Link) AsBytes() ([]byte, error)

+ func (List__Link) AsFloat() (float64, error)

+ func (List__Link) AsInt() (int64, error)

+ func (List__Link) AsLink() (ipld.Link, error)

+ func (List__Link) AsString() (string, error)

+ func (List__Link) IsAbsent() bool

+ func (List__Link) IsNull() bool

+ func (List__Link) Kind() ipld.Kind

+ func (List__Link) LookupByString(string) (ipld.Node, error)

+ func (List__Link) MapIterator() ipld.MapIterator

+ func (List__Link) Prototype() ipld.NodePrototype

+ func (List__Link) Type() schema.Type

+ func (n List__Link) Iterator() *List__Link__Itr

+ func (n List__Link) Length() int64

+ func (n List__Link) ListIterator() ipld.ListIterator

+ func (n List__Link) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__Link) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__Link) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__Link) Representation() ipld.Node

+ type List__LinkLotusMessage = *_List__LinkLotusMessage

+ func (List__LinkLotusMessage) AsBool() (bool, error)

+ func (List__LinkLotusMessage) AsBytes() ([]byte, error)

+ func (List__LinkLotusMessage) AsFloat() (float64, error)

+ func (List__LinkLotusMessage) AsInt() (int64, error)

+ func (List__LinkLotusMessage) AsLink() (ipld.Link, error)

+ func (List__LinkLotusMessage) AsString() (string, error)

+ func (List__LinkLotusMessage) IsAbsent() bool

+ func (List__LinkLotusMessage) IsNull() bool

+ func (List__LinkLotusMessage) Kind() ipld.Kind

+ func (List__LinkLotusMessage) LookupByString(string) (ipld.Node, error)

+ func (List__LinkLotusMessage) MapIterator() ipld.MapIterator

+ func (List__LinkLotusMessage) Prototype() ipld.NodePrototype

+ func (List__LinkLotusMessage) Type() schema.Type

+ func (n List__LinkLotusMessage) Iterator() *List__LinkLotusMessage__Itr

+ func (n List__LinkLotusMessage) Length() int64

+ func (n List__LinkLotusMessage) ListIterator() ipld.ListIterator

+ func (n List__LinkLotusMessage) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__LinkLotusMessage) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__LinkLotusMessage) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__LinkLotusMessage) Representation() ipld.Node

+ type List__LinkLotusMessage__Itr struct

+ func (itr *List__LinkLotusMessage__Itr) Done() bool

+ func (itr *List__LinkLotusMessage__Itr) Next() (idx int64, v Link__LotusMessage)

+ type List__Link__Itr struct

+ func (itr *List__Link__Itr) Done() bool

+ func (itr *List__Link__Itr) Next() (idx int64, v MaybeLink)

+ type List__LotusBeaconEntry = *_List__LotusBeaconEntry

+ func (List__LotusBeaconEntry) AsBool() (bool, error)

+ func (List__LotusBeaconEntry) AsBytes() ([]byte, error)

+ func (List__LotusBeaconEntry) AsFloat() (float64, error)

+ func (List__LotusBeaconEntry) AsInt() (int64, error)

+ func (List__LotusBeaconEntry) AsLink() (ipld.Link, error)

+ func (List__LotusBeaconEntry) AsString() (string, error)

+ func (List__LotusBeaconEntry) IsAbsent() bool

+ func (List__LotusBeaconEntry) IsNull() bool

+ func (List__LotusBeaconEntry) Kind() ipld.Kind

+ func (List__LotusBeaconEntry) LookupByString(string) (ipld.Node, error)

+ func (List__LotusBeaconEntry) MapIterator() ipld.MapIterator

+ func (List__LotusBeaconEntry) Prototype() ipld.NodePrototype

+ func (List__LotusBeaconEntry) Type() schema.Type

+ func (n List__LotusBeaconEntry) Iterator() *List__LotusBeaconEntry__Itr

+ func (n List__LotusBeaconEntry) Length() int64

+ func (n List__LotusBeaconEntry) ListIterator() ipld.ListIterator

+ func (n List__LotusBeaconEntry) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__LotusBeaconEntry) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__LotusBeaconEntry) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__LotusBeaconEntry) Representation() ipld.Node

+ type List__LotusBeaconEntry__Itr struct

+ func (itr *List__LotusBeaconEntry__Itr) Done() bool

+ func (itr *List__LotusBeaconEntry__Itr) Next() (idx int64, v MaybeLotusBeaconEntry)

+ type List__Merge = *_List__Merge

+ func (List__Merge) AsBool() (bool, error)

+ func (List__Merge) AsBytes() ([]byte, error)

+ func (List__Merge) AsFloat() (float64, error)

+ func (List__Merge) AsInt() (int64, error)

+ func (List__Merge) AsLink() (ipld.Link, error)

+ func (List__Merge) AsString() (string, error)

+ func (List__Merge) IsAbsent() bool

+ func (List__Merge) IsNull() bool

+ func (List__Merge) Kind() ipld.Kind

+ func (List__Merge) LookupByString(string) (ipld.Node, error)

+ func (List__Merge) MapIterator() ipld.MapIterator

+ func (List__Merge) Prototype() ipld.NodePrototype

+ func (List__Merge) Type() schema.Type

+ func (n List__Merge) Iterator() *List__Merge__Itr

+ func (n List__Merge) Length() int64

+ func (n List__Merge) ListIterator() ipld.ListIterator

+ func (n List__Merge) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__Merge) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__Merge) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__Merge) Representation() ipld.Node

+ type List__Merge__Itr struct

+ func (itr *List__Merge__Itr) Done() bool

+ func (itr *List__Merge__Itr) Next() (idx int64, v Merge)

+ type List__MinerExpirationExtend = *_List__MinerExpirationExtend

+ func (List__MinerExpirationExtend) AsBool() (bool, error)

+ func (List__MinerExpirationExtend) AsBytes() ([]byte, error)

+ func (List__MinerExpirationExtend) AsFloat() (float64, error)

+ func (List__MinerExpirationExtend) AsInt() (int64, error)

+ func (List__MinerExpirationExtend) AsLink() (ipld.Link, error)

+ func (List__MinerExpirationExtend) AsString() (string, error)

+ func (List__MinerExpirationExtend) IsAbsent() bool

+ func (List__MinerExpirationExtend) IsNull() bool

+ func (List__MinerExpirationExtend) Kind() ipld.Kind

+ func (List__MinerExpirationExtend) LookupByString(string) (ipld.Node, error)

+ func (List__MinerExpirationExtend) MapIterator() ipld.MapIterator

+ func (List__MinerExpirationExtend) Prototype() ipld.NodePrototype

+ func (List__MinerExpirationExtend) Type() schema.Type

+ func (n List__MinerExpirationExtend) Iterator() *List__MinerExpirationExtend__Itr

+ func (n List__MinerExpirationExtend) Length() int64

+ func (n List__MinerExpirationExtend) ListIterator() ipld.ListIterator

+ func (n List__MinerExpirationExtend) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__MinerExpirationExtend) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__MinerExpirationExtend) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__MinerExpirationExtend) Representation() ipld.Node

+ type List__MinerExpirationExtend__Itr struct

+ func (itr *List__MinerExpirationExtend__Itr) Done() bool

+ func (itr *List__MinerExpirationExtend__Itr) Next() (idx int64, v MinerExpirationExtend)

+ type List__MinerPoStProof = *_List__MinerPoStProof

+ func (List__MinerPoStProof) AsBool() (bool, error)

+ func (List__MinerPoStProof) AsBytes() ([]byte, error)

+ func (List__MinerPoStProof) AsFloat() (float64, error)

+ func (List__MinerPoStProof) AsInt() (int64, error)

+ func (List__MinerPoStProof) AsLink() (ipld.Link, error)

+ func (List__MinerPoStProof) AsString() (string, error)

+ func (List__MinerPoStProof) IsAbsent() bool

+ func (List__MinerPoStProof) IsNull() bool

+ func (List__MinerPoStProof) Kind() ipld.Kind

+ func (List__MinerPoStProof) LookupByString(string) (ipld.Node, error)

+ func (List__MinerPoStProof) MapIterator() ipld.MapIterator

+ func (List__MinerPoStProof) Prototype() ipld.NodePrototype

+ func (List__MinerPoStProof) Type() schema.Type

+ func (n List__MinerPoStProof) Iterator() *List__MinerPoStProof__Itr

+ func (n List__MinerPoStProof) Length() int64

+ func (n List__MinerPoStProof) ListIterator() ipld.ListIterator

+ func (n List__MinerPoStProof) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__MinerPoStProof) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__MinerPoStProof) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__MinerPoStProof) Representation() ipld.Node

+ type List__MinerPoStProof__Itr struct

+ func (itr *List__MinerPoStProof__Itr) Done() bool

+ func (itr *List__MinerPoStProof__Itr) Next() (idx int64, v MinerPostProof)

+ type List__MinerPostPartition = *_List__MinerPostPartition

+ func (List__MinerPostPartition) AsBool() (bool, error)

+ func (List__MinerPostPartition) AsBytes() ([]byte, error)

+ func (List__MinerPostPartition) AsFloat() (float64, error)

+ func (List__MinerPostPartition) AsInt() (int64, error)

+ func (List__MinerPostPartition) AsLink() (ipld.Link, error)

+ func (List__MinerPostPartition) AsString() (string, error)

+ func (List__MinerPostPartition) IsAbsent() bool

+ func (List__MinerPostPartition) IsNull() bool

+ func (List__MinerPostPartition) Kind() ipld.Kind

+ func (List__MinerPostPartition) LookupByString(string) (ipld.Node, error)

+ func (List__MinerPostPartition) MapIterator() ipld.MapIterator

+ func (List__MinerPostPartition) Prototype() ipld.NodePrototype

+ func (List__MinerPostPartition) Type() schema.Type

+ func (n List__MinerPostPartition) Iterator() *List__MinerPostPartition__Itr

+ func (n List__MinerPostPartition) Length() int64

+ func (n List__MinerPostPartition) ListIterator() ipld.ListIterator

+ func (n List__MinerPostPartition) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__MinerPostPartition) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__MinerPostPartition) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__MinerPostPartition) Representation() ipld.Node

+ type List__MinerPostPartition__Itr struct

+ func (itr *List__MinerPostPartition__Itr) Done() bool

+ func (itr *List__MinerPostPartition__Itr) Next() (idx int64, v MinerPostPartition)

+ type List__MinerTerminationDecl = *_List__MinerTerminationDecl

+ func (List__MinerTerminationDecl) AsBool() (bool, error)

+ func (List__MinerTerminationDecl) AsBytes() ([]byte, error)

+ func (List__MinerTerminationDecl) AsFloat() (float64, error)

+ func (List__MinerTerminationDecl) AsInt() (int64, error)

+ func (List__MinerTerminationDecl) AsLink() (ipld.Link, error)

+ func (List__MinerTerminationDecl) AsString() (string, error)

+ func (List__MinerTerminationDecl) IsAbsent() bool

+ func (List__MinerTerminationDecl) IsNull() bool

+ func (List__MinerTerminationDecl) Kind() ipld.Kind

+ func (List__MinerTerminationDecl) LookupByString(string) (ipld.Node, error)

+ func (List__MinerTerminationDecl) MapIterator() ipld.MapIterator

+ func (List__MinerTerminationDecl) Prototype() ipld.NodePrototype

+ func (List__MinerTerminationDecl) Type() schema.Type

+ func (n List__MinerTerminationDecl) Iterator() *List__MinerTerminationDecl__Itr

+ func (n List__MinerTerminationDecl) Length() int64

+ func (n List__MinerTerminationDecl) ListIterator() ipld.ListIterator

+ func (n List__MinerTerminationDecl) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__MinerTerminationDecl) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__MinerTerminationDecl) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__MinerTerminationDecl) Representation() ipld.Node

+ type List__MinerTerminationDecl__Itr struct

+ func (itr *List__MinerTerminationDecl__Itr) Done() bool

+ func (itr *List__MinerTerminationDecl__Itr) Next() (idx int64, v MinerTerminationDecl)

+ type List__MinerV0DeadlineLink = *_List__MinerV0DeadlineLink

+ func (List__MinerV0DeadlineLink) AsBool() (bool, error)

+ func (List__MinerV0DeadlineLink) AsBytes() ([]byte, error)

+ func (List__MinerV0DeadlineLink) AsFloat() (float64, error)

+ func (List__MinerV0DeadlineLink) AsInt() (int64, error)

+ func (List__MinerV0DeadlineLink) AsLink() (ipld.Link, error)

+ func (List__MinerV0DeadlineLink) AsString() (string, error)

+ func (List__MinerV0DeadlineLink) IsAbsent() bool

+ func (List__MinerV0DeadlineLink) IsNull() bool

+ func (List__MinerV0DeadlineLink) Kind() ipld.Kind

+ func (List__MinerV0DeadlineLink) LookupByString(string) (ipld.Node, error)

+ func (List__MinerV0DeadlineLink) MapIterator() ipld.MapIterator

+ func (List__MinerV0DeadlineLink) Prototype() ipld.NodePrototype

+ func (List__MinerV0DeadlineLink) Type() schema.Type

+ func (n List__MinerV0DeadlineLink) Iterator() *List__MinerV0DeadlineLink__Itr

+ func (n List__MinerV0DeadlineLink) Length() int64

+ func (n List__MinerV0DeadlineLink) ListIterator() ipld.ListIterator

+ func (n List__MinerV0DeadlineLink) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__MinerV0DeadlineLink) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__MinerV0DeadlineLink) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__MinerV0DeadlineLink) Representation() ipld.Node

+ type List__MinerV0DeadlineLink__Itr struct

+ func (itr *List__MinerV0DeadlineLink__Itr) Done() bool

+ func (itr *List__MinerV0DeadlineLink__Itr) Next() (idx int64, v MaybeLink__MinerV0Deadline)

+ type List__MinerV0SectorPreCommitInfo = *_List__MinerV0SectorPreCommitInfo

+ func (List__MinerV0SectorPreCommitInfo) AsBool() (bool, error)

+ func (List__MinerV0SectorPreCommitInfo) AsBytes() ([]byte, error)

+ func (List__MinerV0SectorPreCommitInfo) AsFloat() (float64, error)

+ func (List__MinerV0SectorPreCommitInfo) AsInt() (int64, error)

+ func (List__MinerV0SectorPreCommitInfo) AsLink() (ipld.Link, error)

+ func (List__MinerV0SectorPreCommitInfo) AsString() (string, error)

+ func (List__MinerV0SectorPreCommitInfo) IsAbsent() bool

+ func (List__MinerV0SectorPreCommitInfo) IsNull() bool

+ func (List__MinerV0SectorPreCommitInfo) Kind() ipld.Kind

+ func (List__MinerV0SectorPreCommitInfo) LookupByString(string) (ipld.Node, error)

+ func (List__MinerV0SectorPreCommitInfo) MapIterator() ipld.MapIterator

+ func (List__MinerV0SectorPreCommitInfo) Prototype() ipld.NodePrototype

+ func (List__MinerV0SectorPreCommitInfo) Type() schema.Type

+ func (n List__MinerV0SectorPreCommitInfo) Iterator() *List__MinerV0SectorPreCommitInfo__Itr

+ func (n List__MinerV0SectorPreCommitInfo) Length() int64

+ func (n List__MinerV0SectorPreCommitInfo) ListIterator() ipld.ListIterator

+ func (n List__MinerV0SectorPreCommitInfo) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__MinerV0SectorPreCommitInfo) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__MinerV0SectorPreCommitInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__MinerV0SectorPreCommitInfo) Representation() ipld.Node

+ type List__MinerV0SectorPreCommitInfo__Itr struct

+ func (itr *List__MinerV0SectorPreCommitInfo__Itr) Done() bool

+ func (itr *List__MinerV0SectorPreCommitInfo__Itr) Next() (idx int64, v MinerV0SectorPreCommitInfo)

+ type List__MinerV0VestingFund = *_List__MinerV0VestingFund

+ func (List__MinerV0VestingFund) AsBool() (bool, error)

+ func (List__MinerV0VestingFund) AsBytes() ([]byte, error)

+ func (List__MinerV0VestingFund) AsFloat() (float64, error)

+ func (List__MinerV0VestingFund) AsInt() (int64, error)

+ func (List__MinerV0VestingFund) AsLink() (ipld.Link, error)

+ func (List__MinerV0VestingFund) AsString() (string, error)

+ func (List__MinerV0VestingFund) IsAbsent() bool

+ func (List__MinerV0VestingFund) IsNull() bool

+ func (List__MinerV0VestingFund) Kind() ipld.Kind

+ func (List__MinerV0VestingFund) LookupByString(string) (ipld.Node, error)

+ func (List__MinerV0VestingFund) MapIterator() ipld.MapIterator

+ func (List__MinerV0VestingFund) Prototype() ipld.NodePrototype

+ func (List__MinerV0VestingFund) Type() schema.Type

+ func (n List__MinerV0VestingFund) Iterator() *List__MinerV0VestingFund__Itr

+ func (n List__MinerV0VestingFund) Length() int64

+ func (n List__MinerV0VestingFund) ListIterator() ipld.ListIterator

+ func (n List__MinerV0VestingFund) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__MinerV0VestingFund) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__MinerV0VestingFund) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__MinerV0VestingFund) Representation() ipld.Node

+ type List__MinerV0VestingFund__Itr struct

+ func (itr *List__MinerV0VestingFund__Itr) Done() bool

+ func (itr *List__MinerV0VestingFund__Itr) Next() (idx int64, v MaybeMinerV0VestingFund)

+ type List__MinerV2DeadlineLink = *_List__MinerV2DeadlineLink

+ func (List__MinerV2DeadlineLink) AsBool() (bool, error)

+ func (List__MinerV2DeadlineLink) AsBytes() ([]byte, error)

+ func (List__MinerV2DeadlineLink) AsFloat() (float64, error)

+ func (List__MinerV2DeadlineLink) AsInt() (int64, error)

+ func (List__MinerV2DeadlineLink) AsLink() (ipld.Link, error)

+ func (List__MinerV2DeadlineLink) AsString() (string, error)

+ func (List__MinerV2DeadlineLink) IsAbsent() bool

+ func (List__MinerV2DeadlineLink) IsNull() bool

+ func (List__MinerV2DeadlineLink) Kind() ipld.Kind

+ func (List__MinerV2DeadlineLink) LookupByString(string) (ipld.Node, error)

+ func (List__MinerV2DeadlineLink) MapIterator() ipld.MapIterator

+ func (List__MinerV2DeadlineLink) Prototype() ipld.NodePrototype

+ func (List__MinerV2DeadlineLink) Type() schema.Type

+ func (n List__MinerV2DeadlineLink) Iterator() *List__MinerV2DeadlineLink__Itr

+ func (n List__MinerV2DeadlineLink) Length() int64

+ func (n List__MinerV2DeadlineLink) ListIterator() ipld.ListIterator

+ func (n List__MinerV2DeadlineLink) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__MinerV2DeadlineLink) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__MinerV2DeadlineLink) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__MinerV2DeadlineLink) Representation() ipld.Node

+ type List__MinerV2DeadlineLink__Itr struct

+ func (itr *List__MinerV2DeadlineLink__Itr) Done() bool

+ func (itr *List__MinerV2DeadlineLink__Itr) Next() (idx int64, v MaybeLink__MinerV2Deadline)

+ type List__MinerV3DeadlineLink = *_List__MinerV3DeadlineLink

+ func (List__MinerV3DeadlineLink) AsBool() (bool, error)

+ func (List__MinerV3DeadlineLink) AsBytes() ([]byte, error)

+ func (List__MinerV3DeadlineLink) AsFloat() (float64, error)

+ func (List__MinerV3DeadlineLink) AsInt() (int64, error)

+ func (List__MinerV3DeadlineLink) AsLink() (ipld.Link, error)

+ func (List__MinerV3DeadlineLink) AsString() (string, error)

+ func (List__MinerV3DeadlineLink) IsAbsent() bool

+ func (List__MinerV3DeadlineLink) IsNull() bool

+ func (List__MinerV3DeadlineLink) Kind() ipld.Kind

+ func (List__MinerV3DeadlineLink) LookupByString(string) (ipld.Node, error)

+ func (List__MinerV3DeadlineLink) MapIterator() ipld.MapIterator

+ func (List__MinerV3DeadlineLink) Prototype() ipld.NodePrototype

+ func (List__MinerV3DeadlineLink) Type() schema.Type

+ func (n List__MinerV3DeadlineLink) Iterator() *List__MinerV3DeadlineLink__Itr

+ func (n List__MinerV3DeadlineLink) Length() int64

+ func (n List__MinerV3DeadlineLink) ListIterator() ipld.ListIterator

+ func (n List__MinerV3DeadlineLink) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__MinerV3DeadlineLink) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__MinerV3DeadlineLink) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__MinerV3DeadlineLink) Representation() ipld.Node

+ type List__MinerV3DeadlineLink__Itr struct

+ func (itr *List__MinerV3DeadlineLink__Itr) Done() bool

+ func (itr *List__MinerV3DeadlineLink__Itr) Next() (idx int64, v MaybeLink__MinerV3Deadline)

+ type List__Multiaddrs = *_List__Multiaddrs

+ func (List__Multiaddrs) AsBool() (bool, error)

+ func (List__Multiaddrs) AsBytes() ([]byte, error)

+ func (List__Multiaddrs) AsFloat() (float64, error)

+ func (List__Multiaddrs) AsInt() (int64, error)

+ func (List__Multiaddrs) AsLink() (ipld.Link, error)

+ func (List__Multiaddrs) AsString() (string, error)

+ func (List__Multiaddrs) IsAbsent() bool

+ func (List__Multiaddrs) IsNull() bool

+ func (List__Multiaddrs) Kind() ipld.Kind

+ func (List__Multiaddrs) LookupByString(string) (ipld.Node, error)

+ func (List__Multiaddrs) MapIterator() ipld.MapIterator

+ func (List__Multiaddrs) Prototype() ipld.NodePrototype

+ func (List__Multiaddrs) Type() schema.Type

+ func (n List__Multiaddrs) Iterator() *List__Multiaddrs__Itr

+ func (n List__Multiaddrs) Length() int64

+ func (n List__Multiaddrs) ListIterator() ipld.ListIterator

+ func (n List__Multiaddrs) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__Multiaddrs) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__Multiaddrs) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__Multiaddrs) Representation() ipld.Node

+ type List__Multiaddrs__Itr struct

+ func (itr *List__Multiaddrs__Itr) Done() bool

+ func (itr *List__Multiaddrs__Itr) Next() (idx int64, v MaybeMultiaddr)

+ type List__PoStProof = *_List__PoStProof

+ func (List__PoStProof) AsBool() (bool, error)

+ func (List__PoStProof) AsBytes() ([]byte, error)

+ func (List__PoStProof) AsFloat() (float64, error)

+ func (List__PoStProof) AsInt() (int64, error)

+ func (List__PoStProof) AsLink() (ipld.Link, error)

+ func (List__PoStProof) AsString() (string, error)

+ func (List__PoStProof) IsAbsent() bool

+ func (List__PoStProof) IsNull() bool

+ func (List__PoStProof) Kind() ipld.Kind

+ func (List__PoStProof) LookupByString(string) (ipld.Node, error)

+ func (List__PoStProof) MapIterator() ipld.MapIterator

+ func (List__PoStProof) Prototype() ipld.NodePrototype

+ func (List__PoStProof) Type() schema.Type

+ func (n List__PoStProof) Iterator() *List__PoStProof__Itr

+ func (n List__PoStProof) Length() int64

+ func (n List__PoStProof) ListIterator() ipld.ListIterator

+ func (n List__PoStProof) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__PoStProof) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__PoStProof) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__PoStProof) Representation() ipld.Node

+ type List__PoStProof__Itr struct

+ func (itr *List__PoStProof__Itr) Done() bool

+ func (itr *List__PoStProof__Itr) Next() (idx int64, v PoStProof)

+ type List__SectorDataSpec = *_List__SectorDataSpec

+ func (List__SectorDataSpec) AsBool() (bool, error)

+ func (List__SectorDataSpec) AsBytes() ([]byte, error)

+ func (List__SectorDataSpec) AsFloat() (float64, error)

+ func (List__SectorDataSpec) AsInt() (int64, error)

+ func (List__SectorDataSpec) AsLink() (ipld.Link, error)

+ func (List__SectorDataSpec) AsString() (string, error)

+ func (List__SectorDataSpec) IsAbsent() bool

+ func (List__SectorDataSpec) IsNull() bool

+ func (List__SectorDataSpec) Kind() ipld.Kind

+ func (List__SectorDataSpec) LookupByString(string) (ipld.Node, error)

+ func (List__SectorDataSpec) MapIterator() ipld.MapIterator

+ func (List__SectorDataSpec) Prototype() ipld.NodePrototype

+ func (List__SectorDataSpec) Type() schema.Type

+ func (n List__SectorDataSpec) Iterator() *List__SectorDataSpec__Itr

+ func (n List__SectorDataSpec) Length() int64

+ func (n List__SectorDataSpec) ListIterator() ipld.ListIterator

+ func (n List__SectorDataSpec) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__SectorDataSpec) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__SectorDataSpec) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__SectorDataSpec) Representation() ipld.Node

+ type List__SectorDataSpec__Itr struct

+ func (itr *List__SectorDataSpec__Itr) Done() bool

+ func (itr *List__SectorDataSpec__Itr) Next() (idx int64, v SectorDataSpec)

+ type List__SectorNumber = *_List__SectorNumber

+ func (List__SectorNumber) AsBool() (bool, error)

+ func (List__SectorNumber) AsBytes() ([]byte, error)

+ func (List__SectorNumber) AsFloat() (float64, error)

+ func (List__SectorNumber) AsInt() (int64, error)

+ func (List__SectorNumber) AsLink() (ipld.Link, error)

+ func (List__SectorNumber) AsString() (string, error)

+ func (List__SectorNumber) IsAbsent() bool

+ func (List__SectorNumber) IsNull() bool

+ func (List__SectorNumber) Kind() ipld.Kind

+ func (List__SectorNumber) LookupByString(string) (ipld.Node, error)

+ func (List__SectorNumber) MapIterator() ipld.MapIterator

+ func (List__SectorNumber) Prototype() ipld.NodePrototype

+ func (List__SectorNumber) Type() schema.Type

+ func (n List__SectorNumber) Iterator() *List__SectorNumber__Itr

+ func (n List__SectorNumber) Length() int64

+ func (n List__SectorNumber) ListIterator() ipld.ListIterator

+ func (n List__SectorNumber) LookupByIndex(idx int64) (ipld.Node, error)

+ func (n List__SectorNumber) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n List__SectorNumber) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n List__SectorNumber) Representation() ipld.Node

+ type List__SectorNumber__Itr struct

+ func (itr *List__SectorNumber__Itr) Done() bool

+ func (itr *List__SectorNumber__Itr) Next() (idx int64, v SectorNumber)

+ type LotusActorV2Head = *_LotusActorV2Head

+ func (LotusActorV2Head) AsBool() (bool, error)

+ func (LotusActorV2Head) AsBytes() ([]byte, error)

+ func (LotusActorV2Head) AsFloat() (float64, error)

+ func (LotusActorV2Head) AsInt() (int64, error)

+ func (LotusActorV2Head) AsLink() (ipld.Link, error)

+ func (LotusActorV2Head) AsString() (string, error)

+ func (LotusActorV2Head) IsAbsent() bool

+ func (LotusActorV2Head) IsNull() bool

+ func (LotusActorV2Head) Kind() ipld.Kind

+ func (LotusActorV2Head) Length() int64

+ func (LotusActorV2Head) ListIterator() ipld.ListIterator

+ func (LotusActorV2Head) LookupByIndex(idx int64) (ipld.Node, error)

+ func (LotusActorV2Head) Prototype() ipld.NodePrototype

+ func (LotusActorV2Head) Type() schema.Type

+ func (n LotusActorV2Head) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n LotusActorV2Head) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n LotusActorV2Head) LookupByString(key string) (ipld.Node, error)

+ func (n LotusActorV2Head) MapIterator() ipld.MapIterator

+ func (n LotusActorV2Head) Representation() ipld.Node

+ type LotusActorV3Head = *_LotusActorV3Head

+ func (LotusActorV3Head) AsBool() (bool, error)

+ func (LotusActorV3Head) AsBytes() ([]byte, error)

+ func (LotusActorV3Head) AsFloat() (float64, error)

+ func (LotusActorV3Head) AsInt() (int64, error)

+ func (LotusActorV3Head) AsLink() (ipld.Link, error)

+ func (LotusActorV3Head) AsString() (string, error)

+ func (LotusActorV3Head) IsAbsent() bool

+ func (LotusActorV3Head) IsNull() bool

+ func (LotusActorV3Head) Kind() ipld.Kind

+ func (LotusActorV3Head) Length() int64

+ func (LotusActorV3Head) ListIterator() ipld.ListIterator

+ func (LotusActorV3Head) LookupByIndex(idx int64) (ipld.Node, error)

+ func (LotusActorV3Head) Prototype() ipld.NodePrototype

+ func (LotusActorV3Head) Type() schema.Type

+ func (n LotusActorV3Head) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n LotusActorV3Head) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n LotusActorV3Head) LookupByString(key string) (ipld.Node, error)

+ func (n LotusActorV3Head) MapIterator() ipld.MapIterator

+ func (n LotusActorV3Head) Representation() ipld.Node

+ type LotusActorV4Head = *_LotusActorV4Head

+ func (LotusActorV4Head) AsBool() (bool, error)

+ func (LotusActorV4Head) AsBytes() ([]byte, error)

+ func (LotusActorV4Head) AsFloat() (float64, error)

+ func (LotusActorV4Head) AsInt() (int64, error)

+ func (LotusActorV4Head) AsLink() (ipld.Link, error)

+ func (LotusActorV4Head) AsString() (string, error)

+ func (LotusActorV4Head) IsAbsent() bool

+ func (LotusActorV4Head) IsNull() bool

+ func (LotusActorV4Head) Kind() ipld.Kind

+ func (LotusActorV4Head) Length() int64

+ func (LotusActorV4Head) ListIterator() ipld.ListIterator

+ func (LotusActorV4Head) LookupByIndex(idx int64) (ipld.Node, error)

+ func (LotusActorV4Head) Prototype() ipld.NodePrototype

+ func (LotusActorV4Head) Type() schema.Type

+ func (n LotusActorV4Head) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n LotusActorV4Head) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n LotusActorV4Head) LookupByString(key string) (ipld.Node, error)

+ func (n LotusActorV4Head) MapIterator() ipld.MapIterator

+ func (n LotusActorV4Head) Representation() ipld.Node

+ type LotusActorV5Head = *_LotusActorV5Head

+ func (LotusActorV5Head) AsBool() (bool, error)

+ func (LotusActorV5Head) AsBytes() ([]byte, error)

+ func (LotusActorV5Head) AsFloat() (float64, error)

+ func (LotusActorV5Head) AsInt() (int64, error)

+ func (LotusActorV5Head) AsLink() (ipld.Link, error)

+ func (LotusActorV5Head) AsString() (string, error)

+ func (LotusActorV5Head) IsAbsent() bool

+ func (LotusActorV5Head) IsNull() bool

+ func (LotusActorV5Head) Kind() ipld.Kind

+ func (LotusActorV5Head) Length() int64

+ func (LotusActorV5Head) ListIterator() ipld.ListIterator

+ func (LotusActorV5Head) LookupByIndex(idx int64) (ipld.Node, error)

+ func (LotusActorV5Head) Prototype() ipld.NodePrototype

+ func (LotusActorV5Head) Type() schema.Type

+ func (n LotusActorV5Head) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n LotusActorV5Head) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n LotusActorV5Head) LookupByString(key string) (ipld.Node, error)

+ func (n LotusActorV5Head) MapIterator() ipld.MapIterator

+ func (n LotusActorV5Head) Representation() ipld.Node

+ type LotusActors = *_LotusActors

+ func (LotusActors) AsBool() (bool, error)

+ func (LotusActors) AsBytes() ([]byte, error)

+ func (LotusActors) AsFloat() (float64, error)

+ func (LotusActors) AsInt() (int64, error)

+ func (LotusActors) AsLink() (ipld.Link, error)

+ func (LotusActors) AsString() (string, error)

+ func (LotusActors) IsAbsent() bool

+ func (LotusActors) IsNull() bool

+ func (LotusActors) Kind() ipld.Kind

+ func (LotusActors) Length() int64

+ func (LotusActors) ListIterator() ipld.ListIterator

+ func (LotusActors) LookupByIndex(idx int64) (ipld.Node, error)

+ func (LotusActors) Prototype() ipld.NodePrototype

+ func (LotusActors) Type() schema.Type

+ func (n LotusActors) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n LotusActors) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n LotusActors) LookupByString(key string) (ipld.Node, error)

+ func (n LotusActors) MapIterator() ipld.MapIterator

+ func (n LotusActors) Representation() ipld.Node

+ type LotusBeaconEntry = *_LotusBeaconEntry

+ func (LotusBeaconEntry) AsBool() (bool, error)

+ func (LotusBeaconEntry) AsBytes() ([]byte, error)

+ func (LotusBeaconEntry) AsFloat() (float64, error)

+ func (LotusBeaconEntry) AsInt() (int64, error)

+ func (LotusBeaconEntry) AsLink() (ipld.Link, error)

+ func (LotusBeaconEntry) AsString() (string, error)

+ func (LotusBeaconEntry) IsAbsent() bool

+ func (LotusBeaconEntry) IsNull() bool

+ func (LotusBeaconEntry) Kind() ipld.Kind

+ func (LotusBeaconEntry) Length() int64

+ func (LotusBeaconEntry) ListIterator() ipld.ListIterator

+ func (LotusBeaconEntry) LookupByIndex(idx int64) (ipld.Node, error)

+ func (LotusBeaconEntry) Prototype() ipld.NodePrototype

+ func (LotusBeaconEntry) Type() schema.Type

+ func (n LotusBeaconEntry) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n LotusBeaconEntry) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n LotusBeaconEntry) LookupByString(key string) (ipld.Node, error)

+ func (n LotusBeaconEntry) MapIterator() ipld.MapIterator

+ func (n LotusBeaconEntry) Representation() ipld.Node

+ type LotusBlockHeader = *_LotusBlockHeader

+ func (LotusBlockHeader) AsBool() (bool, error)

+ func (LotusBlockHeader) AsBytes() ([]byte, error)

+ func (LotusBlockHeader) AsFloat() (float64, error)

+ func (LotusBlockHeader) AsInt() (int64, error)

+ func (LotusBlockHeader) AsLink() (ipld.Link, error)

+ func (LotusBlockHeader) AsString() (string, error)

+ func (LotusBlockHeader) IsAbsent() bool

+ func (LotusBlockHeader) IsNull() bool

+ func (LotusBlockHeader) Kind() ipld.Kind

+ func (LotusBlockHeader) Length() int64

+ func (LotusBlockHeader) ListIterator() ipld.ListIterator

+ func (LotusBlockHeader) LookupByIndex(idx int64) (ipld.Node, error)

+ func (LotusBlockHeader) Prototype() ipld.NodePrototype

+ func (LotusBlockHeader) Type() schema.Type

+ func (n LotusBlockHeader) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n LotusBlockHeader) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n LotusBlockHeader) LookupByString(key string) (ipld.Node, error)

+ func (n LotusBlockHeader) MapIterator() ipld.MapIterator

+ func (n LotusBlockHeader) Representation() ipld.Node

+ type LotusElectionProof = *_LotusElectionProof

+ func (LotusElectionProof) AsBool() (bool, error)

+ func (LotusElectionProof) AsBytes() ([]byte, error)

+ func (LotusElectionProof) AsFloat() (float64, error)

+ func (LotusElectionProof) AsInt() (int64, error)

+ func (LotusElectionProof) AsLink() (ipld.Link, error)

+ func (LotusElectionProof) AsString() (string, error)

+ func (LotusElectionProof) IsAbsent() bool

+ func (LotusElectionProof) IsNull() bool

+ func (LotusElectionProof) Kind() ipld.Kind

+ func (LotusElectionProof) Length() int64

+ func (LotusElectionProof) ListIterator() ipld.ListIterator

+ func (LotusElectionProof) LookupByIndex(idx int64) (ipld.Node, error)

+ func (LotusElectionProof) Prototype() ipld.NodePrototype

+ func (LotusElectionProof) Type() schema.Type

+ func (n LotusElectionProof) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n LotusElectionProof) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n LotusElectionProof) LookupByString(key string) (ipld.Node, error)

+ func (n LotusElectionProof) MapIterator() ipld.MapIterator

+ func (n LotusElectionProof) Representation() ipld.Node

+ type LotusMessage = *_LotusMessage

+ func (LotusMessage) AsBool() (bool, error)

+ func (LotusMessage) AsBytes() ([]byte, error)

+ func (LotusMessage) AsFloat() (float64, error)

+ func (LotusMessage) AsInt() (int64, error)

+ func (LotusMessage) AsLink() (ipld.Link, error)

+ func (LotusMessage) AsString() (string, error)

+ func (LotusMessage) IsAbsent() bool

+ func (LotusMessage) IsNull() bool

+ func (LotusMessage) Kind() ipld.Kind

+ func (LotusMessage) Length() int64

+ func (LotusMessage) ListIterator() ipld.ListIterator

+ func (LotusMessage) LookupByIndex(idx int64) (ipld.Node, error)

+ func (LotusMessage) Prototype() ipld.NodePrototype

+ func (LotusMessage) Type() schema.Type

+ func (n LotusMessage) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n LotusMessage) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n LotusMessage) LookupByString(key string) (ipld.Node, error)

+ func (n LotusMessage) MapIterator() ipld.MapIterator

+ func (n LotusMessage) Representation() ipld.Node

+ type LotusMessageV2Params = *_LotusMessageV2Params

+ func (LotusMessageV2Params) AsBool() (bool, error)

+ func (LotusMessageV2Params) AsBytes() ([]byte, error)

+ func (LotusMessageV2Params) AsFloat() (float64, error)

+ func (LotusMessageV2Params) AsInt() (int64, error)

+ func (LotusMessageV2Params) AsLink() (ipld.Link, error)

+ func (LotusMessageV2Params) AsString() (string, error)

+ func (LotusMessageV2Params) IsAbsent() bool

+ func (LotusMessageV2Params) IsNull() bool

+ func (LotusMessageV2Params) Kind() ipld.Kind

+ func (LotusMessageV2Params) Length() int64

+ func (LotusMessageV2Params) ListIterator() ipld.ListIterator

+ func (LotusMessageV2Params) LookupByIndex(idx int64) (ipld.Node, error)

+ func (LotusMessageV2Params) Prototype() ipld.NodePrototype

+ func (LotusMessageV2Params) Type() schema.Type

+ func (n LotusMessageV2Params) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n LotusMessageV2Params) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n LotusMessageV2Params) LookupByString(key string) (ipld.Node, error)

+ func (n LotusMessageV2Params) MapIterator() ipld.MapIterator

+ func (n LotusMessageV2Params) Representation() ipld.Node

+ type LotusMsgMeta = *_LotusMsgMeta

+ func (LotusMsgMeta) AsBool() (bool, error)

+ func (LotusMsgMeta) AsBytes() ([]byte, error)

+ func (LotusMsgMeta) AsFloat() (float64, error)

+ func (LotusMsgMeta) AsInt() (int64, error)

+ func (LotusMsgMeta) AsLink() (ipld.Link, error)

+ func (LotusMsgMeta) AsString() (string, error)

+ func (LotusMsgMeta) IsAbsent() bool

+ func (LotusMsgMeta) IsNull() bool

+ func (LotusMsgMeta) Kind() ipld.Kind

+ func (LotusMsgMeta) Length() int64

+ func (LotusMsgMeta) ListIterator() ipld.ListIterator

+ func (LotusMsgMeta) LookupByIndex(idx int64) (ipld.Node, error)

+ func (LotusMsgMeta) Prototype() ipld.NodePrototype

+ func (LotusMsgMeta) Type() schema.Type

+ func (n LotusMsgMeta) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n LotusMsgMeta) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n LotusMsgMeta) LookupByString(key string) (ipld.Node, error)

+ func (n LotusMsgMeta) MapIterator() ipld.MapIterator

+ func (n LotusMsgMeta) Representation() ipld.Node

+ type LotusSignedMessage = *_LotusSignedMessage

+ func (LotusSignedMessage) AsBool() (bool, error)

+ func (LotusSignedMessage) AsBytes() ([]byte, error)

+ func (LotusSignedMessage) AsFloat() (float64, error)

+ func (LotusSignedMessage) AsInt() (int64, error)

+ func (LotusSignedMessage) AsLink() (ipld.Link, error)

+ func (LotusSignedMessage) AsString() (string, error)

+ func (LotusSignedMessage) IsAbsent() bool

+ func (LotusSignedMessage) IsNull() bool

+ func (LotusSignedMessage) Kind() ipld.Kind

+ func (LotusSignedMessage) Length() int64

+ func (LotusSignedMessage) ListIterator() ipld.ListIterator

+ func (LotusSignedMessage) LookupByIndex(idx int64) (ipld.Node, error)

+ func (LotusSignedMessage) Prototype() ipld.NodePrototype

+ func (LotusSignedMessage) Type() schema.Type

+ func (n LotusSignedMessage) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n LotusSignedMessage) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n LotusSignedMessage) LookupByString(key string) (ipld.Node, error)

+ func (n LotusSignedMessage) MapIterator() ipld.MapIterator

+ func (n LotusSignedMessage) Representation() ipld.Node

+ type LotusStateRoot = *_LotusStateRoot

+ func (LotusStateRoot) AsBool() (bool, error)

+ func (LotusStateRoot) AsBytes() ([]byte, error)

+ func (LotusStateRoot) AsFloat() (float64, error)

+ func (LotusStateRoot) AsInt() (int64, error)

+ func (LotusStateRoot) AsLink() (ipld.Link, error)

+ func (LotusStateRoot) AsString() (string, error)

+ func (LotusStateRoot) IsAbsent() bool

+ func (LotusStateRoot) IsNull() bool

+ func (LotusStateRoot) Kind() ipld.Kind

+ func (LotusStateRoot) Length() int64

+ func (LotusStateRoot) ListIterator() ipld.ListIterator

+ func (LotusStateRoot) LookupByIndex(idx int64) (ipld.Node, error)

+ func (LotusStateRoot) Prototype() ipld.NodePrototype

+ func (LotusStateRoot) Type() schema.Type

+ func (n LotusStateRoot) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n LotusStateRoot) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n LotusStateRoot) LookupByString(key string) (ipld.Node, error)

+ func (n LotusStateRoot) MapIterator() ipld.MapIterator

+ func (n LotusStateRoot) Representation() ipld.Node

+ type LotusTicket = *_LotusTicket

+ func (LotusTicket) AsBool() (bool, error)

+ func (LotusTicket) AsBytes() ([]byte, error)

+ func (LotusTicket) AsFloat() (float64, error)

+ func (LotusTicket) AsInt() (int64, error)

+ func (LotusTicket) AsLink() (ipld.Link, error)

+ func (LotusTicket) AsString() (string, error)

+ func (LotusTicket) IsAbsent() bool

+ func (LotusTicket) IsNull() bool

+ func (LotusTicket) Kind() ipld.Kind

+ func (LotusTicket) Length() int64

+ func (LotusTicket) ListIterator() ipld.ListIterator

+ func (LotusTicket) LookupByIndex(idx int64) (ipld.Node, error)

+ func (LotusTicket) Prototype() ipld.NodePrototype

+ func (LotusTicket) Type() schema.Type

+ func (n LotusTicket) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n LotusTicket) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n LotusTicket) LookupByString(key string) (ipld.Node, error)

+ func (n LotusTicket) MapIterator() ipld.MapIterator

+ func (n LotusTicket) Representation() ipld.Node

+ type Map = *_Map

+ func (Map) AsBool() (bool, error)

+ func (Map) AsBytes() ([]byte, error)

+ func (Map) AsFloat() (float64, error)

+ func (Map) AsInt() (int64, error)

+ func (Map) AsLink() (ipld.Link, error)

+ func (Map) AsString() (string, error)

+ func (Map) IsAbsent() bool

+ func (Map) IsNull() bool

+ func (Map) Kind() ipld.Kind

+ func (Map) ListIterator() ipld.ListIterator

+ func (Map) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map) Prototype() ipld.NodePrototype

+ func (Map) Type() schema.Type

+ func (n Map) Iterator() *Map__Itr

+ func (n Map) Length() int64

+ func (n Map) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map) LookupByString(k string) (ipld.Node, error)

+ func (n Map) MapIterator() ipld.MapIterator

+ func (n Map) Representation() ipld.Node

+ type MapV3__BitField = *_MapV3__BitField

+ func (MapV3__BitField) AsBool() (bool, error)

+ func (MapV3__BitField) AsBytes() ([]byte, error)

+ func (MapV3__BitField) AsFloat() (float64, error)

+ func (MapV3__BitField) AsInt() (int64, error)

+ func (MapV3__BitField) AsLink() (ipld.Link, error)

+ func (MapV3__BitField) AsString() (string, error)

+ func (MapV3__BitField) IsAbsent() bool

+ func (MapV3__BitField) IsNull() bool

+ func (MapV3__BitField) Kind() ipld.Kind

+ func (MapV3__BitField) ListIterator() ipld.ListIterator

+ func (MapV3__BitField) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MapV3__BitField) Prototype() ipld.NodePrototype

+ func (MapV3__BitField) Type() schema.Type

+ func (n MapV3__BitField) Iterator() *MapV3__BitField__Itr

+ func (n MapV3__BitField) Length() int64

+ func (n MapV3__BitField) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n MapV3__BitField) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MapV3__BitField) LookupByString(k string) (ipld.Node, error)

+ func (n MapV3__BitField) MapIterator() ipld.MapIterator

+ func (n MapV3__BitField) Representation() ipld.Node

+ type MapV3__BitField__Itr struct

+ func (itr *MapV3__BitField__Itr) Done() bool

+ func (itr *MapV3__BitField__Itr) Next() (k String, v MaybeBitField)

+ type MapV3__List__DealID = *_MapV3__List__DealID

+ func (MapV3__List__DealID) AsBool() (bool, error)

+ func (MapV3__List__DealID) AsBytes() ([]byte, error)

+ func (MapV3__List__DealID) AsFloat() (float64, error)

+ func (MapV3__List__DealID) AsInt() (int64, error)

+ func (MapV3__List__DealID) AsLink() (ipld.Link, error)

+ func (MapV3__List__DealID) AsString() (string, error)

+ func (MapV3__List__DealID) IsAbsent() bool

+ func (MapV3__List__DealID) IsNull() bool

+ func (MapV3__List__DealID) Kind() ipld.Kind

+ func (MapV3__List__DealID) ListIterator() ipld.ListIterator

+ func (MapV3__List__DealID) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MapV3__List__DealID) Prototype() ipld.NodePrototype

+ func (MapV3__List__DealID) Type() schema.Type

+ func (n MapV3__List__DealID) Iterator() *MapV3__List__DealID__Itr

+ func (n MapV3__List__DealID) Length() int64

+ func (n MapV3__List__DealID) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n MapV3__List__DealID) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MapV3__List__DealID) LookupByString(k string) (ipld.Node, error)

+ func (n MapV3__List__DealID) MapIterator() ipld.MapIterator

+ func (n MapV3__List__DealID) Representation() ipld.Node

+ type MapV3__List__DealID__Itr struct

+ func (itr *MapV3__List__DealID__Itr) Done() bool

+ func (itr *MapV3__List__DealID__Itr) Next() (k String, v List__DealID)

+ type Map__ActorID = *_Map__ActorID

+ func (Map__ActorID) AsBool() (bool, error)

+ func (Map__ActorID) AsBytes() ([]byte, error)

+ func (Map__ActorID) AsFloat() (float64, error)

+ func (Map__ActorID) AsInt() (int64, error)

+ func (Map__ActorID) AsLink() (ipld.Link, error)

+ func (Map__ActorID) AsString() (string, error)

+ func (Map__ActorID) IsAbsent() bool

+ func (Map__ActorID) IsNull() bool

+ func (Map__ActorID) Kind() ipld.Kind

+ func (Map__ActorID) ListIterator() ipld.ListIterator

+ func (Map__ActorID) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__ActorID) Prototype() ipld.NodePrototype

+ func (Map__ActorID) Type() schema.Type

+ func (n Map__ActorID) Iterator() *Map__ActorID__Itr

+ func (n Map__ActorID) Length() int64

+ func (n Map__ActorID) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__ActorID) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__ActorID) LookupByString(k string) (ipld.Node, error)

+ func (n Map__ActorID) MapIterator() ipld.MapIterator

+ func (n Map__ActorID) Representation() ipld.Node

+ type Map__ActorID__Itr struct

+ func (itr *Map__ActorID__Itr) Done() bool

+ func (itr *Map__ActorID__Itr) Next() (k RawAddress, v ActorID)

+ type Map__BalanceTable = *_Map__BalanceTable

+ func (Map__BalanceTable) AsBool() (bool, error)

+ func (Map__BalanceTable) AsBytes() ([]byte, error)

+ func (Map__BalanceTable) AsFloat() (float64, error)

+ func (Map__BalanceTable) AsInt() (int64, error)

+ func (Map__BalanceTable) AsLink() (ipld.Link, error)

+ func (Map__BalanceTable) AsString() (string, error)

+ func (Map__BalanceTable) IsAbsent() bool

+ func (Map__BalanceTable) IsNull() bool

+ func (Map__BalanceTable) Kind() ipld.Kind

+ func (Map__BalanceTable) ListIterator() ipld.ListIterator

+ func (Map__BalanceTable) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__BalanceTable) Prototype() ipld.NodePrototype

+ func (Map__BalanceTable) Type() schema.Type

+ func (n Map__BalanceTable) Iterator() *Map__BalanceTable__Itr

+ func (n Map__BalanceTable) Length() int64

+ func (n Map__BalanceTable) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__BalanceTable) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__BalanceTable) LookupByString(k string) (ipld.Node, error)

+ func (n Map__BalanceTable) MapIterator() ipld.MapIterator

+ func (n Map__BalanceTable) Representation() ipld.Node

+ type Map__BalanceTable__Itr struct

+ func (itr *Map__BalanceTable__Itr) Done() bool

+ func (itr *Map__BalanceTable__Itr) Next() (k RawAddress, v BigInt)

+ type Map__BitField = *_Map__BitField

+ func (Map__BitField) AsBool() (bool, error)

+ func (Map__BitField) AsBytes() ([]byte, error)

+ func (Map__BitField) AsFloat() (float64, error)

+ func (Map__BitField) AsInt() (int64, error)

+ func (Map__BitField) AsLink() (ipld.Link, error)

+ func (Map__BitField) AsString() (string, error)

+ func (Map__BitField) IsAbsent() bool

+ func (Map__BitField) IsNull() bool

+ func (Map__BitField) Kind() ipld.Kind

+ func (Map__BitField) ListIterator() ipld.ListIterator

+ func (Map__BitField) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__BitField) Prototype() ipld.NodePrototype

+ func (Map__BitField) Type() schema.Type

+ func (n Map__BitField) Iterator() *Map__BitField__Itr

+ func (n Map__BitField) Length() int64

+ func (n Map__BitField) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__BitField) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__BitField) LookupByString(k string) (ipld.Node, error)

+ func (n Map__BitField) MapIterator() ipld.MapIterator

+ func (n Map__BitField) Representation() ipld.Node

+ type Map__BitField__Itr struct

+ func (itr *Map__BitField__Itr) Done() bool

+ func (itr *Map__BitField__Itr) Next() (k String, v MaybeBitField)

+ type Map__DataCap = *_Map__DataCap

+ func (Map__DataCap) AsBool() (bool, error)

+ func (Map__DataCap) AsBytes() ([]byte, error)

+ func (Map__DataCap) AsFloat() (float64, error)

+ func (Map__DataCap) AsInt() (int64, error)

+ func (Map__DataCap) AsLink() (ipld.Link, error)

+ func (Map__DataCap) AsString() (string, error)

+ func (Map__DataCap) IsAbsent() bool

+ func (Map__DataCap) IsNull() bool

+ func (Map__DataCap) Kind() ipld.Kind

+ func (Map__DataCap) ListIterator() ipld.ListIterator

+ func (Map__DataCap) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__DataCap) Prototype() ipld.NodePrototype

+ func (Map__DataCap) Type() schema.Type

+ func (n Map__DataCap) Iterator() *Map__DataCap__Itr

+ func (n Map__DataCap) Length() int64

+ func (n Map__DataCap) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__DataCap) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__DataCap) LookupByString(k string) (ipld.Node, error)

+ func (n Map__DataCap) MapIterator() ipld.MapIterator

+ func (n Map__DataCap) Representation() ipld.Node

+ type Map__DataCap__Itr struct

+ func (itr *Map__DataCap__Itr) Done() bool

+ func (itr *Map__DataCap__Itr) Next() (k RawAddress, v BigInt)

+ type Map__Itr struct

+ func (itr *Map__Itr) Done() bool

+ func (itr *Map__Itr) Next() (k String, v MaybeAny)

+ type Map__List__DealID = *_Map__List__DealID

+ func (Map__List__DealID) AsBool() (bool, error)

+ func (Map__List__DealID) AsBytes() ([]byte, error)

+ func (Map__List__DealID) AsFloat() (float64, error)

+ func (Map__List__DealID) AsInt() (int64, error)

+ func (Map__List__DealID) AsLink() (ipld.Link, error)

+ func (Map__List__DealID) AsString() (string, error)

+ func (Map__List__DealID) IsAbsent() bool

+ func (Map__List__DealID) IsNull() bool

+ func (Map__List__DealID) Kind() ipld.Kind

+ func (Map__List__DealID) ListIterator() ipld.ListIterator

+ func (Map__List__DealID) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__List__DealID) Prototype() ipld.NodePrototype

+ func (Map__List__DealID) Type() schema.Type

+ func (n Map__List__DealID) Iterator() *Map__List__DealID__Itr

+ func (n Map__List__DealID) Length() int64

+ func (n Map__List__DealID) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__List__DealID) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__List__DealID) LookupByString(k string) (ipld.Node, error)

+ func (n Map__List__DealID) MapIterator() ipld.MapIterator

+ func (n Map__List__DealID) Representation() ipld.Node

+ type Map__List__DealID__Itr struct

+ func (itr *Map__List__DealID__Itr) Done() bool

+ func (itr *Map__List__DealID__Itr) Next() (k String, v List__DealID)

+ type Map__LotusActors = *_Map__LotusActors

+ func (Map__LotusActors) AsBool() (bool, error)

+ func (Map__LotusActors) AsBytes() ([]byte, error)

+ func (Map__LotusActors) AsFloat() (float64, error)

+ func (Map__LotusActors) AsInt() (int64, error)

+ func (Map__LotusActors) AsLink() (ipld.Link, error)

+ func (Map__LotusActors) AsString() (string, error)

+ func (Map__LotusActors) IsAbsent() bool

+ func (Map__LotusActors) IsNull() bool

+ func (Map__LotusActors) Kind() ipld.Kind

+ func (Map__LotusActors) ListIterator() ipld.ListIterator

+ func (Map__LotusActors) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__LotusActors) Prototype() ipld.NodePrototype

+ func (Map__LotusActors) Type() schema.Type

+ func (n Map__LotusActors) Iterator() *Map__LotusActors__Itr

+ func (n Map__LotusActors) Length() int64

+ func (n Map__LotusActors) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__LotusActors) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__LotusActors) LookupByString(k string) (ipld.Node, error)

+ func (n Map__LotusActors) MapIterator() ipld.MapIterator

+ func (n Map__LotusActors) Representation() ipld.Node

+ type Map__LotusActors__Itr struct

+ func (itr *Map__LotusActors__Itr) Done() bool

+ func (itr *Map__LotusActors__Itr) Next() (k RawAddress, v LotusActors)

+ type Map__MarketV0DealProposal = *_Map__MarketV0DealProposal

+ func (Map__MarketV0DealProposal) AsBool() (bool, error)

+ func (Map__MarketV0DealProposal) AsBytes() ([]byte, error)

+ func (Map__MarketV0DealProposal) AsFloat() (float64, error)

+ func (Map__MarketV0DealProposal) AsInt() (int64, error)

+ func (Map__MarketV0DealProposal) AsLink() (ipld.Link, error)

+ func (Map__MarketV0DealProposal) AsString() (string, error)

+ func (Map__MarketV0DealProposal) IsAbsent() bool

+ func (Map__MarketV0DealProposal) IsNull() bool

+ func (Map__MarketV0DealProposal) Kind() ipld.Kind

+ func (Map__MarketV0DealProposal) ListIterator() ipld.ListIterator

+ func (Map__MarketV0DealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MarketV0DealProposal) Prototype() ipld.NodePrototype

+ func (Map__MarketV0DealProposal) Type() schema.Type

+ func (n Map__MarketV0DealProposal) Iterator() *Map__MarketV0DealProposal__Itr

+ func (n Map__MarketV0DealProposal) Length() int64

+ func (n Map__MarketV0DealProposal) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MarketV0DealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MarketV0DealProposal) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MarketV0DealProposal) MapIterator() ipld.MapIterator

+ func (n Map__MarketV0DealProposal) Representation() ipld.Node

+ type Map__MarketV0DealProposal__Itr struct

+ func (itr *Map__MarketV0DealProposal__Itr) Done() bool

+ func (itr *Map__MarketV0DealProposal__Itr) Next() (k CidString, v MarketV0DealProposal)

+ type Map__MarketV0DealState = *_Map__MarketV0DealState

+ func (Map__MarketV0DealState) AsBool() (bool, error)

+ func (Map__MarketV0DealState) AsBytes() ([]byte, error)

+ func (Map__MarketV0DealState) AsFloat() (float64, error)

+ func (Map__MarketV0DealState) AsInt() (int64, error)

+ func (Map__MarketV0DealState) AsLink() (ipld.Link, error)

+ func (Map__MarketV0DealState) AsString() (string, error)

+ func (Map__MarketV0DealState) IsAbsent() bool

+ func (Map__MarketV0DealState) IsNull() bool

+ func (Map__MarketV0DealState) Kind() ipld.Kind

+ func (Map__MarketV0DealState) ListIterator() ipld.ListIterator

+ func (Map__MarketV0DealState) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MarketV0DealState) Prototype() ipld.NodePrototype

+ func (Map__MarketV0DealState) Type() schema.Type

+ func (n Map__MarketV0DealState) Iterator() *Map__MarketV0DealState__Itr

+ func (n Map__MarketV0DealState) Length() int64

+ func (n Map__MarketV0DealState) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MarketV0DealState) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MarketV0DealState) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MarketV0DealState) MapIterator() ipld.MapIterator

+ func (n Map__MarketV0DealState) Representation() ipld.Node

+ type Map__MarketV0DealState__Itr struct

+ func (itr *Map__MarketV0DealState__Itr) Done() bool

+ func (itr *Map__MarketV0DealState__Itr) Next() (k String, v MarketV0DealState)

+ type Map__MarketV0RawDealProposal = *_Map__MarketV0RawDealProposal

+ func (Map__MarketV0RawDealProposal) AsBool() (bool, error)

+ func (Map__MarketV0RawDealProposal) AsBytes() ([]byte, error)

+ func (Map__MarketV0RawDealProposal) AsFloat() (float64, error)

+ func (Map__MarketV0RawDealProposal) AsInt() (int64, error)

+ func (Map__MarketV0RawDealProposal) AsLink() (ipld.Link, error)

+ func (Map__MarketV0RawDealProposal) AsString() (string, error)

+ func (Map__MarketV0RawDealProposal) IsAbsent() bool

+ func (Map__MarketV0RawDealProposal) IsNull() bool

+ func (Map__MarketV0RawDealProposal) Kind() ipld.Kind

+ func (Map__MarketV0RawDealProposal) ListIterator() ipld.ListIterator

+ func (Map__MarketV0RawDealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MarketV0RawDealProposal) Prototype() ipld.NodePrototype

+ func (Map__MarketV0RawDealProposal) Type() schema.Type

+ func (n Map__MarketV0RawDealProposal) Iterator() *Map__MarketV0RawDealProposal__Itr

+ func (n Map__MarketV0RawDealProposal) Length() int64

+ func (n Map__MarketV0RawDealProposal) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MarketV0RawDealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MarketV0RawDealProposal) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MarketV0RawDealProposal) MapIterator() ipld.MapIterator

+ func (n Map__MarketV0RawDealProposal) Representation() ipld.Node

+ type Map__MarketV0RawDealProposal__Itr struct

+ func (itr *Map__MarketV0RawDealProposal__Itr) Done() bool

+ func (itr *Map__MarketV0RawDealProposal__Itr) Next() (k String, v MarketV0DealProposal)

+ type Map__MarketV2DealProposal = *_Map__MarketV2DealProposal

+ func (Map__MarketV2DealProposal) AsBool() (bool, error)

+ func (Map__MarketV2DealProposal) AsBytes() ([]byte, error)

+ func (Map__MarketV2DealProposal) AsFloat() (float64, error)

+ func (Map__MarketV2DealProposal) AsInt() (int64, error)

+ func (Map__MarketV2DealProposal) AsLink() (ipld.Link, error)

+ func (Map__MarketV2DealProposal) AsString() (string, error)

+ func (Map__MarketV2DealProposal) IsAbsent() bool

+ func (Map__MarketV2DealProposal) IsNull() bool

+ func (Map__MarketV2DealProposal) Kind() ipld.Kind

+ func (Map__MarketV2DealProposal) ListIterator() ipld.ListIterator

+ func (Map__MarketV2DealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MarketV2DealProposal) Prototype() ipld.NodePrototype

+ func (Map__MarketV2DealProposal) Type() schema.Type

+ func (n Map__MarketV2DealProposal) Iterator() *Map__MarketV2DealProposal__Itr

+ func (n Map__MarketV2DealProposal) Length() int64

+ func (n Map__MarketV2DealProposal) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MarketV2DealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MarketV2DealProposal) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MarketV2DealProposal) MapIterator() ipld.MapIterator

+ func (n Map__MarketV2DealProposal) Representation() ipld.Node

+ type Map__MarketV2DealProposal__Itr struct

+ func (itr *Map__MarketV2DealProposal__Itr) Done() bool

+ func (itr *Map__MarketV2DealProposal__Itr) Next() (k CidString, v MarketV2DealProposal)

+ type Map__MarketV2RawDealProposal = *_Map__MarketV2RawDealProposal

+ func (Map__MarketV2RawDealProposal) AsBool() (bool, error)

+ func (Map__MarketV2RawDealProposal) AsBytes() ([]byte, error)

+ func (Map__MarketV2RawDealProposal) AsFloat() (float64, error)

+ func (Map__MarketV2RawDealProposal) AsInt() (int64, error)

+ func (Map__MarketV2RawDealProposal) AsLink() (ipld.Link, error)

+ func (Map__MarketV2RawDealProposal) AsString() (string, error)

+ func (Map__MarketV2RawDealProposal) IsAbsent() bool

+ func (Map__MarketV2RawDealProposal) IsNull() bool

+ func (Map__MarketV2RawDealProposal) Kind() ipld.Kind

+ func (Map__MarketV2RawDealProposal) ListIterator() ipld.ListIterator

+ func (Map__MarketV2RawDealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MarketV2RawDealProposal) Prototype() ipld.NodePrototype

+ func (Map__MarketV2RawDealProposal) Type() schema.Type

+ func (n Map__MarketV2RawDealProposal) Iterator() *Map__MarketV2RawDealProposal__Itr

+ func (n Map__MarketV2RawDealProposal) Length() int64

+ func (n Map__MarketV2RawDealProposal) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MarketV2RawDealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MarketV2RawDealProposal) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MarketV2RawDealProposal) MapIterator() ipld.MapIterator

+ func (n Map__MarketV2RawDealProposal) Representation() ipld.Node

+ type Map__MarketV2RawDealProposal__Itr struct

+ func (itr *Map__MarketV2RawDealProposal__Itr) Done() bool

+ func (itr *Map__MarketV2RawDealProposal__Itr) Next() (k String, v MarketV2DealProposal)

+ type Map__MarketV3DealProposal = *_Map__MarketV3DealProposal

+ func (Map__MarketV3DealProposal) AsBool() (bool, error)

+ func (Map__MarketV3DealProposal) AsBytes() ([]byte, error)

+ func (Map__MarketV3DealProposal) AsFloat() (float64, error)

+ func (Map__MarketV3DealProposal) AsInt() (int64, error)

+ func (Map__MarketV3DealProposal) AsLink() (ipld.Link, error)

+ func (Map__MarketV3DealProposal) AsString() (string, error)

+ func (Map__MarketV3DealProposal) IsAbsent() bool

+ func (Map__MarketV3DealProposal) IsNull() bool

+ func (Map__MarketV3DealProposal) Kind() ipld.Kind

+ func (Map__MarketV3DealProposal) ListIterator() ipld.ListIterator

+ func (Map__MarketV3DealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MarketV3DealProposal) Prototype() ipld.NodePrototype

+ func (Map__MarketV3DealProposal) Type() schema.Type

+ func (n Map__MarketV3DealProposal) Iterator() *Map__MarketV3DealProposal__Itr

+ func (n Map__MarketV3DealProposal) Length() int64

+ func (n Map__MarketV3DealProposal) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MarketV3DealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MarketV3DealProposal) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MarketV3DealProposal) MapIterator() ipld.MapIterator

+ func (n Map__MarketV3DealProposal) Representation() ipld.Node

+ type Map__MarketV3DealProposal__Itr struct

+ func (itr *Map__MarketV3DealProposal__Itr) Done() bool

+ func (itr *Map__MarketV3DealProposal__Itr) Next() (k CidString, v MarketV2DealProposal)

+ type Map__MarketV3DealState = *_Map__MarketV3DealState

+ func (Map__MarketV3DealState) AsBool() (bool, error)

+ func (Map__MarketV3DealState) AsBytes() ([]byte, error)

+ func (Map__MarketV3DealState) AsFloat() (float64, error)

+ func (Map__MarketV3DealState) AsInt() (int64, error)

+ func (Map__MarketV3DealState) AsLink() (ipld.Link, error)

+ func (Map__MarketV3DealState) AsString() (string, error)

+ func (Map__MarketV3DealState) IsAbsent() bool

+ func (Map__MarketV3DealState) IsNull() bool

+ func (Map__MarketV3DealState) Kind() ipld.Kind

+ func (Map__MarketV3DealState) ListIterator() ipld.ListIterator

+ func (Map__MarketV3DealState) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MarketV3DealState) Prototype() ipld.NodePrototype

+ func (Map__MarketV3DealState) Type() schema.Type

+ func (n Map__MarketV3DealState) Iterator() *Map__MarketV3DealState__Itr

+ func (n Map__MarketV3DealState) Length() int64

+ func (n Map__MarketV3DealState) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MarketV3DealState) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MarketV3DealState) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MarketV3DealState) MapIterator() ipld.MapIterator

+ func (n Map__MarketV3DealState) Representation() ipld.Node

+ type Map__MarketV3DealState__Itr struct

+ func (itr *Map__MarketV3DealState__Itr) Done() bool

+ func (itr *Map__MarketV3DealState__Itr) Next() (k String, v MarketV0DealState)

+ type Map__MarketV3RawDealProposal = *_Map__MarketV3RawDealProposal

+ func (Map__MarketV3RawDealProposal) AsBool() (bool, error)

+ func (Map__MarketV3RawDealProposal) AsBytes() ([]byte, error)

+ func (Map__MarketV3RawDealProposal) AsFloat() (float64, error)

+ func (Map__MarketV3RawDealProposal) AsInt() (int64, error)

+ func (Map__MarketV3RawDealProposal) AsLink() (ipld.Link, error)

+ func (Map__MarketV3RawDealProposal) AsString() (string, error)

+ func (Map__MarketV3RawDealProposal) IsAbsent() bool

+ func (Map__MarketV3RawDealProposal) IsNull() bool

+ func (Map__MarketV3RawDealProposal) Kind() ipld.Kind

+ func (Map__MarketV3RawDealProposal) ListIterator() ipld.ListIterator

+ func (Map__MarketV3RawDealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MarketV3RawDealProposal) Prototype() ipld.NodePrototype

+ func (Map__MarketV3RawDealProposal) Type() schema.Type

+ func (n Map__MarketV3RawDealProposal) Iterator() *Map__MarketV3RawDealProposal__Itr

+ func (n Map__MarketV3RawDealProposal) Length() int64

+ func (n Map__MarketV3RawDealProposal) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MarketV3RawDealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MarketV3RawDealProposal) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MarketV3RawDealProposal) MapIterator() ipld.MapIterator

+ func (n Map__MarketV3RawDealProposal) Representation() ipld.Node

+ type Map__MarketV3RawDealProposal__Itr struct

+ func (itr *Map__MarketV3RawDealProposal__Itr) Done() bool

+ func (itr *Map__MarketV3RawDealProposal__Itr) Next() (k String, v MarketV2DealProposal)

+ type Map__MinerV0ExpirationSet = *_Map__MinerV0ExpirationSet

+ func (Map__MinerV0ExpirationSet) AsBool() (bool, error)

+ func (Map__MinerV0ExpirationSet) AsBytes() ([]byte, error)

+ func (Map__MinerV0ExpirationSet) AsFloat() (float64, error)

+ func (Map__MinerV0ExpirationSet) AsInt() (int64, error)

+ func (Map__MinerV0ExpirationSet) AsLink() (ipld.Link, error)

+ func (Map__MinerV0ExpirationSet) AsString() (string, error)

+ func (Map__MinerV0ExpirationSet) IsAbsent() bool

+ func (Map__MinerV0ExpirationSet) IsNull() bool

+ func (Map__MinerV0ExpirationSet) Kind() ipld.Kind

+ func (Map__MinerV0ExpirationSet) ListIterator() ipld.ListIterator

+ func (Map__MinerV0ExpirationSet) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MinerV0ExpirationSet) Prototype() ipld.NodePrototype

+ func (Map__MinerV0ExpirationSet) Type() schema.Type

+ func (n Map__MinerV0ExpirationSet) Iterator() *Map__MinerV0ExpirationSet__Itr

+ func (n Map__MinerV0ExpirationSet) Length() int64

+ func (n Map__MinerV0ExpirationSet) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MinerV0ExpirationSet) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MinerV0ExpirationSet) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MinerV0ExpirationSet) MapIterator() ipld.MapIterator

+ func (n Map__MinerV0ExpirationSet) Representation() ipld.Node

+ type Map__MinerV0ExpirationSet__Itr struct

+ func (itr *Map__MinerV0ExpirationSet__Itr) Done() bool

+ func (itr *Map__MinerV0ExpirationSet__Itr) Next() (k String, v MaybeMinerV0ExpirationSet)

+ type Map__MinerV0Partition = *_Map__MinerV0Partition

+ func (Map__MinerV0Partition) AsBool() (bool, error)

+ func (Map__MinerV0Partition) AsBytes() ([]byte, error)

+ func (Map__MinerV0Partition) AsFloat() (float64, error)

+ func (Map__MinerV0Partition) AsInt() (int64, error)

+ func (Map__MinerV0Partition) AsLink() (ipld.Link, error)

+ func (Map__MinerV0Partition) AsString() (string, error)

+ func (Map__MinerV0Partition) IsAbsent() bool

+ func (Map__MinerV0Partition) IsNull() bool

+ func (Map__MinerV0Partition) Kind() ipld.Kind

+ func (Map__MinerV0Partition) ListIterator() ipld.ListIterator

+ func (Map__MinerV0Partition) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MinerV0Partition) Prototype() ipld.NodePrototype

+ func (Map__MinerV0Partition) Type() schema.Type

+ func (n Map__MinerV0Partition) Iterator() *Map__MinerV0Partition__Itr

+ func (n Map__MinerV0Partition) Length() int64

+ func (n Map__MinerV0Partition) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MinerV0Partition) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MinerV0Partition) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MinerV0Partition) MapIterator() ipld.MapIterator

+ func (n Map__MinerV0Partition) Representation() ipld.Node

+ type Map__MinerV0Partition__Itr struct

+ func (itr *Map__MinerV0Partition__Itr) Done() bool

+ func (itr *Map__MinerV0Partition__Itr) Next() (k String, v MaybeMinerV0Partition)

+ type Map__MinerV2Partition = *_Map__MinerV2Partition

+ func (Map__MinerV2Partition) AsBool() (bool, error)

+ func (Map__MinerV2Partition) AsBytes() ([]byte, error)

+ func (Map__MinerV2Partition) AsFloat() (float64, error)

+ func (Map__MinerV2Partition) AsInt() (int64, error)

+ func (Map__MinerV2Partition) AsLink() (ipld.Link, error)

+ func (Map__MinerV2Partition) AsString() (string, error)

+ func (Map__MinerV2Partition) IsAbsent() bool

+ func (Map__MinerV2Partition) IsNull() bool

+ func (Map__MinerV2Partition) Kind() ipld.Kind

+ func (Map__MinerV2Partition) ListIterator() ipld.ListIterator

+ func (Map__MinerV2Partition) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MinerV2Partition) Prototype() ipld.NodePrototype

+ func (Map__MinerV2Partition) Type() schema.Type

+ func (n Map__MinerV2Partition) Iterator() *Map__MinerV2Partition__Itr

+ func (n Map__MinerV2Partition) Length() int64

+ func (n Map__MinerV2Partition) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MinerV2Partition) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MinerV2Partition) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MinerV2Partition) MapIterator() ipld.MapIterator

+ func (n Map__MinerV2Partition) Representation() ipld.Node

+ type Map__MinerV2Partition__Itr struct

+ func (itr *Map__MinerV2Partition__Itr) Done() bool

+ func (itr *Map__MinerV2Partition__Itr) Next() (k String, v MaybeMinerV2Partition)

+ type Map__MinerV3ExpirationSet = *_Map__MinerV3ExpirationSet

+ func (Map__MinerV3ExpirationSet) AsBool() (bool, error)

+ func (Map__MinerV3ExpirationSet) AsBytes() ([]byte, error)

+ func (Map__MinerV3ExpirationSet) AsFloat() (float64, error)

+ func (Map__MinerV3ExpirationSet) AsInt() (int64, error)

+ func (Map__MinerV3ExpirationSet) AsLink() (ipld.Link, error)

+ func (Map__MinerV3ExpirationSet) AsString() (string, error)

+ func (Map__MinerV3ExpirationSet) IsAbsent() bool

+ func (Map__MinerV3ExpirationSet) IsNull() bool

+ func (Map__MinerV3ExpirationSet) Kind() ipld.Kind

+ func (Map__MinerV3ExpirationSet) ListIterator() ipld.ListIterator

+ func (Map__MinerV3ExpirationSet) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MinerV3ExpirationSet) Prototype() ipld.NodePrototype

+ func (Map__MinerV3ExpirationSet) Type() schema.Type

+ func (n Map__MinerV3ExpirationSet) Iterator() *Map__MinerV3ExpirationSet__Itr

+ func (n Map__MinerV3ExpirationSet) Length() int64

+ func (n Map__MinerV3ExpirationSet) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MinerV3ExpirationSet) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MinerV3ExpirationSet) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MinerV3ExpirationSet) MapIterator() ipld.MapIterator

+ func (n Map__MinerV3ExpirationSet) Representation() ipld.Node

+ type Map__MinerV3ExpirationSet__Itr struct

+ func (itr *Map__MinerV3ExpirationSet__Itr) Done() bool

+ func (itr *Map__MinerV3ExpirationSet__Itr) Next() (k String, v MaybeMinerV0ExpirationSet)

+ type Map__MinerV3Partition = *_Map__MinerV3Partition

+ func (Map__MinerV3Partition) AsBool() (bool, error)

+ func (Map__MinerV3Partition) AsBytes() ([]byte, error)

+ func (Map__MinerV3Partition) AsFloat() (float64, error)

+ func (Map__MinerV3Partition) AsInt() (int64, error)

+ func (Map__MinerV3Partition) AsLink() (ipld.Link, error)

+ func (Map__MinerV3Partition) AsString() (string, error)

+ func (Map__MinerV3Partition) IsAbsent() bool

+ func (Map__MinerV3Partition) IsNull() bool

+ func (Map__MinerV3Partition) Kind() ipld.Kind

+ func (Map__MinerV3Partition) ListIterator() ipld.ListIterator

+ func (Map__MinerV3Partition) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MinerV3Partition) Prototype() ipld.NodePrototype

+ func (Map__MinerV3Partition) Type() schema.Type

+ func (n Map__MinerV3Partition) Iterator() *Map__MinerV3Partition__Itr

+ func (n Map__MinerV3Partition) Length() int64

+ func (n Map__MinerV3Partition) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MinerV3Partition) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MinerV3Partition) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MinerV3Partition) MapIterator() ipld.MapIterator

+ func (n Map__MinerV3Partition) Representation() ipld.Node

+ type Map__MinerV3Partition__Itr struct

+ func (itr *Map__MinerV3Partition__Itr) Done() bool

+ func (itr *Map__MinerV3Partition__Itr) Next() (k String, v MaybeMinerV3Partition)

+ type Map__MultisigV0Transaction = *_Map__MultisigV0Transaction

+ func (Map__MultisigV0Transaction) AsBool() (bool, error)

+ func (Map__MultisigV0Transaction) AsBytes() ([]byte, error)

+ func (Map__MultisigV0Transaction) AsFloat() (float64, error)

+ func (Map__MultisigV0Transaction) AsInt() (int64, error)

+ func (Map__MultisigV0Transaction) AsLink() (ipld.Link, error)

+ func (Map__MultisigV0Transaction) AsString() (string, error)

+ func (Map__MultisigV0Transaction) IsAbsent() bool

+ func (Map__MultisigV0Transaction) IsNull() bool

+ func (Map__MultisigV0Transaction) Kind() ipld.Kind

+ func (Map__MultisigV0Transaction) ListIterator() ipld.ListIterator

+ func (Map__MultisigV0Transaction) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MultisigV0Transaction) Prototype() ipld.NodePrototype

+ func (Map__MultisigV0Transaction) Type() schema.Type

+ func (n Map__MultisigV0Transaction) Iterator() *Map__MultisigV0Transaction__Itr

+ func (n Map__MultisigV0Transaction) Length() int64

+ func (n Map__MultisigV0Transaction) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MultisigV0Transaction) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MultisigV0Transaction) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MultisigV0Transaction) MapIterator() ipld.MapIterator

+ func (n Map__MultisigV0Transaction) Representation() ipld.Node

+ type Map__MultisigV0Transaction__Itr struct

+ func (itr *Map__MultisigV0Transaction__Itr) Done() bool

+ func (itr *Map__MultisigV0Transaction__Itr) Next() (k String, v MultisigV0Transaction)

+ type Map__MultisigV3Transaction = *_Map__MultisigV3Transaction

+ func (Map__MultisigV3Transaction) AsBool() (bool, error)

+ func (Map__MultisigV3Transaction) AsBytes() ([]byte, error)

+ func (Map__MultisigV3Transaction) AsFloat() (float64, error)

+ func (Map__MultisigV3Transaction) AsInt() (int64, error)

+ func (Map__MultisigV3Transaction) AsLink() (ipld.Link, error)

+ func (Map__MultisigV3Transaction) AsString() (string, error)

+ func (Map__MultisigV3Transaction) IsAbsent() bool

+ func (Map__MultisigV3Transaction) IsNull() bool

+ func (Map__MultisigV3Transaction) Kind() ipld.Kind

+ func (Map__MultisigV3Transaction) ListIterator() ipld.ListIterator

+ func (Map__MultisigV3Transaction) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__MultisigV3Transaction) Prototype() ipld.NodePrototype

+ func (Map__MultisigV3Transaction) Type() schema.Type

+ func (n Map__MultisigV3Transaction) Iterator() *Map__MultisigV3Transaction__Itr

+ func (n Map__MultisigV3Transaction) Length() int64

+ func (n Map__MultisigV3Transaction) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__MultisigV3Transaction) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__MultisigV3Transaction) LookupByString(k string) (ipld.Node, error)

+ func (n Map__MultisigV3Transaction) MapIterator() ipld.MapIterator

+ func (n Map__MultisigV3Transaction) Representation() ipld.Node

+ type Map__MultisigV3Transaction__Itr struct

+ func (itr *Map__MultisigV3Transaction__Itr) Done() bool

+ func (itr *Map__MultisigV3Transaction__Itr) Next() (k String, v MultisigV0Transaction)

+ type Map__PaychV0LaneState = *_Map__PaychV0LaneState

+ func (Map__PaychV0LaneState) AsBool() (bool, error)

+ func (Map__PaychV0LaneState) AsBytes() ([]byte, error)

+ func (Map__PaychV0LaneState) AsFloat() (float64, error)

+ func (Map__PaychV0LaneState) AsInt() (int64, error)

+ func (Map__PaychV0LaneState) AsLink() (ipld.Link, error)

+ func (Map__PaychV0LaneState) AsString() (string, error)

+ func (Map__PaychV0LaneState) IsAbsent() bool

+ func (Map__PaychV0LaneState) IsNull() bool

+ func (Map__PaychV0LaneState) Kind() ipld.Kind

+ func (Map__PaychV0LaneState) ListIterator() ipld.ListIterator

+ func (Map__PaychV0LaneState) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__PaychV0LaneState) Prototype() ipld.NodePrototype

+ func (Map__PaychV0LaneState) Type() schema.Type

+ func (n Map__PaychV0LaneState) Iterator() *Map__PaychV0LaneState__Itr

+ func (n Map__PaychV0LaneState) Length() int64

+ func (n Map__PaychV0LaneState) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__PaychV0LaneState) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__PaychV0LaneState) LookupByString(k string) (ipld.Node, error)

+ func (n Map__PaychV0LaneState) MapIterator() ipld.MapIterator

+ func (n Map__PaychV0LaneState) Representation() ipld.Node

+ type Map__PaychV0LaneState__Itr struct

+ func (itr *Map__PaychV0LaneState__Itr) Done() bool

+ func (itr *Map__PaychV0LaneState__Itr) Next() (k String, v PaychV0LaneState)

+ type Map__PaychV3LaneState = *_Map__PaychV3LaneState

+ func (Map__PaychV3LaneState) AsBool() (bool, error)

+ func (Map__PaychV3LaneState) AsBytes() ([]byte, error)

+ func (Map__PaychV3LaneState) AsFloat() (float64, error)

+ func (Map__PaychV3LaneState) AsInt() (int64, error)

+ func (Map__PaychV3LaneState) AsLink() (ipld.Link, error)

+ func (Map__PaychV3LaneState) AsString() (string, error)

+ func (Map__PaychV3LaneState) IsAbsent() bool

+ func (Map__PaychV3LaneState) IsNull() bool

+ func (Map__PaychV3LaneState) Kind() ipld.Kind

+ func (Map__PaychV3LaneState) ListIterator() ipld.ListIterator

+ func (Map__PaychV3LaneState) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__PaychV3LaneState) Prototype() ipld.NodePrototype

+ func (Map__PaychV3LaneState) Type() schema.Type

+ func (n Map__PaychV3LaneState) Iterator() *Map__PaychV3LaneState__Itr

+ func (n Map__PaychV3LaneState) Length() int64

+ func (n Map__PaychV3LaneState) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__PaychV3LaneState) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__PaychV3LaneState) LookupByString(k string) (ipld.Node, error)

+ func (n Map__PaychV3LaneState) MapIterator() ipld.MapIterator

+ func (n Map__PaychV3LaneState) Representation() ipld.Node

+ type Map__PaychV3LaneState__Itr struct

+ func (itr *Map__PaychV3LaneState__Itr) Done() bool

+ func (itr *Map__PaychV3LaneState__Itr) Next() (k String, v PaychV0LaneState)

+ type Map__PowerV0Claim = *_Map__PowerV0Claim

+ func (Map__PowerV0Claim) AsBool() (bool, error)

+ func (Map__PowerV0Claim) AsBytes() ([]byte, error)

+ func (Map__PowerV0Claim) AsFloat() (float64, error)

+ func (Map__PowerV0Claim) AsInt() (int64, error)

+ func (Map__PowerV0Claim) AsLink() (ipld.Link, error)

+ func (Map__PowerV0Claim) AsString() (string, error)

+ func (Map__PowerV0Claim) IsAbsent() bool

+ func (Map__PowerV0Claim) IsNull() bool

+ func (Map__PowerV0Claim) Kind() ipld.Kind

+ func (Map__PowerV0Claim) ListIterator() ipld.ListIterator

+ func (Map__PowerV0Claim) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__PowerV0Claim) Prototype() ipld.NodePrototype

+ func (Map__PowerV0Claim) Type() schema.Type

+ func (n Map__PowerV0Claim) Iterator() *Map__PowerV0Claim__Itr

+ func (n Map__PowerV0Claim) Length() int64

+ func (n Map__PowerV0Claim) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__PowerV0Claim) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__PowerV0Claim) LookupByString(k string) (ipld.Node, error)

+ func (n Map__PowerV0Claim) MapIterator() ipld.MapIterator

+ func (n Map__PowerV0Claim) Representation() ipld.Node

+ type Map__PowerV0Claim__Itr struct

+ func (itr *Map__PowerV0Claim__Itr) Done() bool

+ func (itr *Map__PowerV0Claim__Itr) Next() (k RawAddress, v MaybePowerV0Claim)

+ type Map__PowerV0CronEvent = *_Map__PowerV0CronEvent

+ func (Map__PowerV0CronEvent) AsBool() (bool, error)

+ func (Map__PowerV0CronEvent) AsBytes() ([]byte, error)

+ func (Map__PowerV0CronEvent) AsFloat() (float64, error)

+ func (Map__PowerV0CronEvent) AsInt() (int64, error)

+ func (Map__PowerV0CronEvent) AsLink() (ipld.Link, error)

+ func (Map__PowerV0CronEvent) AsString() (string, error)

+ func (Map__PowerV0CronEvent) IsAbsent() bool

+ func (Map__PowerV0CronEvent) IsNull() bool

+ func (Map__PowerV0CronEvent) Kind() ipld.Kind

+ func (Map__PowerV0CronEvent) ListIterator() ipld.ListIterator

+ func (Map__PowerV0CronEvent) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__PowerV0CronEvent) Prototype() ipld.NodePrototype

+ func (Map__PowerV0CronEvent) Type() schema.Type

+ func (n Map__PowerV0CronEvent) Iterator() *Map__PowerV0CronEvent__Itr

+ func (n Map__PowerV0CronEvent) Length() int64

+ func (n Map__PowerV0CronEvent) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__PowerV0CronEvent) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__PowerV0CronEvent) LookupByString(k string) (ipld.Node, error)

+ func (n Map__PowerV0CronEvent) MapIterator() ipld.MapIterator

+ func (n Map__PowerV0CronEvent) Representation() ipld.Node

+ type Map__PowerV0CronEvent__Itr struct

+ func (itr *Map__PowerV0CronEvent__Itr) Done() bool

+ func (itr *Map__PowerV0CronEvent__Itr) Next() (k String, v MaybePowerV0CronEvent)

+ type Map__PowerV2Claim = *_Map__PowerV2Claim

+ func (Map__PowerV2Claim) AsBool() (bool, error)

+ func (Map__PowerV2Claim) AsBytes() ([]byte, error)

+ func (Map__PowerV2Claim) AsFloat() (float64, error)

+ func (Map__PowerV2Claim) AsInt() (int64, error)

+ func (Map__PowerV2Claim) AsLink() (ipld.Link, error)

+ func (Map__PowerV2Claim) AsString() (string, error)

+ func (Map__PowerV2Claim) IsAbsent() bool

+ func (Map__PowerV2Claim) IsNull() bool

+ func (Map__PowerV2Claim) Kind() ipld.Kind

+ func (Map__PowerV2Claim) ListIterator() ipld.ListIterator

+ func (Map__PowerV2Claim) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__PowerV2Claim) Prototype() ipld.NodePrototype

+ func (Map__PowerV2Claim) Type() schema.Type

+ func (n Map__PowerV2Claim) Iterator() *Map__PowerV2Claim__Itr

+ func (n Map__PowerV2Claim) Length() int64

+ func (n Map__PowerV2Claim) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__PowerV2Claim) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__PowerV2Claim) LookupByString(k string) (ipld.Node, error)

+ func (n Map__PowerV2Claim) MapIterator() ipld.MapIterator

+ func (n Map__PowerV2Claim) Representation() ipld.Node

+ type Map__PowerV2Claim__Itr struct

+ func (itr *Map__PowerV2Claim__Itr) Done() bool

+ func (itr *Map__PowerV2Claim__Itr) Next() (k RawAddress, v MaybePowerV2Claim)

+ type Map__PowerV3Claim = *_Map__PowerV3Claim

+ func (Map__PowerV3Claim) AsBool() (bool, error)

+ func (Map__PowerV3Claim) AsBytes() ([]byte, error)

+ func (Map__PowerV3Claim) AsFloat() (float64, error)

+ func (Map__PowerV3Claim) AsInt() (int64, error)

+ func (Map__PowerV3Claim) AsLink() (ipld.Link, error)

+ func (Map__PowerV3Claim) AsString() (string, error)

+ func (Map__PowerV3Claim) IsAbsent() bool

+ func (Map__PowerV3Claim) IsNull() bool

+ func (Map__PowerV3Claim) Kind() ipld.Kind

+ func (Map__PowerV3Claim) ListIterator() ipld.ListIterator

+ func (Map__PowerV3Claim) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__PowerV3Claim) Prototype() ipld.NodePrototype

+ func (Map__PowerV3Claim) Type() schema.Type

+ func (n Map__PowerV3Claim) Iterator() *Map__PowerV3Claim__Itr

+ func (n Map__PowerV3Claim) Length() int64

+ func (n Map__PowerV3Claim) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__PowerV3Claim) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__PowerV3Claim) LookupByString(k string) (ipld.Node, error)

+ func (n Map__PowerV3Claim) MapIterator() ipld.MapIterator

+ func (n Map__PowerV3Claim) Representation() ipld.Node

+ type Map__PowerV3Claim__Itr struct

+ func (itr *Map__PowerV3Claim__Itr) Done() bool

+ func (itr *Map__PowerV3Claim__Itr) Next() (k RawAddress, v MaybePowerV2Claim)

+ type Map__PowerV3CronEvent = *_Map__PowerV3CronEvent

+ func (Map__PowerV3CronEvent) AsBool() (bool, error)

+ func (Map__PowerV3CronEvent) AsBytes() ([]byte, error)

+ func (Map__PowerV3CronEvent) AsFloat() (float64, error)

+ func (Map__PowerV3CronEvent) AsInt() (int64, error)

+ func (Map__PowerV3CronEvent) AsLink() (ipld.Link, error)

+ func (Map__PowerV3CronEvent) AsString() (string, error)

+ func (Map__PowerV3CronEvent) IsAbsent() bool

+ func (Map__PowerV3CronEvent) IsNull() bool

+ func (Map__PowerV3CronEvent) Kind() ipld.Kind

+ func (Map__PowerV3CronEvent) ListIterator() ipld.ListIterator

+ func (Map__PowerV3CronEvent) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__PowerV3CronEvent) Prototype() ipld.NodePrototype

+ func (Map__PowerV3CronEvent) Type() schema.Type

+ func (n Map__PowerV3CronEvent) Iterator() *Map__PowerV3CronEvent__Itr

+ func (n Map__PowerV3CronEvent) Length() int64

+ func (n Map__PowerV3CronEvent) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__PowerV3CronEvent) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__PowerV3CronEvent) LookupByString(k string) (ipld.Node, error)

+ func (n Map__PowerV3CronEvent) MapIterator() ipld.MapIterator

+ func (n Map__PowerV3CronEvent) Representation() ipld.Node

+ type Map__PowerV3CronEvent__Itr struct

+ func (itr *Map__PowerV3CronEvent__Itr) Done() bool

+ func (itr *Map__PowerV3CronEvent__Itr) Next() (k String, v MaybePowerV0CronEvent)

+ type Map__SectorOnChainInfo = *_Map__SectorOnChainInfo

+ func (Map__SectorOnChainInfo) AsBool() (bool, error)

+ func (Map__SectorOnChainInfo) AsBytes() ([]byte, error)

+ func (Map__SectorOnChainInfo) AsFloat() (float64, error)

+ func (Map__SectorOnChainInfo) AsInt() (int64, error)

+ func (Map__SectorOnChainInfo) AsLink() (ipld.Link, error)

+ func (Map__SectorOnChainInfo) AsString() (string, error)

+ func (Map__SectorOnChainInfo) IsAbsent() bool

+ func (Map__SectorOnChainInfo) IsNull() bool

+ func (Map__SectorOnChainInfo) Kind() ipld.Kind

+ func (Map__SectorOnChainInfo) ListIterator() ipld.ListIterator

+ func (Map__SectorOnChainInfo) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__SectorOnChainInfo) Prototype() ipld.NodePrototype

+ func (Map__SectorOnChainInfo) Type() schema.Type

+ func (n Map__SectorOnChainInfo) Iterator() *Map__SectorOnChainInfo__Itr

+ func (n Map__SectorOnChainInfo) Length() int64

+ func (n Map__SectorOnChainInfo) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__SectorOnChainInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__SectorOnChainInfo) LookupByString(k string) (ipld.Node, error)

+ func (n Map__SectorOnChainInfo) MapIterator() ipld.MapIterator

+ func (n Map__SectorOnChainInfo) Representation() ipld.Node

+ type Map__SectorOnChainInfo__Itr struct

+ func (itr *Map__SectorOnChainInfo__Itr) Done() bool

+ func (itr *Map__SectorOnChainInfo__Itr) Next() (k String, v MaybeMinerV0SectorOnChainInfo)

+ type Map__SectorPreCommitOnChainInfo = *_Map__SectorPreCommitOnChainInfo

+ func (Map__SectorPreCommitOnChainInfo) AsBool() (bool, error)

+ func (Map__SectorPreCommitOnChainInfo) AsBytes() ([]byte, error)

+ func (Map__SectorPreCommitOnChainInfo) AsFloat() (float64, error)

+ func (Map__SectorPreCommitOnChainInfo) AsInt() (int64, error)

+ func (Map__SectorPreCommitOnChainInfo) AsLink() (ipld.Link, error)

+ func (Map__SectorPreCommitOnChainInfo) AsString() (string, error)

+ func (Map__SectorPreCommitOnChainInfo) IsAbsent() bool

+ func (Map__SectorPreCommitOnChainInfo) IsNull() bool

+ func (Map__SectorPreCommitOnChainInfo) Kind() ipld.Kind

+ func (Map__SectorPreCommitOnChainInfo) ListIterator() ipld.ListIterator

+ func (Map__SectorPreCommitOnChainInfo) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__SectorPreCommitOnChainInfo) Prototype() ipld.NodePrototype

+ func (Map__SectorPreCommitOnChainInfo) Type() schema.Type

+ func (n Map__SectorPreCommitOnChainInfo) Iterator() *Map__SectorPreCommitOnChainInfo__Itr

+ func (n Map__SectorPreCommitOnChainInfo) Length() int64

+ func (n Map__SectorPreCommitOnChainInfo) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__SectorPreCommitOnChainInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__SectorPreCommitOnChainInfo) LookupByString(k string) (ipld.Node, error)

+ func (n Map__SectorPreCommitOnChainInfo) MapIterator() ipld.MapIterator

+ func (n Map__SectorPreCommitOnChainInfo) Representation() ipld.Node

+ type Map__SectorPreCommitOnChainInfo__Itr struct

+ func (itr *Map__SectorPreCommitOnChainInfo__Itr) Done() bool

+ func (itr *Map__SectorPreCommitOnChainInfo__Itr) Next() (k String, v MaybeMinerV0SectorPreCommitOnChainInfo)

+ type Map__SectorV2OnChainInfo = *_Map__SectorV2OnChainInfo

+ func (Map__SectorV2OnChainInfo) AsBool() (bool, error)

+ func (Map__SectorV2OnChainInfo) AsBytes() ([]byte, error)

+ func (Map__SectorV2OnChainInfo) AsFloat() (float64, error)

+ func (Map__SectorV2OnChainInfo) AsInt() (int64, error)

+ func (Map__SectorV2OnChainInfo) AsLink() (ipld.Link, error)

+ func (Map__SectorV2OnChainInfo) AsString() (string, error)

+ func (Map__SectorV2OnChainInfo) IsAbsent() bool

+ func (Map__SectorV2OnChainInfo) IsNull() bool

+ func (Map__SectorV2OnChainInfo) Kind() ipld.Kind

+ func (Map__SectorV2OnChainInfo) ListIterator() ipld.ListIterator

+ func (Map__SectorV2OnChainInfo) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__SectorV2OnChainInfo) Prototype() ipld.NodePrototype

+ func (Map__SectorV2OnChainInfo) Type() schema.Type

+ func (n Map__SectorV2OnChainInfo) Iterator() *Map__SectorV2OnChainInfo__Itr

+ func (n Map__SectorV2OnChainInfo) Length() int64

+ func (n Map__SectorV2OnChainInfo) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__SectorV2OnChainInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__SectorV2OnChainInfo) LookupByString(k string) (ipld.Node, error)

+ func (n Map__SectorV2OnChainInfo) MapIterator() ipld.MapIterator

+ func (n Map__SectorV2OnChainInfo) Representation() ipld.Node

+ type Map__SectorV2OnChainInfo__Itr struct

+ func (itr *Map__SectorV2OnChainInfo__Itr) Done() bool

+ func (itr *Map__SectorV2OnChainInfo__Itr) Next() (k String, v MaybeMinerV2SectorOnChainInfo)

+ type Map__SectorV3OnChainInfo = *_Map__SectorV3OnChainInfo

+ func (Map__SectorV3OnChainInfo) AsBool() (bool, error)

+ func (Map__SectorV3OnChainInfo) AsBytes() ([]byte, error)

+ func (Map__SectorV3OnChainInfo) AsFloat() (float64, error)

+ func (Map__SectorV3OnChainInfo) AsInt() (int64, error)

+ func (Map__SectorV3OnChainInfo) AsLink() (ipld.Link, error)

+ func (Map__SectorV3OnChainInfo) AsString() (string, error)

+ func (Map__SectorV3OnChainInfo) IsAbsent() bool

+ func (Map__SectorV3OnChainInfo) IsNull() bool

+ func (Map__SectorV3OnChainInfo) Kind() ipld.Kind

+ func (Map__SectorV3OnChainInfo) ListIterator() ipld.ListIterator

+ func (Map__SectorV3OnChainInfo) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__SectorV3OnChainInfo) Prototype() ipld.NodePrototype

+ func (Map__SectorV3OnChainInfo) Type() schema.Type

+ func (n Map__SectorV3OnChainInfo) Iterator() *Map__SectorV3OnChainInfo__Itr

+ func (n Map__SectorV3OnChainInfo) Length() int64

+ func (n Map__SectorV3OnChainInfo) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__SectorV3OnChainInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__SectorV3OnChainInfo) LookupByString(k string) (ipld.Node, error)

+ func (n Map__SectorV3OnChainInfo) MapIterator() ipld.MapIterator

+ func (n Map__SectorV3OnChainInfo) Representation() ipld.Node

+ type Map__SectorV3OnChainInfo__Itr struct

+ func (itr *Map__SectorV3OnChainInfo__Itr) Done() bool

+ func (itr *Map__SectorV3OnChainInfo__Itr) Next() (k String, v MaybeMinerV2SectorOnChainInfo)

+ type Map__V3ActorID = *_Map__V3ActorID

+ func (Map__V3ActorID) AsBool() (bool, error)

+ func (Map__V3ActorID) AsBytes() ([]byte, error)

+ func (Map__V3ActorID) AsFloat() (float64, error)

+ func (Map__V3ActorID) AsInt() (int64, error)

+ func (Map__V3ActorID) AsLink() (ipld.Link, error)

+ func (Map__V3ActorID) AsString() (string, error)

+ func (Map__V3ActorID) IsAbsent() bool

+ func (Map__V3ActorID) IsNull() bool

+ func (Map__V3ActorID) Kind() ipld.Kind

+ func (Map__V3ActorID) ListIterator() ipld.ListIterator

+ func (Map__V3ActorID) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__V3ActorID) Prototype() ipld.NodePrototype

+ func (Map__V3ActorID) Type() schema.Type

+ func (n Map__V3ActorID) Iterator() *Map__V3ActorID__Itr

+ func (n Map__V3ActorID) Length() int64

+ func (n Map__V3ActorID) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__V3ActorID) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__V3ActorID) LookupByString(k string) (ipld.Node, error)

+ func (n Map__V3ActorID) MapIterator() ipld.MapIterator

+ func (n Map__V3ActorID) Representation() ipld.Node

+ type Map__V3ActorID__Itr struct

+ func (itr *Map__V3ActorID__Itr) Done() bool

+ func (itr *Map__V3ActorID__Itr) Next() (k RawAddress, v ActorID)

+ type Map__V3BalanceTable = *_Map__V3BalanceTable

+ func (Map__V3BalanceTable) AsBool() (bool, error)

+ func (Map__V3BalanceTable) AsBytes() ([]byte, error)

+ func (Map__V3BalanceTable) AsFloat() (float64, error)

+ func (Map__V3BalanceTable) AsInt() (int64, error)

+ func (Map__V3BalanceTable) AsLink() (ipld.Link, error)

+ func (Map__V3BalanceTable) AsString() (string, error)

+ func (Map__V3BalanceTable) IsAbsent() bool

+ func (Map__V3BalanceTable) IsNull() bool

+ func (Map__V3BalanceTable) Kind() ipld.Kind

+ func (Map__V3BalanceTable) ListIterator() ipld.ListIterator

+ func (Map__V3BalanceTable) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__V3BalanceTable) Prototype() ipld.NodePrototype

+ func (Map__V3BalanceTable) Type() schema.Type

+ func (n Map__V3BalanceTable) Iterator() *Map__V3BalanceTable__Itr

+ func (n Map__V3BalanceTable) Length() int64

+ func (n Map__V3BalanceTable) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__V3BalanceTable) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__V3BalanceTable) LookupByString(k string) (ipld.Node, error)

+ func (n Map__V3BalanceTable) MapIterator() ipld.MapIterator

+ func (n Map__V3BalanceTable) Representation() ipld.Node

+ type Map__V3BalanceTable__Itr struct

+ func (itr *Map__V3BalanceTable__Itr) Done() bool

+ func (itr *Map__V3BalanceTable__Itr) Next() (k RawAddress, v BigInt)

+ type Map__V3DataCap = *_Map__V3DataCap

+ func (Map__V3DataCap) AsBool() (bool, error)

+ func (Map__V3DataCap) AsBytes() ([]byte, error)

+ func (Map__V3DataCap) AsFloat() (float64, error)

+ func (Map__V3DataCap) AsInt() (int64, error)

+ func (Map__V3DataCap) AsLink() (ipld.Link, error)

+ func (Map__V3DataCap) AsString() (string, error)

+ func (Map__V3DataCap) IsAbsent() bool

+ func (Map__V3DataCap) IsNull() bool

+ func (Map__V3DataCap) Kind() ipld.Kind

+ func (Map__V3DataCap) ListIterator() ipld.ListIterator

+ func (Map__V3DataCap) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__V3DataCap) Prototype() ipld.NodePrototype

+ func (Map__V3DataCap) Type() schema.Type

+ func (n Map__V3DataCap) Iterator() *Map__V3DataCap__Itr

+ func (n Map__V3DataCap) Length() int64

+ func (n Map__V3DataCap) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__V3DataCap) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__V3DataCap) LookupByString(k string) (ipld.Node, error)

+ func (n Map__V3DataCap) MapIterator() ipld.MapIterator

+ func (n Map__V3DataCap) Representation() ipld.Node

+ type Map__V3DataCap__Itr struct

+ func (itr *Map__V3DataCap__Itr) Done() bool

+ func (itr *Map__V3DataCap__Itr) Next() (k RawAddress, v BigInt)

+ type Map__V3SectorPreCommitOnChainInfo = *_Map__V3SectorPreCommitOnChainInfo

+ func (Map__V3SectorPreCommitOnChainInfo) AsBool() (bool, error)

+ func (Map__V3SectorPreCommitOnChainInfo) AsBytes() ([]byte, error)

+ func (Map__V3SectorPreCommitOnChainInfo) AsFloat() (float64, error)

+ func (Map__V3SectorPreCommitOnChainInfo) AsInt() (int64, error)

+ func (Map__V3SectorPreCommitOnChainInfo) AsLink() (ipld.Link, error)

+ func (Map__V3SectorPreCommitOnChainInfo) AsString() (string, error)

+ func (Map__V3SectorPreCommitOnChainInfo) IsAbsent() bool

+ func (Map__V3SectorPreCommitOnChainInfo) IsNull() bool

+ func (Map__V3SectorPreCommitOnChainInfo) Kind() ipld.Kind

+ func (Map__V3SectorPreCommitOnChainInfo) ListIterator() ipld.ListIterator

+ func (Map__V3SectorPreCommitOnChainInfo) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Map__V3SectorPreCommitOnChainInfo) Prototype() ipld.NodePrototype

+ func (Map__V3SectorPreCommitOnChainInfo) Type() schema.Type

+ func (n Map__V3SectorPreCommitOnChainInfo) Iterator() *Map__V3SectorPreCommitOnChainInfo__Itr

+ func (n Map__V3SectorPreCommitOnChainInfo) Length() int64

+ func (n Map__V3SectorPreCommitOnChainInfo) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Map__V3SectorPreCommitOnChainInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Map__V3SectorPreCommitOnChainInfo) LookupByString(k string) (ipld.Node, error)

+ func (n Map__V3SectorPreCommitOnChainInfo) MapIterator() ipld.MapIterator

+ func (n Map__V3SectorPreCommitOnChainInfo) Representation() ipld.Node

+ type Map__V3SectorPreCommitOnChainInfo__Itr struct

+ func (itr *Map__V3SectorPreCommitOnChainInfo__Itr) Done() bool

+ func (itr *Map__V3SectorPreCommitOnChainInfo__Itr) Next() (k String, v MaybeMinerV0SectorPreCommitOnChainInfo)

+ type Mapv3__LotusActors = *_Mapv3__LotusActors

+ func (Mapv3__LotusActors) AsBool() (bool, error)

+ func (Mapv3__LotusActors) AsBytes() ([]byte, error)

+ func (Mapv3__LotusActors) AsFloat() (float64, error)

+ func (Mapv3__LotusActors) AsInt() (int64, error)

+ func (Mapv3__LotusActors) AsLink() (ipld.Link, error)

+ func (Mapv3__LotusActors) AsString() (string, error)

+ func (Mapv3__LotusActors) IsAbsent() bool

+ func (Mapv3__LotusActors) IsNull() bool

+ func (Mapv3__LotusActors) Kind() ipld.Kind

+ func (Mapv3__LotusActors) ListIterator() ipld.ListIterator

+ func (Mapv3__LotusActors) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Mapv3__LotusActors) Prototype() ipld.NodePrototype

+ func (Mapv3__LotusActors) Type() schema.Type

+ func (n Mapv3__LotusActors) Iterator() *Mapv3__LotusActors__Itr

+ func (n Mapv3__LotusActors) Length() int64

+ func (n Mapv3__LotusActors) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Mapv3__LotusActors) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Mapv3__LotusActors) LookupByString(k string) (ipld.Node, error)

+ func (n Mapv3__LotusActors) MapIterator() ipld.MapIterator

+ func (n Mapv3__LotusActors) Representation() ipld.Node

+ type Mapv3__LotusActors__Itr struct

+ func (itr *Mapv3__LotusActors__Itr) Done() bool

+ func (itr *Mapv3__LotusActors__Itr) Next() (k RawAddress, v LotusActors)

+ type MarketClientDealProposal = *_MarketClientDealProposal

+ func (MarketClientDealProposal) AsBool() (bool, error)

+ func (MarketClientDealProposal) AsBytes() ([]byte, error)

+ func (MarketClientDealProposal) AsFloat() (float64, error)

+ func (MarketClientDealProposal) AsInt() (int64, error)

+ func (MarketClientDealProposal) AsLink() (ipld.Link, error)

+ func (MarketClientDealProposal) AsString() (string, error)

+ func (MarketClientDealProposal) IsAbsent() bool

+ func (MarketClientDealProposal) IsNull() bool

+ func (MarketClientDealProposal) Kind() ipld.Kind

+ func (MarketClientDealProposal) Length() int64

+ func (MarketClientDealProposal) ListIterator() ipld.ListIterator

+ func (MarketClientDealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MarketClientDealProposal) Prototype() ipld.NodePrototype

+ func (MarketClientDealProposal) Type() schema.Type

+ func (n MarketClientDealProposal) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MarketClientDealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MarketClientDealProposal) LookupByString(key string) (ipld.Node, error)

+ func (n MarketClientDealProposal) MapIterator() ipld.MapIterator

+ func (n MarketClientDealProposal) Representation() ipld.Node

+ type MarketV0DealProposal = *_MarketV0DealProposal

+ func (MarketV0DealProposal) AsBool() (bool, error)

+ func (MarketV0DealProposal) AsBytes() ([]byte, error)

+ func (MarketV0DealProposal) AsFloat() (float64, error)

+ func (MarketV0DealProposal) AsInt() (int64, error)

+ func (MarketV0DealProposal) AsLink() (ipld.Link, error)

+ func (MarketV0DealProposal) AsString() (string, error)

+ func (MarketV0DealProposal) IsAbsent() bool

+ func (MarketV0DealProposal) IsNull() bool

+ func (MarketV0DealProposal) Kind() ipld.Kind

+ func (MarketV0DealProposal) Length() int64

+ func (MarketV0DealProposal) ListIterator() ipld.ListIterator

+ func (MarketV0DealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MarketV0DealProposal) Prototype() ipld.NodePrototype

+ func (MarketV0DealProposal) Type() schema.Type

+ func (n MarketV0DealProposal) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MarketV0DealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MarketV0DealProposal) LookupByString(key string) (ipld.Node, error)

+ func (n MarketV0DealProposal) MapIterator() ipld.MapIterator

+ func (n MarketV0DealProposal) Representation() ipld.Node

+ type MarketV0DealState = *_MarketV0DealState

+ func (MarketV0DealState) AsBool() (bool, error)

+ func (MarketV0DealState) AsBytes() ([]byte, error)

+ func (MarketV0DealState) AsFloat() (float64, error)

+ func (MarketV0DealState) AsInt() (int64, error)

+ func (MarketV0DealState) AsLink() (ipld.Link, error)

+ func (MarketV0DealState) AsString() (string, error)

+ func (MarketV0DealState) IsAbsent() bool

+ func (MarketV0DealState) IsNull() bool

+ func (MarketV0DealState) Kind() ipld.Kind

+ func (MarketV0DealState) Length() int64

+ func (MarketV0DealState) ListIterator() ipld.ListIterator

+ func (MarketV0DealState) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MarketV0DealState) Prototype() ipld.NodePrototype

+ func (MarketV0DealState) Type() schema.Type

+ func (n MarketV0DealState) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MarketV0DealState) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MarketV0DealState) LookupByString(key string) (ipld.Node, error)

+ func (n MarketV0DealState) MapIterator() ipld.MapIterator

+ func (n MarketV0DealState) Representation() ipld.Node

+ type MarketV0State = *_MarketV0State

+ func (MarketV0State) AsBool() (bool, error)

+ func (MarketV0State) AsBytes() ([]byte, error)

+ func (MarketV0State) AsFloat() (float64, error)

+ func (MarketV0State) AsInt() (int64, error)

+ func (MarketV0State) AsLink() (ipld.Link, error)

+ func (MarketV0State) AsString() (string, error)

+ func (MarketV0State) IsAbsent() bool

+ func (MarketV0State) IsNull() bool

+ func (MarketV0State) Kind() ipld.Kind

+ func (MarketV0State) Length() int64

+ func (MarketV0State) ListIterator() ipld.ListIterator

+ func (MarketV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MarketV0State) Prototype() ipld.NodePrototype

+ func (MarketV0State) Type() schema.Type

+ func (n MarketV0State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MarketV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MarketV0State) LookupByString(key string) (ipld.Node, error)

+ func (n MarketV0State) MapIterator() ipld.MapIterator

+ func (n MarketV0State) Representation() ipld.Node

+ type MarketV2DealProposal = *_MarketV2DealProposal

+ func (MarketV2DealProposal) AsBool() (bool, error)

+ func (MarketV2DealProposal) AsBytes() ([]byte, error)

+ func (MarketV2DealProposal) AsFloat() (float64, error)

+ func (MarketV2DealProposal) AsInt() (int64, error)

+ func (MarketV2DealProposal) AsLink() (ipld.Link, error)

+ func (MarketV2DealProposal) AsString() (string, error)

+ func (MarketV2DealProposal) IsAbsent() bool

+ func (MarketV2DealProposal) IsNull() bool

+ func (MarketV2DealProposal) Kind() ipld.Kind

+ func (MarketV2DealProposal) Length() int64

+ func (MarketV2DealProposal) ListIterator() ipld.ListIterator

+ func (MarketV2DealProposal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MarketV2DealProposal) Prototype() ipld.NodePrototype

+ func (MarketV2DealProposal) Type() schema.Type

+ func (n MarketV2DealProposal) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MarketV2DealProposal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MarketV2DealProposal) LookupByString(key string) (ipld.Node, error)

+ func (n MarketV2DealProposal) MapIterator() ipld.MapIterator

+ func (n MarketV2DealProposal) Representation() ipld.Node

+ type MarketV2State = *_MarketV2State

+ func (MarketV2State) AsBool() (bool, error)

+ func (MarketV2State) AsBytes() ([]byte, error)

+ func (MarketV2State) AsFloat() (float64, error)

+ func (MarketV2State) AsInt() (int64, error)

+ func (MarketV2State) AsLink() (ipld.Link, error)

+ func (MarketV2State) AsString() (string, error)

+ func (MarketV2State) IsAbsent() bool

+ func (MarketV2State) IsNull() bool

+ func (MarketV2State) Kind() ipld.Kind

+ func (MarketV2State) Length() int64

+ func (MarketV2State) ListIterator() ipld.ListIterator

+ func (MarketV2State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MarketV2State) Prototype() ipld.NodePrototype

+ func (MarketV2State) Type() schema.Type

+ func (n MarketV2State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MarketV2State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MarketV2State) LookupByString(key string) (ipld.Node, error)

+ func (n MarketV2State) MapIterator() ipld.MapIterator

+ func (n MarketV2State) Representation() ipld.Node

+ type MarketV3State = *_MarketV3State

+ func (MarketV3State) AsBool() (bool, error)

+ func (MarketV3State) AsBytes() ([]byte, error)

+ func (MarketV3State) AsFloat() (float64, error)

+ func (MarketV3State) AsInt() (int64, error)

+ func (MarketV3State) AsLink() (ipld.Link, error)

+ func (MarketV3State) AsString() (string, error)

+ func (MarketV3State) IsAbsent() bool

+ func (MarketV3State) IsNull() bool

+ func (MarketV3State) Kind() ipld.Kind

+ func (MarketV3State) Length() int64

+ func (MarketV3State) ListIterator() ipld.ListIterator

+ func (MarketV3State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MarketV3State) Prototype() ipld.NodePrototype

+ func (MarketV3State) Type() schema.Type

+ func (n MarketV3State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MarketV3State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MarketV3State) LookupByString(key string) (ipld.Node, error)

+ func (n MarketV3State) MapIterator() ipld.MapIterator

+ func (n MarketV3State) Representation() ipld.Node

+ type MarketV5State = *_MarketV5State

+ func (MarketV5State) AsBool() (bool, error)

+ func (MarketV5State) AsBytes() ([]byte, error)

+ func (MarketV5State) AsFloat() (float64, error)

+ func (MarketV5State) AsInt() (int64, error)

+ func (MarketV5State) AsLink() (ipld.Link, error)

+ func (MarketV5State) AsString() (string, error)

+ func (MarketV5State) IsAbsent() bool

+ func (MarketV5State) IsNull() bool

+ func (MarketV5State) Kind() ipld.Kind

+ func (MarketV5State) Length() int64

+ func (MarketV5State) ListIterator() ipld.ListIterator

+ func (MarketV5State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MarketV5State) Prototype() ipld.NodePrototype

+ func (MarketV5State) Type() schema.Type

+ func (n MarketV5State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MarketV5State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MarketV5State) LookupByString(key string) (ipld.Node, error)

+ func (n MarketV5State) MapIterator() ipld.MapIterator

+ func (n MarketV5State) Representation() ipld.Node

+ type MaybeAccountV0State = *_AccountV0State__Maybe

+ func (m MaybeAccountV0State) AsNode() ipld.Node

+ func (m MaybeAccountV0State) Exists() bool

+ func (m MaybeAccountV0State) IsAbsent() bool

+ func (m MaybeAccountV0State) IsNull() bool

+ func (m MaybeAccountV0State) Must() AccountV0State

+ type MaybeActorID = *_ActorID__Maybe

+ func (m MaybeActorID) AsNode() ipld.Node

+ func (m MaybeActorID) Exists() bool

+ func (m MaybeActorID) IsAbsent() bool

+ func (m MaybeActorID) IsNull() bool

+ func (m MaybeActorID) Must() ActorID

+ type MaybeAddress = *_Address__Maybe

+ func (m MaybeAddress) AsNode() ipld.Node

+ func (m MaybeAddress) Exists() bool

+ func (m MaybeAddress) IsAbsent() bool

+ func (m MaybeAddress) IsNull() bool

+ func (m MaybeAddress) Must() Address

+ type MaybeAny = *_Any__Maybe

+ func (m MaybeAny) AsNode() ipld.Node

+ func (m MaybeAny) Exists() bool

+ func (m MaybeAny) IsAbsent() bool

+ func (m MaybeAny) IsNull() bool

+ func (m MaybeAny) Must() Any

+ type MaybeApplyRewardParams = *_ApplyRewardParams__Maybe

+ func (m MaybeApplyRewardParams) AsNode() ipld.Node

+ func (m MaybeApplyRewardParams) Exists() bool

+ func (m MaybeApplyRewardParams) IsAbsent() bool

+ func (m MaybeApplyRewardParams) IsNull() bool

+ func (m MaybeApplyRewardParams) Must() ApplyRewardParams

+ type MaybeBigInt = *_BigInt__Maybe

+ func (m MaybeBigInt) AsNode() ipld.Node

+ func (m MaybeBigInt) Exists() bool

+ func (m MaybeBigInt) IsAbsent() bool

+ func (m MaybeBigInt) IsNull() bool

+ func (m MaybeBigInt) Must() BigInt

+ type MaybeBitField = *_BitField__Maybe

+ func (m MaybeBitField) AsNode() ipld.Node

+ func (m MaybeBitField) Exists() bool

+ func (m MaybeBitField) IsAbsent() bool

+ func (m MaybeBitField) IsNull() bool

+ func (m MaybeBitField) Must() BitField

+ type MaybeBool = *_Bool__Maybe

+ func (m MaybeBool) AsNode() ipld.Node

+ func (m MaybeBool) Exists() bool

+ func (m MaybeBool) IsAbsent() bool

+ func (m MaybeBool) IsNull() bool

+ func (m MaybeBool) Must() Bool

+ type MaybeBytes = *_Bytes__Maybe

+ func (m MaybeBytes) AsNode() ipld.Node

+ func (m MaybeBytes) Exists() bool

+ func (m MaybeBytes) IsAbsent() bool

+ func (m MaybeBytes) IsNull() bool

+ func (m MaybeBytes) Must() Bytes

+ type MaybeChainEpoch = *_ChainEpoch__Maybe

+ func (m MaybeChainEpoch) AsNode() ipld.Node

+ func (m MaybeChainEpoch) Exists() bool

+ func (m MaybeChainEpoch) IsAbsent() bool

+ func (m MaybeChainEpoch) IsNull() bool

+ func (m MaybeChainEpoch) Must() ChainEpoch

+ type MaybeCidString = *_CidString__Maybe

+ func (m MaybeCidString) AsNode() ipld.Node

+ func (m MaybeCidString) Exists() bool

+ func (m MaybeCidString) IsAbsent() bool

+ func (m MaybeCidString) IsNull() bool

+ func (m MaybeCidString) Must() CidString

+ type MaybeCronV0Entry = *_CronV0Entry__Maybe

+ func (m MaybeCronV0Entry) AsNode() ipld.Node

+ func (m MaybeCronV0Entry) Exists() bool

+ func (m MaybeCronV0Entry) IsAbsent() bool

+ func (m MaybeCronV0Entry) IsNull() bool

+ func (m MaybeCronV0Entry) Must() CronV0Entry

+ type MaybeCronV0State = *_CronV0State__Maybe

+ func (m MaybeCronV0State) AsNode() ipld.Node

+ func (m MaybeCronV0State) Exists() bool

+ func (m MaybeCronV0State) IsAbsent() bool

+ func (m MaybeCronV0State) IsNull() bool

+ func (m MaybeCronV0State) Must() CronV0State

+ type MaybeDealID = *_DealID__Maybe

+ func (m MaybeDealID) AsNode() ipld.Node

+ func (m MaybeDealID) Exists() bool

+ func (m MaybeDealID) IsAbsent() bool

+ func (m MaybeDealID) IsNull() bool

+ func (m MaybeDealID) Must() DealID

+ type MaybeFloat = *_Float__Maybe

+ func (m MaybeFloat) AsNode() ipld.Node

+ func (m MaybeFloat) Exists() bool

+ func (m MaybeFloat) IsAbsent() bool

+ func (m MaybeFloat) IsNull() bool

+ func (m MaybeFloat) Must() Float

+ type MaybeInitV0State = *_InitV0State__Maybe

+ func (m MaybeInitV0State) AsNode() ipld.Node

+ func (m MaybeInitV0State) Exists() bool

+ func (m MaybeInitV0State) IsAbsent() bool

+ func (m MaybeInitV0State) IsNull() bool

+ func (m MaybeInitV0State) Must() InitV0State

+ type MaybeInitV3State = *_InitV3State__Maybe

+ func (m MaybeInitV3State) AsNode() ipld.Node

+ func (m MaybeInitV3State) Exists() bool

+ func (m MaybeInitV3State) IsAbsent() bool

+ func (m MaybeInitV3State) IsNull() bool

+ func (m MaybeInitV3State) Must() InitV3State

+ type MaybeInt = *_Int__Maybe

+ func (m MaybeInt) AsNode() ipld.Node

+ func (m MaybeInt) Exists() bool

+ func (m MaybeInt) IsAbsent() bool

+ func (m MaybeInt) IsNull() bool

+ func (m MaybeInt) Must() Int

+ type MaybeLink = *_Link__Maybe

+ func (m MaybeLink) AsNode() ipld.Node

+ func (m MaybeLink) Exists() bool

+ func (m MaybeLink) IsAbsent() bool

+ func (m MaybeLink) IsNull() bool

+ func (m MaybeLink) Must() Link

+ type MaybeLink__AccountV0State = *_Link__AccountV0State__Maybe

+ func (m MaybeLink__AccountV0State) AsNode() ipld.Node

+ func (m MaybeLink__AccountV0State) Exists() bool

+ func (m MaybeLink__AccountV0State) IsAbsent() bool

+ func (m MaybeLink__AccountV0State) IsNull() bool

+ func (m MaybeLink__AccountV0State) Must() Link__AccountV0State

+ type MaybeLink__BalanceTable = *_Link__BalanceTable__Maybe

+ func (m MaybeLink__BalanceTable) AsNode() ipld.Node

+ func (m MaybeLink__BalanceTable) Exists() bool

+ func (m MaybeLink__BalanceTable) IsAbsent() bool

+ func (m MaybeLink__BalanceTable) IsNull() bool

+ func (m MaybeLink__BalanceTable) Must() Link__BalanceTable

+ type MaybeLink__BitField = *_Link__BitField__Maybe

+ func (m MaybeLink__BitField) AsNode() ipld.Node

+ func (m MaybeLink__BitField) Exists() bool

+ func (m MaybeLink__BitField) IsAbsent() bool

+ func (m MaybeLink__BitField) IsNull() bool

+ func (m MaybeLink__BitField) Must() Link__BitField

+ type MaybeLink__CronV0State = *_Link__CronV0State__Maybe

+ func (m MaybeLink__CronV0State) AsNode() ipld.Node

+ func (m MaybeLink__CronV0State) Exists() bool

+ func (m MaybeLink__CronV0State) IsAbsent() bool

+ func (m MaybeLink__CronV0State) IsNull() bool

+ func (m MaybeLink__CronV0State) Must() Link__CronV0State

+ type MaybeLink__DataCap = *_Link__DataCap__Maybe

+ func (m MaybeLink__DataCap) AsNode() ipld.Node

+ func (m MaybeLink__DataCap) Exists() bool

+ func (m MaybeLink__DataCap) IsAbsent() bool

+ func (m MaybeLink__DataCap) IsNull() bool

+ func (m MaybeLink__DataCap) Must() Link__DataCap

+ type MaybeLink__InitV0State = *_Link__InitV0State__Maybe

+ func (m MaybeLink__InitV0State) AsNode() ipld.Node

+ func (m MaybeLink__InitV0State) Exists() bool

+ func (m MaybeLink__InitV0State) IsAbsent() bool

+ func (m MaybeLink__InitV0State) IsNull() bool

+ func (m MaybeLink__InitV0State) Must() Link__InitV0State

+ type MaybeLink__InitV3State = *_Link__InitV3State__Maybe

+ func (m MaybeLink__InitV3State) AsNode() ipld.Node

+ func (m MaybeLink__InitV3State) Exists() bool

+ func (m MaybeLink__InitV3State) IsAbsent() bool

+ func (m MaybeLink__InitV3State) IsNull() bool

+ func (m MaybeLink__InitV3State) Must() Link__InitV3State

+ type MaybeLink__ListLotusMessage = *_Link__ListLotusMessage__Maybe

+ func (m MaybeLink__ListLotusMessage) AsNode() ipld.Node

+ func (m MaybeLink__ListLotusMessage) Exists() bool

+ func (m MaybeLink__ListLotusMessage) IsAbsent() bool

+ func (m MaybeLink__ListLotusMessage) IsNull() bool

+ func (m MaybeLink__ListLotusMessage) Must() Link__ListLotusMessage

+ type MaybeLink__LotusActorV2Head = *_Link__LotusActorV2Head__Maybe

+ func (m MaybeLink__LotusActorV2Head) AsNode() ipld.Node

+ func (m MaybeLink__LotusActorV2Head) Exists() bool

+ func (m MaybeLink__LotusActorV2Head) IsAbsent() bool

+ func (m MaybeLink__LotusActorV2Head) IsNull() bool

+ func (m MaybeLink__LotusActorV2Head) Must() Link__LotusActorV2Head

+ type MaybeLink__LotusActorV3Head = *_Link__LotusActorV3Head__Maybe

+ func (m MaybeLink__LotusActorV3Head) AsNode() ipld.Node

+ func (m MaybeLink__LotusActorV3Head) Exists() bool

+ func (m MaybeLink__LotusActorV3Head) IsAbsent() bool

+ func (m MaybeLink__LotusActorV3Head) IsNull() bool

+ func (m MaybeLink__LotusActorV3Head) Must() Link__LotusActorV3Head

+ type MaybeLink__LotusActorV4Head = *_Link__LotusActorV4Head__Maybe

+ func (m MaybeLink__LotusActorV4Head) AsNode() ipld.Node

+ func (m MaybeLink__LotusActorV4Head) Exists() bool

+ func (m MaybeLink__LotusActorV4Head) IsAbsent() bool

+ func (m MaybeLink__LotusActorV4Head) IsNull() bool

+ func (m MaybeLink__LotusActorV4Head) Must() Link__LotusActorV4Head

+ type MaybeLink__LotusActorV5Head = *_Link__LotusActorV5Head__Maybe

+ func (m MaybeLink__LotusActorV5Head) AsNode() ipld.Node

+ func (m MaybeLink__LotusActorV5Head) Exists() bool

+ func (m MaybeLink__LotusActorV5Head) IsAbsent() bool

+ func (m MaybeLink__LotusActorV5Head) IsNull() bool

+ func (m MaybeLink__LotusActorV5Head) Must() Link__LotusActorV5Head

+ type MaybeLink__LotusActors = *_Link__LotusActors__Maybe

+ func (m MaybeLink__LotusActors) AsNode() ipld.Node

+ func (m MaybeLink__LotusActors) Exists() bool

+ func (m MaybeLink__LotusActors) IsAbsent() bool

+ func (m MaybeLink__LotusActors) IsNull() bool

+ func (m MaybeLink__LotusActors) Must() Link__LotusActors

+ type MaybeLink__LotusMessage = *_Link__LotusMessage__Maybe

+ func (m MaybeLink__LotusMessage) AsNode() ipld.Node

+ func (m MaybeLink__LotusMessage) Exists() bool

+ func (m MaybeLink__LotusMessage) IsAbsent() bool

+ func (m MaybeLink__LotusMessage) IsNull() bool

+ func (m MaybeLink__LotusMessage) Must() Link__LotusMessage

+ type MaybeLink__LotusMsgMeta = *_Link__LotusMsgMeta__Maybe

+ func (m MaybeLink__LotusMsgMeta) AsNode() ipld.Node

+ func (m MaybeLink__LotusMsgMeta) Exists() bool

+ func (m MaybeLink__LotusMsgMeta) IsAbsent() bool

+ func (m MaybeLink__LotusMsgMeta) IsNull() bool

+ func (m MaybeLink__LotusMsgMeta) Must() Link__LotusMsgMeta

+ type MaybeLink__LotusStateRoot = *_Link__LotusStateRoot__Maybe

+ func (m MaybeLink__LotusStateRoot) AsNode() ipld.Node

+ func (m MaybeLink__LotusStateRoot) Exists() bool

+ func (m MaybeLink__LotusStateRoot) IsAbsent() bool

+ func (m MaybeLink__LotusStateRoot) IsNull() bool

+ func (m MaybeLink__LotusStateRoot) Must() Link__LotusStateRoot

+ type MaybeLink__MapActorID = *_Link__MapActorID__Maybe

+ func (m MaybeLink__MapActorID) AsNode() ipld.Node

+ func (m MaybeLink__MapActorID) Exists() bool

+ func (m MaybeLink__MapActorID) IsAbsent() bool

+ func (m MaybeLink__MapActorID) IsNull() bool

+ func (m MaybeLink__MapActorID) Must() Link__MapActorID

+ type MaybeLink__MarketV0DealProposal = *_Link__MarketV0DealProposal__Maybe

+ func (m MaybeLink__MarketV0DealProposal) AsNode() ipld.Node

+ func (m MaybeLink__MarketV0DealProposal) Exists() bool

+ func (m MaybeLink__MarketV0DealProposal) IsAbsent() bool

+ func (m MaybeLink__MarketV0DealProposal) IsNull() bool

+ func (m MaybeLink__MarketV0DealProposal) Must() Link__MarketV0DealProposal

+ type MaybeLink__MarketV0DealState = *_Link__MarketV0DealState__Maybe

+ func (m MaybeLink__MarketV0DealState) AsNode() ipld.Node

+ func (m MaybeLink__MarketV0DealState) Exists() bool

+ func (m MaybeLink__MarketV0DealState) IsAbsent() bool

+ func (m MaybeLink__MarketV0DealState) IsNull() bool

+ func (m MaybeLink__MarketV0DealState) Must() Link__MarketV0DealState

+ type MaybeLink__MarketV0RawDealProposal = *_Link__MarketV0RawDealProposal__Maybe

+ func (m MaybeLink__MarketV0RawDealProposal) AsNode() ipld.Node

+ func (m MaybeLink__MarketV0RawDealProposal) Exists() bool

+ func (m MaybeLink__MarketV0RawDealProposal) IsAbsent() bool

+ func (m MaybeLink__MarketV0RawDealProposal) IsNull() bool

+ func (m MaybeLink__MarketV0RawDealProposal) Must() Link__MarketV0RawDealProposal

+ type MaybeLink__MarketV0State = *_Link__MarketV0State__Maybe

+ func (m MaybeLink__MarketV0State) AsNode() ipld.Node

+ func (m MaybeLink__MarketV0State) Exists() bool

+ func (m MaybeLink__MarketV0State) IsAbsent() bool

+ func (m MaybeLink__MarketV0State) IsNull() bool

+ func (m MaybeLink__MarketV0State) Must() Link__MarketV0State

+ type MaybeLink__MarketV2DealProposal = *_Link__MarketV2DealProposal__Maybe

+ func (m MaybeLink__MarketV2DealProposal) AsNode() ipld.Node

+ func (m MaybeLink__MarketV2DealProposal) Exists() bool

+ func (m MaybeLink__MarketV2DealProposal) IsAbsent() bool

+ func (m MaybeLink__MarketV2DealProposal) IsNull() bool

+ func (m MaybeLink__MarketV2DealProposal) Must() Link__MarketV2DealProposal

+ type MaybeLink__MarketV2RawDealProposal = *_Link__MarketV2RawDealProposal__Maybe

+ func (m MaybeLink__MarketV2RawDealProposal) AsNode() ipld.Node

+ func (m MaybeLink__MarketV2RawDealProposal) Exists() bool

+ func (m MaybeLink__MarketV2RawDealProposal) IsAbsent() bool

+ func (m MaybeLink__MarketV2RawDealProposal) IsNull() bool

+ func (m MaybeLink__MarketV2RawDealProposal) Must() Link__MarketV2RawDealProposal

+ type MaybeLink__MarketV2State = *_Link__MarketV2State__Maybe

+ func (m MaybeLink__MarketV2State) AsNode() ipld.Node

+ func (m MaybeLink__MarketV2State) Exists() bool

+ func (m MaybeLink__MarketV2State) IsAbsent() bool

+ func (m MaybeLink__MarketV2State) IsNull() bool

+ func (m MaybeLink__MarketV2State) Must() Link__MarketV2State

+ type MaybeLink__MarketV3DealProposal = *_Link__MarketV3DealProposal__Maybe

+ func (m MaybeLink__MarketV3DealProposal) AsNode() ipld.Node

+ func (m MaybeLink__MarketV3DealProposal) Exists() bool

+ func (m MaybeLink__MarketV3DealProposal) IsAbsent() bool

+ func (m MaybeLink__MarketV3DealProposal) IsNull() bool

+ func (m MaybeLink__MarketV3DealProposal) Must() Link__MarketV3DealProposal

+ type MaybeLink__MarketV3DealState = *_Link__MarketV3DealState__Maybe

+ func (m MaybeLink__MarketV3DealState) AsNode() ipld.Node

+ func (m MaybeLink__MarketV3DealState) Exists() bool

+ func (m MaybeLink__MarketV3DealState) IsAbsent() bool

+ func (m MaybeLink__MarketV3DealState) IsNull() bool

+ func (m MaybeLink__MarketV3DealState) Must() Link__MarketV3DealState

+ type MaybeLink__MarketV3MultimapDealID = *_Link__MarketV3MultimapDealID__Maybe

+ func (m MaybeLink__MarketV3MultimapDealID) AsNode() ipld.Node

+ func (m MaybeLink__MarketV3MultimapDealID) Exists() bool

+ func (m MaybeLink__MarketV3MultimapDealID) IsAbsent() bool

+ func (m MaybeLink__MarketV3MultimapDealID) IsNull() bool

+ func (m MaybeLink__MarketV3MultimapDealID) Must() Link__MarketV3MultimapDealID

+ type MaybeLink__MarketV3RawDealProposal = *_Link__MarketV3RawDealProposal__Maybe

+ func (m MaybeLink__MarketV3RawDealProposal) AsNode() ipld.Node

+ func (m MaybeLink__MarketV3RawDealProposal) Exists() bool

+ func (m MaybeLink__MarketV3RawDealProposal) IsAbsent() bool

+ func (m MaybeLink__MarketV3RawDealProposal) IsNull() bool

+ func (m MaybeLink__MarketV3RawDealProposal) Must() Link__MarketV3RawDealProposal

+ type MaybeLink__MarketV3State = *_Link__MarketV3State__Maybe

+ func (m MaybeLink__MarketV3State) AsNode() ipld.Node

+ func (m MaybeLink__MarketV3State) Exists() bool

+ func (m MaybeLink__MarketV3State) IsAbsent() bool

+ func (m MaybeLink__MarketV3State) IsNull() bool

+ func (m MaybeLink__MarketV3State) Must() Link__MarketV3State

+ type MaybeLink__MarketV5State = *_Link__MarketV5State__Maybe

+ func (m MaybeLink__MarketV5State) AsNode() ipld.Node

+ func (m MaybeLink__MarketV5State) Exists() bool

+ func (m MaybeLink__MarketV5State) IsAbsent() bool

+ func (m MaybeLink__MarketV5State) IsNull() bool

+ func (m MaybeLink__MarketV5State) Must() Link__MarketV5State

+ type MaybeLink__MinerV0Deadline = *_Link__MinerV0Deadline__Maybe

+ func (m MaybeLink__MinerV0Deadline) AsNode() ipld.Node

+ func (m MaybeLink__MinerV0Deadline) Exists() bool

+ func (m MaybeLink__MinerV0Deadline) IsAbsent() bool

+ func (m MaybeLink__MinerV0Deadline) IsNull() bool

+ func (m MaybeLink__MinerV0Deadline) Must() Link__MinerV0Deadline

+ type MaybeLink__MinerV0Deadlines = *_Link__MinerV0Deadlines__Maybe

+ func (m MaybeLink__MinerV0Deadlines) AsNode() ipld.Node

+ func (m MaybeLink__MinerV0Deadlines) Exists() bool

+ func (m MaybeLink__MinerV0Deadlines) IsAbsent() bool

+ func (m MaybeLink__MinerV0Deadlines) IsNull() bool

+ func (m MaybeLink__MinerV0Deadlines) Must() Link__MinerV0Deadlines

+ type MaybeLink__MinerV0ExpirationSet = *_Link__MinerV0ExpirationSet__Maybe

+ func (m MaybeLink__MinerV0ExpirationSet) AsNode() ipld.Node

+ func (m MaybeLink__MinerV0ExpirationSet) Exists() bool

+ func (m MaybeLink__MinerV0ExpirationSet) IsAbsent() bool

+ func (m MaybeLink__MinerV0ExpirationSet) IsNull() bool

+ func (m MaybeLink__MinerV0ExpirationSet) Must() Link__MinerV0ExpirationSet

+ type MaybeLink__MinerV0Info = *_Link__MinerV0Info__Maybe

+ func (m MaybeLink__MinerV0Info) AsNode() ipld.Node

+ func (m MaybeLink__MinerV0Info) Exists() bool

+ func (m MaybeLink__MinerV0Info) IsAbsent() bool

+ func (m MaybeLink__MinerV0Info) IsNull() bool

+ func (m MaybeLink__MinerV0Info) Must() Link__MinerV0Info

+ type MaybeLink__MinerV0Partition = *_Link__MinerV0Partition__Maybe

+ func (m MaybeLink__MinerV0Partition) AsNode() ipld.Node

+ func (m MaybeLink__MinerV0Partition) Exists() bool

+ func (m MaybeLink__MinerV0Partition) IsAbsent() bool

+ func (m MaybeLink__MinerV0Partition) IsNull() bool

+ func (m MaybeLink__MinerV0Partition) Must() Link__MinerV0Partition

+ type MaybeLink__MinerV0SectorInfo = *_Link__MinerV0SectorInfo__Maybe

+ func (m MaybeLink__MinerV0SectorInfo) AsNode() ipld.Node

+ func (m MaybeLink__MinerV0SectorInfo) Exists() bool

+ func (m MaybeLink__MinerV0SectorInfo) IsAbsent() bool

+ func (m MaybeLink__MinerV0SectorInfo) IsNull() bool

+ func (m MaybeLink__MinerV0SectorInfo) Must() Link__MinerV0SectorInfo

+ type MaybeLink__MinerV0SectorPreCommits = *_Link__MinerV0SectorPreCommits__Maybe

+ func (m MaybeLink__MinerV0SectorPreCommits) AsNode() ipld.Node

+ func (m MaybeLink__MinerV0SectorPreCommits) Exists() bool

+ func (m MaybeLink__MinerV0SectorPreCommits) IsAbsent() bool

+ func (m MaybeLink__MinerV0SectorPreCommits) IsNull() bool

+ func (m MaybeLink__MinerV0SectorPreCommits) Must() Link__MinerV0SectorPreCommits

+ type MaybeLink__MinerV0State = *_Link__MinerV0State__Maybe

+ func (m MaybeLink__MinerV0State) AsNode() ipld.Node

+ func (m MaybeLink__MinerV0State) Exists() bool

+ func (m MaybeLink__MinerV0State) IsAbsent() bool

+ func (m MaybeLink__MinerV0State) IsNull() bool

+ func (m MaybeLink__MinerV0State) Must() Link__MinerV0State

+ type MaybeLink__MinerV0VestingFunds = *_Link__MinerV0VestingFunds__Maybe

+ func (m MaybeLink__MinerV0VestingFunds) AsNode() ipld.Node

+ func (m MaybeLink__MinerV0VestingFunds) Exists() bool

+ func (m MaybeLink__MinerV0VestingFunds) IsAbsent() bool

+ func (m MaybeLink__MinerV0VestingFunds) IsNull() bool

+ func (m MaybeLink__MinerV0VestingFunds) Must() Link__MinerV0VestingFunds

+ type MaybeLink__MinerV2Deadline = *_Link__MinerV2Deadline__Maybe

+ func (m MaybeLink__MinerV2Deadline) AsNode() ipld.Node

+ func (m MaybeLink__MinerV2Deadline) Exists() bool

+ func (m MaybeLink__MinerV2Deadline) IsAbsent() bool

+ func (m MaybeLink__MinerV2Deadline) IsNull() bool

+ func (m MaybeLink__MinerV2Deadline) Must() Link__MinerV2Deadline

+ type MaybeLink__MinerV2Deadlines = *_Link__MinerV2Deadlines__Maybe

+ func (m MaybeLink__MinerV2Deadlines) AsNode() ipld.Node

+ func (m MaybeLink__MinerV2Deadlines) Exists() bool

+ func (m MaybeLink__MinerV2Deadlines) IsAbsent() bool

+ func (m MaybeLink__MinerV2Deadlines) IsNull() bool

+ func (m MaybeLink__MinerV2Deadlines) Must() Link__MinerV2Deadlines

+ type MaybeLink__MinerV2Info = *_Link__MinerV2Info__Maybe

+ func (m MaybeLink__MinerV2Info) AsNode() ipld.Node

+ func (m MaybeLink__MinerV2Info) Exists() bool

+ func (m MaybeLink__MinerV2Info) IsAbsent() bool

+ func (m MaybeLink__MinerV2Info) IsNull() bool

+ func (m MaybeLink__MinerV2Info) Must() Link__MinerV2Info

+ type MaybeLink__MinerV2Partition = *_Link__MinerV2Partition__Maybe

+ func (m MaybeLink__MinerV2Partition) AsNode() ipld.Node

+ func (m MaybeLink__MinerV2Partition) Exists() bool

+ func (m MaybeLink__MinerV2Partition) IsAbsent() bool

+ func (m MaybeLink__MinerV2Partition) IsNull() bool

+ func (m MaybeLink__MinerV2Partition) Must() Link__MinerV2Partition

+ type MaybeLink__MinerV2SectorInfo = *_Link__MinerV2SectorInfo__Maybe

+ func (m MaybeLink__MinerV2SectorInfo) AsNode() ipld.Node

+ func (m MaybeLink__MinerV2SectorInfo) Exists() bool

+ func (m MaybeLink__MinerV2SectorInfo) IsAbsent() bool

+ func (m MaybeLink__MinerV2SectorInfo) IsNull() bool

+ func (m MaybeLink__MinerV2SectorInfo) Must() Link__MinerV2SectorInfo

+ type MaybeLink__MinerV2State = *_Link__MinerV2State__Maybe

+ func (m MaybeLink__MinerV2State) AsNode() ipld.Node

+ func (m MaybeLink__MinerV2State) Exists() bool

+ func (m MaybeLink__MinerV2State) IsAbsent() bool

+ func (m MaybeLink__MinerV2State) IsNull() bool

+ func (m MaybeLink__MinerV2State) Must() Link__MinerV2State

+ type MaybeLink__MinerV3Deadline = *_Link__MinerV3Deadline__Maybe

+ func (m MaybeLink__MinerV3Deadline) AsNode() ipld.Node

+ func (m MaybeLink__MinerV3Deadline) Exists() bool

+ func (m MaybeLink__MinerV3Deadline) IsAbsent() bool

+ func (m MaybeLink__MinerV3Deadline) IsNull() bool

+ func (m MaybeLink__MinerV3Deadline) Must() Link__MinerV3Deadline

+ type MaybeLink__MinerV3Deadlines = *_Link__MinerV3Deadlines__Maybe

+ func (m MaybeLink__MinerV3Deadlines) AsNode() ipld.Node

+ func (m MaybeLink__MinerV3Deadlines) Exists() bool

+ func (m MaybeLink__MinerV3Deadlines) IsAbsent() bool

+ func (m MaybeLink__MinerV3Deadlines) IsNull() bool

+ func (m MaybeLink__MinerV3Deadlines) Must() Link__MinerV3Deadlines

+ type MaybeLink__MinerV3ExpirationSet = *_Link__MinerV3ExpirationSet__Maybe

+ func (m MaybeLink__MinerV3ExpirationSet) AsNode() ipld.Node

+ func (m MaybeLink__MinerV3ExpirationSet) Exists() bool

+ func (m MaybeLink__MinerV3ExpirationSet) IsAbsent() bool

+ func (m MaybeLink__MinerV3ExpirationSet) IsNull() bool

+ func (m MaybeLink__MinerV3ExpirationSet) Must() Link__MinerV3ExpirationSet

+ type MaybeLink__MinerV3Partition = *_Link__MinerV3Partition__Maybe

+ func (m MaybeLink__MinerV3Partition) AsNode() ipld.Node

+ func (m MaybeLink__MinerV3Partition) Exists() bool

+ func (m MaybeLink__MinerV3Partition) IsAbsent() bool

+ func (m MaybeLink__MinerV3Partition) IsNull() bool

+ func (m MaybeLink__MinerV3Partition) Must() Link__MinerV3Partition

+ type MaybeLink__MinerV3SectorInfo = *_Link__MinerV3SectorInfo__Maybe

+ func (m MaybeLink__MinerV3SectorInfo) AsNode() ipld.Node

+ func (m MaybeLink__MinerV3SectorInfo) Exists() bool

+ func (m MaybeLink__MinerV3SectorInfo) IsAbsent() bool

+ func (m MaybeLink__MinerV3SectorInfo) IsNull() bool

+ func (m MaybeLink__MinerV3SectorInfo) Must() Link__MinerV3SectorInfo

+ type MaybeLink__MinerV3SectorPreCommits = *_Link__MinerV3SectorPreCommits__Maybe

+ func (m MaybeLink__MinerV3SectorPreCommits) AsNode() ipld.Node

+ func (m MaybeLink__MinerV3SectorPreCommits) Exists() bool

+ func (m MaybeLink__MinerV3SectorPreCommits) IsAbsent() bool

+ func (m MaybeLink__MinerV3SectorPreCommits) IsNull() bool

+ func (m MaybeLink__MinerV3SectorPreCommits) Must() Link__MinerV3SectorPreCommits

+ type MaybeLink__MinerV3State = *_Link__MinerV3State__Maybe

+ func (m MaybeLink__MinerV3State) AsNode() ipld.Node

+ func (m MaybeLink__MinerV3State) Exists() bool

+ func (m MaybeLink__MinerV3State) IsAbsent() bool

+ func (m MaybeLink__MinerV3State) IsNull() bool

+ func (m MaybeLink__MinerV3State) Must() Link__MinerV3State

+ type MaybeLink__MinerV4State = *_Link__MinerV4State__Maybe

+ func (m MaybeLink__MinerV4State) AsNode() ipld.Node

+ func (m MaybeLink__MinerV4State) Exists() bool

+ func (m MaybeLink__MinerV4State) IsAbsent() bool

+ func (m MaybeLink__MinerV4State) IsNull() bool

+ func (m MaybeLink__MinerV4State) Must() Link__MinerV4State

+ type MaybeLink__MinerV5State = *_Link__MinerV5State__Maybe

+ func (m MaybeLink__MinerV5State) AsNode() ipld.Node

+ func (m MaybeLink__MinerV5State) Exists() bool

+ func (m MaybeLink__MinerV5State) IsAbsent() bool

+ func (m MaybeLink__MinerV5State) IsNull() bool

+ func (m MaybeLink__MinerV5State) Must() Link__MinerV5State

+ type MaybeLink__MultimapDealID = *_Link__MultimapDealID__Maybe

+ func (m MaybeLink__MultimapDealID) AsNode() ipld.Node

+ func (m MaybeLink__MultimapDealID) Exists() bool

+ func (m MaybeLink__MultimapDealID) IsAbsent() bool

+ func (m MaybeLink__MultimapDealID) IsNull() bool

+ func (m MaybeLink__MultimapDealID) Must() Link__MultimapDealID

+ type MaybeLink__MultisigV0State = *_Link__MultisigV0State__Maybe

+ func (m MaybeLink__MultisigV0State) AsNode() ipld.Node

+ func (m MaybeLink__MultisigV0State) Exists() bool

+ func (m MaybeLink__MultisigV0State) IsAbsent() bool

+ func (m MaybeLink__MultisigV0State) IsNull() bool

+ func (m MaybeLink__MultisigV0State) Must() Link__MultisigV0State

+ type MaybeLink__MultisigV0Transaction = *_Link__MultisigV0Transaction__Maybe

+ func (m MaybeLink__MultisigV0Transaction) AsNode() ipld.Node

+ func (m MaybeLink__MultisigV0Transaction) Exists() bool

+ func (m MaybeLink__MultisigV0Transaction) IsAbsent() bool

+ func (m MaybeLink__MultisigV0Transaction) IsNull() bool

+ func (m MaybeLink__MultisigV0Transaction) Must() Link__MultisigV0Transaction

+ type MaybeLink__MultisigV3State = *_Link__MultisigV3State__Maybe

+ func (m MaybeLink__MultisigV3State) AsNode() ipld.Node

+ func (m MaybeLink__MultisigV3State) Exists() bool

+ func (m MaybeLink__MultisigV3State) IsAbsent() bool

+ func (m MaybeLink__MultisigV3State) IsNull() bool

+ func (m MaybeLink__MultisigV3State) Must() Link__MultisigV3State

+ type MaybeLink__MultisigV3Transaction = *_Link__MultisigV3Transaction__Maybe

+ func (m MaybeLink__MultisigV3Transaction) AsNode() ipld.Node

+ func (m MaybeLink__MultisigV3Transaction) Exists() bool

+ func (m MaybeLink__MultisigV3Transaction) IsAbsent() bool

+ func (m MaybeLink__MultisigV3Transaction) IsNull() bool

+ func (m MaybeLink__MultisigV3Transaction) Must() Link__MultisigV3Transaction

+ type MaybeLink__PaychV0LaneState = *_Link__PaychV0LaneState__Maybe

+ func (m MaybeLink__PaychV0LaneState) AsNode() ipld.Node

+ func (m MaybeLink__PaychV0LaneState) Exists() bool

+ func (m MaybeLink__PaychV0LaneState) IsAbsent() bool

+ func (m MaybeLink__PaychV0LaneState) IsNull() bool

+ func (m MaybeLink__PaychV0LaneState) Must() Link__PaychV0LaneState

+ type MaybeLink__PaychV0State = *_Link__PaychV0State__Maybe

+ func (m MaybeLink__PaychV0State) AsNode() ipld.Node

+ func (m MaybeLink__PaychV0State) Exists() bool

+ func (m MaybeLink__PaychV0State) IsAbsent() bool

+ func (m MaybeLink__PaychV0State) IsNull() bool

+ func (m MaybeLink__PaychV0State) Must() Link__PaychV0State

+ type MaybeLink__PaychV3LaneState = *_Link__PaychV3LaneState__Maybe

+ func (m MaybeLink__PaychV3LaneState) AsNode() ipld.Node

+ func (m MaybeLink__PaychV3LaneState) Exists() bool

+ func (m MaybeLink__PaychV3LaneState) IsAbsent() bool

+ func (m MaybeLink__PaychV3LaneState) IsNull() bool

+ func (m MaybeLink__PaychV3LaneState) Must() Link__PaychV3LaneState

+ type MaybeLink__PaychV3State = *_Link__PaychV3State__Maybe

+ func (m MaybeLink__PaychV3State) AsNode() ipld.Node

+ func (m MaybeLink__PaychV3State) Exists() bool

+ func (m MaybeLink__PaychV3State) IsAbsent() bool

+ func (m MaybeLink__PaychV3State) IsNull() bool

+ func (m MaybeLink__PaychV3State) Must() Link__PaychV3State

+ type MaybeLink__PowerV0Claim = *_Link__PowerV0Claim__Maybe

+ func (m MaybeLink__PowerV0Claim) AsNode() ipld.Node

+ func (m MaybeLink__PowerV0Claim) Exists() bool

+ func (m MaybeLink__PowerV0Claim) IsAbsent() bool

+ func (m MaybeLink__PowerV0Claim) IsNull() bool

+ func (m MaybeLink__PowerV0Claim) Must() Link__PowerV0Claim

+ type MaybeLink__PowerV0CronEvent = *_Link__PowerV0CronEvent__Maybe

+ func (m MaybeLink__PowerV0CronEvent) AsNode() ipld.Node

+ func (m MaybeLink__PowerV0CronEvent) Exists() bool

+ func (m MaybeLink__PowerV0CronEvent) IsAbsent() bool

+ func (m MaybeLink__PowerV0CronEvent) IsNull() bool

+ func (m MaybeLink__PowerV0CronEvent) Must() Link__PowerV0CronEvent

+ type MaybeLink__PowerV0State = *_Link__PowerV0State__Maybe

+ func (m MaybeLink__PowerV0State) AsNode() ipld.Node

+ func (m MaybeLink__PowerV0State) Exists() bool

+ func (m MaybeLink__PowerV0State) IsAbsent() bool

+ func (m MaybeLink__PowerV0State) IsNull() bool

+ func (m MaybeLink__PowerV0State) Must() Link__PowerV0State

+ type MaybeLink__PowerV2Claim = *_Link__PowerV2Claim__Maybe

+ func (m MaybeLink__PowerV2Claim) AsNode() ipld.Node

+ func (m MaybeLink__PowerV2Claim) Exists() bool

+ func (m MaybeLink__PowerV2Claim) IsAbsent() bool

+ func (m MaybeLink__PowerV2Claim) IsNull() bool

+ func (m MaybeLink__PowerV2Claim) Must() Link__PowerV2Claim

+ type MaybeLink__PowerV2State = *_Link__PowerV2State__Maybe

+ func (m MaybeLink__PowerV2State) AsNode() ipld.Node

+ func (m MaybeLink__PowerV2State) Exists() bool

+ func (m MaybeLink__PowerV2State) IsAbsent() bool

+ func (m MaybeLink__PowerV2State) IsNull() bool

+ func (m MaybeLink__PowerV2State) Must() Link__PowerV2State

+ type MaybeLink__PowerV3Claim = *_Link__PowerV3Claim__Maybe

+ func (m MaybeLink__PowerV3Claim) AsNode() ipld.Node

+ func (m MaybeLink__PowerV3Claim) Exists() bool

+ func (m MaybeLink__PowerV3Claim) IsAbsent() bool

+ func (m MaybeLink__PowerV3Claim) IsNull() bool

+ func (m MaybeLink__PowerV3Claim) Must() Link__PowerV3Claim

+ type MaybeLink__PowerV3CronEvent = *_Link__PowerV3CronEvent__Maybe

+ func (m MaybeLink__PowerV3CronEvent) AsNode() ipld.Node

+ func (m MaybeLink__PowerV3CronEvent) Exists() bool

+ func (m MaybeLink__PowerV3CronEvent) IsAbsent() bool

+ func (m MaybeLink__PowerV3CronEvent) IsNull() bool

+ func (m MaybeLink__PowerV3CronEvent) Must() Link__PowerV3CronEvent

+ type MaybeLink__PowerV3State = *_Link__PowerV3State__Maybe

+ func (m MaybeLink__PowerV3State) AsNode() ipld.Node

+ func (m MaybeLink__PowerV3State) Exists() bool

+ func (m MaybeLink__PowerV3State) IsAbsent() bool

+ func (m MaybeLink__PowerV3State) IsNull() bool

+ func (m MaybeLink__PowerV3State) Must() Link__PowerV3State

+ type MaybeLink__RewardV0State = *_Link__RewardV0State__Maybe

+ func (m MaybeLink__RewardV0State) AsNode() ipld.Node

+ func (m MaybeLink__RewardV0State) Exists() bool

+ func (m MaybeLink__RewardV0State) IsAbsent() bool

+ func (m MaybeLink__RewardV0State) IsNull() bool

+ func (m MaybeLink__RewardV0State) Must() Link__RewardV0State

+ type MaybeLink__RewardV2State = *_Link__RewardV2State__Maybe

+ func (m MaybeLink__RewardV2State) AsNode() ipld.Node

+ func (m MaybeLink__RewardV2State) Exists() bool

+ func (m MaybeLink__RewardV2State) IsAbsent() bool

+ func (m MaybeLink__RewardV2State) IsNull() bool

+ func (m MaybeLink__RewardV2State) Must() Link__RewardV2State

+ type MaybeLink__V3BalanceTable = *_Link__V3BalanceTable__Maybe

+ func (m MaybeLink__V3BalanceTable) AsNode() ipld.Node

+ func (m MaybeLink__V3BalanceTable) Exists() bool

+ func (m MaybeLink__V3BalanceTable) IsAbsent() bool

+ func (m MaybeLink__V3BalanceTable) IsNull() bool

+ func (m MaybeLink__V3BalanceTable) Must() Link__V3BalanceTable

+ type MaybeLink__V3DataCap = *_Link__V3DataCap__Maybe

+ func (m MaybeLink__V3DataCap) AsNode() ipld.Node

+ func (m MaybeLink__V3DataCap) Exists() bool

+ func (m MaybeLink__V3DataCap) IsAbsent() bool

+ func (m MaybeLink__V3DataCap) IsNull() bool

+ func (m MaybeLink__V3DataCap) Must() Link__V3DataCap

+ type MaybeLink__V3MapActorID = *_Link__V3MapActorID__Maybe

+ func (m MaybeLink__V3MapActorID) AsNode() ipld.Node

+ func (m MaybeLink__V3MapActorID) Exists() bool

+ func (m MaybeLink__V3MapActorID) IsAbsent() bool

+ func (m MaybeLink__V3MapActorID) IsNull() bool

+ func (m MaybeLink__V3MapActorID) Must() Link__V3MapActorID

+ type MaybeLink__VerifregV0State = *_Link__VerifregV0State__Maybe

+ func (m MaybeLink__VerifregV0State) AsNode() ipld.Node

+ func (m MaybeLink__VerifregV0State) Exists() bool

+ func (m MaybeLink__VerifregV0State) IsAbsent() bool

+ func (m MaybeLink__VerifregV0State) IsNull() bool

+ func (m MaybeLink__VerifregV0State) Must() Link__VerifregV0State

+ type MaybeLink__VerifregV3State = *_Link__VerifregV3State__Maybe

+ func (m MaybeLink__VerifregV3State) AsNode() ipld.Node

+ func (m MaybeLink__VerifregV3State) Exists() bool

+ func (m MaybeLink__VerifregV3State) IsAbsent() bool

+ func (m MaybeLink__VerifregV3State) IsNull() bool

+ func (m MaybeLink__VerifregV3State) Must() Link__VerifregV3State

+ type MaybeList = *_List__Maybe

+ func (m MaybeList) AsNode() ipld.Node

+ func (m MaybeList) Exists() bool

+ func (m MaybeList) IsAbsent() bool

+ func (m MaybeList) IsNull() bool

+ func (m MaybeList) Must() List

+ type MaybeList__Address = *_List__Address__Maybe

+ func (m MaybeList__Address) AsNode() ipld.Node

+ func (m MaybeList__Address) Exists() bool

+ func (m MaybeList__Address) IsAbsent() bool

+ func (m MaybeList__Address) IsNull() bool

+ func (m MaybeList__Address) Must() List__Address

+ type MaybeList__ClientDealProposal = *_List__ClientDealProposal__Maybe

+ func (m MaybeList__ClientDealProposal) AsNode() ipld.Node

+ func (m MaybeList__ClientDealProposal) Exists() bool

+ func (m MaybeList__ClientDealProposal) IsAbsent() bool

+ func (m MaybeList__ClientDealProposal) IsNull() bool

+ func (m MaybeList__ClientDealProposal) Must() List__ClientDealProposal

+ type MaybeList__CronV0Entry = *_List__CronV0Entry__Maybe

+ func (m MaybeList__CronV0Entry) AsNode() ipld.Node

+ func (m MaybeList__CronV0Entry) Exists() bool

+ func (m MaybeList__CronV0Entry) IsAbsent() bool

+ func (m MaybeList__CronV0Entry) IsNull() bool

+ func (m MaybeList__CronV0Entry) Must() List__CronV0Entry

+ type MaybeList__DealID = *_List__DealID__Maybe

+ func (m MaybeList__DealID) AsNode() ipld.Node

+ func (m MaybeList__DealID) Exists() bool

+ func (m MaybeList__DealID) IsAbsent() bool

+ func (m MaybeList__DealID) IsNull() bool

+ func (m MaybeList__DealID) Must() List__DealID

+ type MaybeList__Link = *_List__Link__Maybe

+ func (m MaybeList__Link) AsNode() ipld.Node

+ func (m MaybeList__Link) Exists() bool

+ func (m MaybeList__Link) IsAbsent() bool

+ func (m MaybeList__Link) IsNull() bool

+ func (m MaybeList__Link) Must() List__Link

+ type MaybeList__LinkLotusMessage = *_List__LinkLotusMessage__Maybe

+ func (m MaybeList__LinkLotusMessage) AsNode() ipld.Node

+ func (m MaybeList__LinkLotusMessage) Exists() bool

+ func (m MaybeList__LinkLotusMessage) IsAbsent() bool

+ func (m MaybeList__LinkLotusMessage) IsNull() bool

+ func (m MaybeList__LinkLotusMessage) Must() List__LinkLotusMessage

+ type MaybeList__LotusBeaconEntry = *_List__LotusBeaconEntry__Maybe

+ func (m MaybeList__LotusBeaconEntry) AsNode() ipld.Node

+ func (m MaybeList__LotusBeaconEntry) Exists() bool

+ func (m MaybeList__LotusBeaconEntry) IsAbsent() bool

+ func (m MaybeList__LotusBeaconEntry) IsNull() bool

+ func (m MaybeList__LotusBeaconEntry) Must() List__LotusBeaconEntry

+ type MaybeList__Merge = *_List__Merge__Maybe

+ func (m MaybeList__Merge) AsNode() ipld.Node

+ func (m MaybeList__Merge) Exists() bool

+ func (m MaybeList__Merge) IsAbsent() bool

+ func (m MaybeList__Merge) IsNull() bool

+ func (m MaybeList__Merge) Must() List__Merge

+ type MaybeList__MinerExpirationExtend = *_List__MinerExpirationExtend__Maybe

+ func (m MaybeList__MinerExpirationExtend) AsNode() ipld.Node

+ func (m MaybeList__MinerExpirationExtend) Exists() bool

+ func (m MaybeList__MinerExpirationExtend) IsAbsent() bool

+ func (m MaybeList__MinerExpirationExtend) IsNull() bool

+ func (m MaybeList__MinerExpirationExtend) Must() List__MinerExpirationExtend

+ type MaybeList__MinerPoStProof = *_List__MinerPoStProof__Maybe

+ func (m MaybeList__MinerPoStProof) AsNode() ipld.Node

+ func (m MaybeList__MinerPoStProof) Exists() bool

+ func (m MaybeList__MinerPoStProof) IsAbsent() bool

+ func (m MaybeList__MinerPoStProof) IsNull() bool

+ func (m MaybeList__MinerPoStProof) Must() List__MinerPoStProof

+ type MaybeList__MinerPostPartition = *_List__MinerPostPartition__Maybe

+ func (m MaybeList__MinerPostPartition) AsNode() ipld.Node

+ func (m MaybeList__MinerPostPartition) Exists() bool

+ func (m MaybeList__MinerPostPartition) IsAbsent() bool

+ func (m MaybeList__MinerPostPartition) IsNull() bool

+ func (m MaybeList__MinerPostPartition) Must() List__MinerPostPartition

+ type MaybeList__MinerTerminationDecl = *_List__MinerTerminationDecl__Maybe

+ func (m MaybeList__MinerTerminationDecl) AsNode() ipld.Node

+ func (m MaybeList__MinerTerminationDecl) Exists() bool

+ func (m MaybeList__MinerTerminationDecl) IsAbsent() bool

+ func (m MaybeList__MinerTerminationDecl) IsNull() bool

+ func (m MaybeList__MinerTerminationDecl) Must() List__MinerTerminationDecl

+ type MaybeList__MinerV0DeadlineLink = *_List__MinerV0DeadlineLink__Maybe

+ func (m MaybeList__MinerV0DeadlineLink) AsNode() ipld.Node

+ func (m MaybeList__MinerV0DeadlineLink) Exists() bool

+ func (m MaybeList__MinerV0DeadlineLink) IsAbsent() bool

+ func (m MaybeList__MinerV0DeadlineLink) IsNull() bool

+ func (m MaybeList__MinerV0DeadlineLink) Must() List__MinerV0DeadlineLink

+ type MaybeList__MinerV0SectorPreCommitInfo = *_List__MinerV0SectorPreCommitInfo__Maybe

+ func (m MaybeList__MinerV0SectorPreCommitInfo) AsNode() ipld.Node

+ func (m MaybeList__MinerV0SectorPreCommitInfo) Exists() bool

+ func (m MaybeList__MinerV0SectorPreCommitInfo) IsAbsent() bool

+ func (m MaybeList__MinerV0SectorPreCommitInfo) IsNull() bool

+ func (m MaybeList__MinerV0SectorPreCommitInfo) Must() List__MinerV0SectorPreCommitInfo

+ type MaybeList__MinerV0VestingFund = *_List__MinerV0VestingFund__Maybe

+ func (m MaybeList__MinerV0VestingFund) AsNode() ipld.Node

+ func (m MaybeList__MinerV0VestingFund) Exists() bool

+ func (m MaybeList__MinerV0VestingFund) IsAbsent() bool

+ func (m MaybeList__MinerV0VestingFund) IsNull() bool

+ func (m MaybeList__MinerV0VestingFund) Must() List__MinerV0VestingFund

+ type MaybeList__MinerV2DeadlineLink = *_List__MinerV2DeadlineLink__Maybe

+ func (m MaybeList__MinerV2DeadlineLink) AsNode() ipld.Node

+ func (m MaybeList__MinerV2DeadlineLink) Exists() bool

+ func (m MaybeList__MinerV2DeadlineLink) IsAbsent() bool

+ func (m MaybeList__MinerV2DeadlineLink) IsNull() bool

+ func (m MaybeList__MinerV2DeadlineLink) Must() List__MinerV2DeadlineLink

+ type MaybeList__MinerV3DeadlineLink = *_List__MinerV3DeadlineLink__Maybe

+ func (m MaybeList__MinerV3DeadlineLink) AsNode() ipld.Node

+ func (m MaybeList__MinerV3DeadlineLink) Exists() bool

+ func (m MaybeList__MinerV3DeadlineLink) IsAbsent() bool

+ func (m MaybeList__MinerV3DeadlineLink) IsNull() bool

+ func (m MaybeList__MinerV3DeadlineLink) Must() List__MinerV3DeadlineLink

+ type MaybeList__Multiaddrs = *_List__Multiaddrs__Maybe

+ func (m MaybeList__Multiaddrs) AsNode() ipld.Node

+ func (m MaybeList__Multiaddrs) Exists() bool

+ func (m MaybeList__Multiaddrs) IsAbsent() bool

+ func (m MaybeList__Multiaddrs) IsNull() bool

+ func (m MaybeList__Multiaddrs) Must() List__Multiaddrs

+ type MaybeList__PoStProof = *_List__PoStProof__Maybe

+ func (m MaybeList__PoStProof) AsNode() ipld.Node

+ func (m MaybeList__PoStProof) Exists() bool

+ func (m MaybeList__PoStProof) IsAbsent() bool

+ func (m MaybeList__PoStProof) IsNull() bool

+ func (m MaybeList__PoStProof) Must() List__PoStProof

+ type MaybeList__SectorDataSpec = *_List__SectorDataSpec__Maybe

+ func (m MaybeList__SectorDataSpec) AsNode() ipld.Node

+ func (m MaybeList__SectorDataSpec) Exists() bool

+ func (m MaybeList__SectorDataSpec) IsAbsent() bool

+ func (m MaybeList__SectorDataSpec) IsNull() bool

+ func (m MaybeList__SectorDataSpec) Must() List__SectorDataSpec

+ type MaybeList__SectorNumber = *_List__SectorNumber__Maybe

+ func (m MaybeList__SectorNumber) AsNode() ipld.Node

+ func (m MaybeList__SectorNumber) Exists() bool

+ func (m MaybeList__SectorNumber) IsAbsent() bool

+ func (m MaybeList__SectorNumber) IsNull() bool

+ func (m MaybeList__SectorNumber) Must() List__SectorNumber

+ type MaybeLotusActorV2Head = *_LotusActorV2Head__Maybe

+ func (m MaybeLotusActorV2Head) AsNode() ipld.Node

+ func (m MaybeLotusActorV2Head) Exists() bool

+ func (m MaybeLotusActorV2Head) IsAbsent() bool

+ func (m MaybeLotusActorV2Head) IsNull() bool

+ func (m MaybeLotusActorV2Head) Must() LotusActorV2Head

+ type MaybeLotusActorV3Head = *_LotusActorV3Head__Maybe

+ func (m MaybeLotusActorV3Head) AsNode() ipld.Node

+ func (m MaybeLotusActorV3Head) Exists() bool

+ func (m MaybeLotusActorV3Head) IsAbsent() bool

+ func (m MaybeLotusActorV3Head) IsNull() bool

+ func (m MaybeLotusActorV3Head) Must() LotusActorV3Head

+ type MaybeLotusActorV4Head = *_LotusActorV4Head__Maybe

+ func (m MaybeLotusActorV4Head) AsNode() ipld.Node

+ func (m MaybeLotusActorV4Head) Exists() bool

+ func (m MaybeLotusActorV4Head) IsAbsent() bool

+ func (m MaybeLotusActorV4Head) IsNull() bool

+ func (m MaybeLotusActorV4Head) Must() LotusActorV4Head

+ type MaybeLotusActorV5Head = *_LotusActorV5Head__Maybe

+ func (m MaybeLotusActorV5Head) AsNode() ipld.Node

+ func (m MaybeLotusActorV5Head) Exists() bool

+ func (m MaybeLotusActorV5Head) IsAbsent() bool

+ func (m MaybeLotusActorV5Head) IsNull() bool

+ func (m MaybeLotusActorV5Head) Must() LotusActorV5Head

+ type MaybeLotusActors = *_LotusActors__Maybe

+ func (m MaybeLotusActors) AsNode() ipld.Node

+ func (m MaybeLotusActors) Exists() bool

+ func (m MaybeLotusActors) IsAbsent() bool

+ func (m MaybeLotusActors) IsNull() bool

+ func (m MaybeLotusActors) Must() LotusActors

+ type MaybeLotusBeaconEntry = *_LotusBeaconEntry__Maybe

+ func (m MaybeLotusBeaconEntry) AsNode() ipld.Node

+ func (m MaybeLotusBeaconEntry) Exists() bool

+ func (m MaybeLotusBeaconEntry) IsAbsent() bool

+ func (m MaybeLotusBeaconEntry) IsNull() bool

+ func (m MaybeLotusBeaconEntry) Must() LotusBeaconEntry

+ type MaybeLotusBlockHeader = *_LotusBlockHeader__Maybe

+ func (m MaybeLotusBlockHeader) AsNode() ipld.Node

+ func (m MaybeLotusBlockHeader) Exists() bool

+ func (m MaybeLotusBlockHeader) IsAbsent() bool

+ func (m MaybeLotusBlockHeader) IsNull() bool

+ func (m MaybeLotusBlockHeader) Must() LotusBlockHeader

+ type MaybeLotusElectionProof = *_LotusElectionProof__Maybe

+ func (m MaybeLotusElectionProof) AsNode() ipld.Node

+ func (m MaybeLotusElectionProof) Exists() bool

+ func (m MaybeLotusElectionProof) IsAbsent() bool

+ func (m MaybeLotusElectionProof) IsNull() bool

+ func (m MaybeLotusElectionProof) Must() LotusElectionProof

+ type MaybeLotusMessage = *_LotusMessage__Maybe

+ func (m MaybeLotusMessage) AsNode() ipld.Node

+ func (m MaybeLotusMessage) Exists() bool

+ func (m MaybeLotusMessage) IsAbsent() bool

+ func (m MaybeLotusMessage) IsNull() bool

+ func (m MaybeLotusMessage) Must() LotusMessage

+ type MaybeLotusMessageV2Params = *_LotusMessageV2Params__Maybe

+ func (m MaybeLotusMessageV2Params) AsNode() ipld.Node

+ func (m MaybeLotusMessageV2Params) Exists() bool

+ func (m MaybeLotusMessageV2Params) IsAbsent() bool

+ func (m MaybeLotusMessageV2Params) IsNull() bool

+ func (m MaybeLotusMessageV2Params) Must() LotusMessageV2Params

+ type MaybeLotusMsgMeta = *_LotusMsgMeta__Maybe

+ func (m MaybeLotusMsgMeta) AsNode() ipld.Node

+ func (m MaybeLotusMsgMeta) Exists() bool

+ func (m MaybeLotusMsgMeta) IsAbsent() bool

+ func (m MaybeLotusMsgMeta) IsNull() bool

+ func (m MaybeLotusMsgMeta) Must() LotusMsgMeta

+ type MaybeLotusSignedMessage = *_LotusSignedMessage__Maybe

+ func (m MaybeLotusSignedMessage) AsNode() ipld.Node

+ func (m MaybeLotusSignedMessage) Exists() bool

+ func (m MaybeLotusSignedMessage) IsAbsent() bool

+ func (m MaybeLotusSignedMessage) IsNull() bool

+ func (m MaybeLotusSignedMessage) Must() LotusSignedMessage

+ type MaybeLotusStateRoot = *_LotusStateRoot__Maybe

+ func (m MaybeLotusStateRoot) AsNode() ipld.Node

+ func (m MaybeLotusStateRoot) Exists() bool

+ func (m MaybeLotusStateRoot) IsAbsent() bool

+ func (m MaybeLotusStateRoot) IsNull() bool

+ func (m MaybeLotusStateRoot) Must() LotusStateRoot

+ type MaybeLotusTicket = *_LotusTicket__Maybe

+ func (m MaybeLotusTicket) AsNode() ipld.Node

+ func (m MaybeLotusTicket) Exists() bool

+ func (m MaybeLotusTicket) IsAbsent() bool

+ func (m MaybeLotusTicket) IsNull() bool

+ func (m MaybeLotusTicket) Must() LotusTicket

+ type MaybeMap = *_Map__Maybe

+ func (m MaybeMap) AsNode() ipld.Node

+ func (m MaybeMap) Exists() bool

+ func (m MaybeMap) IsAbsent() bool

+ func (m MaybeMap) IsNull() bool

+ func (m MaybeMap) Must() Map

+ type MaybeMapV3__BitField = *_MapV3__BitField__Maybe

+ func (m MaybeMapV3__BitField) AsNode() ipld.Node

+ func (m MaybeMapV3__BitField) Exists() bool

+ func (m MaybeMapV3__BitField) IsAbsent() bool

+ func (m MaybeMapV3__BitField) IsNull() bool

+ func (m MaybeMapV3__BitField) Must() MapV3__BitField

+ type MaybeMapV3__List__DealID = *_MapV3__List__DealID__Maybe

+ func (m MaybeMapV3__List__DealID) AsNode() ipld.Node

+ func (m MaybeMapV3__List__DealID) Exists() bool

+ func (m MaybeMapV3__List__DealID) IsAbsent() bool

+ func (m MaybeMapV3__List__DealID) IsNull() bool

+ func (m MaybeMapV3__List__DealID) Must() MapV3__List__DealID

+ type MaybeMap__ActorID = *_Map__ActorID__Maybe

+ func (m MaybeMap__ActorID) AsNode() ipld.Node

+ func (m MaybeMap__ActorID) Exists() bool

+ func (m MaybeMap__ActorID) IsAbsent() bool

+ func (m MaybeMap__ActorID) IsNull() bool

+ func (m MaybeMap__ActorID) Must() Map__ActorID

+ type MaybeMap__BalanceTable = *_Map__BalanceTable__Maybe

+ func (m MaybeMap__BalanceTable) AsNode() ipld.Node

+ func (m MaybeMap__BalanceTable) Exists() bool

+ func (m MaybeMap__BalanceTable) IsAbsent() bool

+ func (m MaybeMap__BalanceTable) IsNull() bool

+ func (m MaybeMap__BalanceTable) Must() Map__BalanceTable

+ type MaybeMap__BitField = *_Map__BitField__Maybe

+ func (m MaybeMap__BitField) AsNode() ipld.Node

+ func (m MaybeMap__BitField) Exists() bool

+ func (m MaybeMap__BitField) IsAbsent() bool

+ func (m MaybeMap__BitField) IsNull() bool

+ func (m MaybeMap__BitField) Must() Map__BitField

+ type MaybeMap__DataCap = *_Map__DataCap__Maybe

+ func (m MaybeMap__DataCap) AsNode() ipld.Node

+ func (m MaybeMap__DataCap) Exists() bool

+ func (m MaybeMap__DataCap) IsAbsent() bool

+ func (m MaybeMap__DataCap) IsNull() bool

+ func (m MaybeMap__DataCap) Must() Map__DataCap

+ type MaybeMap__List__DealID = *_Map__List__DealID__Maybe

+ func (m MaybeMap__List__DealID) AsNode() ipld.Node

+ func (m MaybeMap__List__DealID) Exists() bool

+ func (m MaybeMap__List__DealID) IsAbsent() bool

+ func (m MaybeMap__List__DealID) IsNull() bool

+ func (m MaybeMap__List__DealID) Must() Map__List__DealID

+ type MaybeMap__LotusActors = *_Map__LotusActors__Maybe

+ func (m MaybeMap__LotusActors) AsNode() ipld.Node

+ func (m MaybeMap__LotusActors) Exists() bool

+ func (m MaybeMap__LotusActors) IsAbsent() bool

+ func (m MaybeMap__LotusActors) IsNull() bool

+ func (m MaybeMap__LotusActors) Must() Map__LotusActors

+ type MaybeMap__MarketV0DealProposal = *_Map__MarketV0DealProposal__Maybe

+ func (m MaybeMap__MarketV0DealProposal) AsNode() ipld.Node

+ func (m MaybeMap__MarketV0DealProposal) Exists() bool

+ func (m MaybeMap__MarketV0DealProposal) IsAbsent() bool

+ func (m MaybeMap__MarketV0DealProposal) IsNull() bool

+ func (m MaybeMap__MarketV0DealProposal) Must() Map__MarketV0DealProposal

+ type MaybeMap__MarketV0DealState = *_Map__MarketV0DealState__Maybe

+ func (m MaybeMap__MarketV0DealState) AsNode() ipld.Node

+ func (m MaybeMap__MarketV0DealState) Exists() bool

+ func (m MaybeMap__MarketV0DealState) IsAbsent() bool

+ func (m MaybeMap__MarketV0DealState) IsNull() bool

+ func (m MaybeMap__MarketV0DealState) Must() Map__MarketV0DealState

+ type MaybeMap__MarketV0RawDealProposal = *_Map__MarketV0RawDealProposal__Maybe

+ func (m MaybeMap__MarketV0RawDealProposal) AsNode() ipld.Node

+ func (m MaybeMap__MarketV0RawDealProposal) Exists() bool

+ func (m MaybeMap__MarketV0RawDealProposal) IsAbsent() bool

+ func (m MaybeMap__MarketV0RawDealProposal) IsNull() bool

+ func (m MaybeMap__MarketV0RawDealProposal) Must() Map__MarketV0RawDealProposal

+ type MaybeMap__MarketV2DealProposal = *_Map__MarketV2DealProposal__Maybe

+ func (m MaybeMap__MarketV2DealProposal) AsNode() ipld.Node

+ func (m MaybeMap__MarketV2DealProposal) Exists() bool

+ func (m MaybeMap__MarketV2DealProposal) IsAbsent() bool

+ func (m MaybeMap__MarketV2DealProposal) IsNull() bool

+ func (m MaybeMap__MarketV2DealProposal) Must() Map__MarketV2DealProposal

+ type MaybeMap__MarketV2RawDealProposal = *_Map__MarketV2RawDealProposal__Maybe

+ func (m MaybeMap__MarketV2RawDealProposal) AsNode() ipld.Node

+ func (m MaybeMap__MarketV2RawDealProposal) Exists() bool

+ func (m MaybeMap__MarketV2RawDealProposal) IsAbsent() bool

+ func (m MaybeMap__MarketV2RawDealProposal) IsNull() bool

+ func (m MaybeMap__MarketV2RawDealProposal) Must() Map__MarketV2RawDealProposal

+ type MaybeMap__MarketV3DealProposal = *_Map__MarketV3DealProposal__Maybe

+ func (m MaybeMap__MarketV3DealProposal) AsNode() ipld.Node

+ func (m MaybeMap__MarketV3DealProposal) Exists() bool

+ func (m MaybeMap__MarketV3DealProposal) IsAbsent() bool

+ func (m MaybeMap__MarketV3DealProposal) IsNull() bool

+ func (m MaybeMap__MarketV3DealProposal) Must() Map__MarketV3DealProposal

+ type MaybeMap__MarketV3DealState = *_Map__MarketV3DealState__Maybe

+ func (m MaybeMap__MarketV3DealState) AsNode() ipld.Node

+ func (m MaybeMap__MarketV3DealState) Exists() bool

+ func (m MaybeMap__MarketV3DealState) IsAbsent() bool

+ func (m MaybeMap__MarketV3DealState) IsNull() bool

+ func (m MaybeMap__MarketV3DealState) Must() Map__MarketV3DealState

+ type MaybeMap__MarketV3RawDealProposal = *_Map__MarketV3RawDealProposal__Maybe

+ func (m MaybeMap__MarketV3RawDealProposal) AsNode() ipld.Node

+ func (m MaybeMap__MarketV3RawDealProposal) Exists() bool

+ func (m MaybeMap__MarketV3RawDealProposal) IsAbsent() bool

+ func (m MaybeMap__MarketV3RawDealProposal) IsNull() bool

+ func (m MaybeMap__MarketV3RawDealProposal) Must() Map__MarketV3RawDealProposal

+ type MaybeMap__MinerV0ExpirationSet = *_Map__MinerV0ExpirationSet__Maybe

+ func (m MaybeMap__MinerV0ExpirationSet) AsNode() ipld.Node

+ func (m MaybeMap__MinerV0ExpirationSet) Exists() bool

+ func (m MaybeMap__MinerV0ExpirationSet) IsAbsent() bool

+ func (m MaybeMap__MinerV0ExpirationSet) IsNull() bool

+ func (m MaybeMap__MinerV0ExpirationSet) Must() Map__MinerV0ExpirationSet

+ type MaybeMap__MinerV0Partition = *_Map__MinerV0Partition__Maybe

+ func (m MaybeMap__MinerV0Partition) AsNode() ipld.Node

+ func (m MaybeMap__MinerV0Partition) Exists() bool

+ func (m MaybeMap__MinerV0Partition) IsAbsent() bool

+ func (m MaybeMap__MinerV0Partition) IsNull() bool

+ func (m MaybeMap__MinerV0Partition) Must() Map__MinerV0Partition

+ type MaybeMap__MinerV2Partition = *_Map__MinerV2Partition__Maybe

+ func (m MaybeMap__MinerV2Partition) AsNode() ipld.Node

+ func (m MaybeMap__MinerV2Partition) Exists() bool

+ func (m MaybeMap__MinerV2Partition) IsAbsent() bool

+ func (m MaybeMap__MinerV2Partition) IsNull() bool

+ func (m MaybeMap__MinerV2Partition) Must() Map__MinerV2Partition

+ type MaybeMap__MinerV3ExpirationSet = *_Map__MinerV3ExpirationSet__Maybe

+ func (m MaybeMap__MinerV3ExpirationSet) AsNode() ipld.Node

+ func (m MaybeMap__MinerV3ExpirationSet) Exists() bool

+ func (m MaybeMap__MinerV3ExpirationSet) IsAbsent() bool

+ func (m MaybeMap__MinerV3ExpirationSet) IsNull() bool

+ func (m MaybeMap__MinerV3ExpirationSet) Must() Map__MinerV3ExpirationSet

+ type MaybeMap__MinerV3Partition = *_Map__MinerV3Partition__Maybe

+ func (m MaybeMap__MinerV3Partition) AsNode() ipld.Node

+ func (m MaybeMap__MinerV3Partition) Exists() bool

+ func (m MaybeMap__MinerV3Partition) IsAbsent() bool

+ func (m MaybeMap__MinerV3Partition) IsNull() bool

+ func (m MaybeMap__MinerV3Partition) Must() Map__MinerV3Partition

+ type MaybeMap__MultisigV0Transaction = *_Map__MultisigV0Transaction__Maybe

+ func (m MaybeMap__MultisigV0Transaction) AsNode() ipld.Node

+ func (m MaybeMap__MultisigV0Transaction) Exists() bool

+ func (m MaybeMap__MultisigV0Transaction) IsAbsent() bool

+ func (m MaybeMap__MultisigV0Transaction) IsNull() bool

+ func (m MaybeMap__MultisigV0Transaction) Must() Map__MultisigV0Transaction

+ type MaybeMap__MultisigV3Transaction = *_Map__MultisigV3Transaction__Maybe

+ func (m MaybeMap__MultisigV3Transaction) AsNode() ipld.Node

+ func (m MaybeMap__MultisigV3Transaction) Exists() bool

+ func (m MaybeMap__MultisigV3Transaction) IsAbsent() bool

+ func (m MaybeMap__MultisigV3Transaction) IsNull() bool

+ func (m MaybeMap__MultisigV3Transaction) Must() Map__MultisigV3Transaction

+ type MaybeMap__PaychV0LaneState = *_Map__PaychV0LaneState__Maybe

+ func (m MaybeMap__PaychV0LaneState) AsNode() ipld.Node

+ func (m MaybeMap__PaychV0LaneState) Exists() bool

+ func (m MaybeMap__PaychV0LaneState) IsAbsent() bool

+ func (m MaybeMap__PaychV0LaneState) IsNull() bool

+ func (m MaybeMap__PaychV0LaneState) Must() Map__PaychV0LaneState

+ type MaybeMap__PaychV3LaneState = *_Map__PaychV3LaneState__Maybe

+ func (m MaybeMap__PaychV3LaneState) AsNode() ipld.Node

+ func (m MaybeMap__PaychV3LaneState) Exists() bool

+ func (m MaybeMap__PaychV3LaneState) IsAbsent() bool

+ func (m MaybeMap__PaychV3LaneState) IsNull() bool

+ func (m MaybeMap__PaychV3LaneState) Must() Map__PaychV3LaneState

+ type MaybeMap__PowerV0Claim = *_Map__PowerV0Claim__Maybe

+ func (m MaybeMap__PowerV0Claim) AsNode() ipld.Node

+ func (m MaybeMap__PowerV0Claim) Exists() bool

+ func (m MaybeMap__PowerV0Claim) IsAbsent() bool

+ func (m MaybeMap__PowerV0Claim) IsNull() bool

+ func (m MaybeMap__PowerV0Claim) Must() Map__PowerV0Claim

+ type MaybeMap__PowerV0CronEvent = *_Map__PowerV0CronEvent__Maybe

+ func (m MaybeMap__PowerV0CronEvent) AsNode() ipld.Node

+ func (m MaybeMap__PowerV0CronEvent) Exists() bool

+ func (m MaybeMap__PowerV0CronEvent) IsAbsent() bool

+ func (m MaybeMap__PowerV0CronEvent) IsNull() bool

+ func (m MaybeMap__PowerV0CronEvent) Must() Map__PowerV0CronEvent

+ type MaybeMap__PowerV2Claim = *_Map__PowerV2Claim__Maybe

+ func (m MaybeMap__PowerV2Claim) AsNode() ipld.Node

+ func (m MaybeMap__PowerV2Claim) Exists() bool

+ func (m MaybeMap__PowerV2Claim) IsAbsent() bool

+ func (m MaybeMap__PowerV2Claim) IsNull() bool

+ func (m MaybeMap__PowerV2Claim) Must() Map__PowerV2Claim

+ type MaybeMap__PowerV3Claim = *_Map__PowerV3Claim__Maybe

+ func (m MaybeMap__PowerV3Claim) AsNode() ipld.Node

+ func (m MaybeMap__PowerV3Claim) Exists() bool

+ func (m MaybeMap__PowerV3Claim) IsAbsent() bool

+ func (m MaybeMap__PowerV3Claim) IsNull() bool

+ func (m MaybeMap__PowerV3Claim) Must() Map__PowerV3Claim

+ type MaybeMap__PowerV3CronEvent = *_Map__PowerV3CronEvent__Maybe

+ func (m MaybeMap__PowerV3CronEvent) AsNode() ipld.Node

+ func (m MaybeMap__PowerV3CronEvent) Exists() bool

+ func (m MaybeMap__PowerV3CronEvent) IsAbsent() bool

+ func (m MaybeMap__PowerV3CronEvent) IsNull() bool

+ func (m MaybeMap__PowerV3CronEvent) Must() Map__PowerV3CronEvent

+ type MaybeMap__SectorOnChainInfo = *_Map__SectorOnChainInfo__Maybe

+ func (m MaybeMap__SectorOnChainInfo) AsNode() ipld.Node

+ func (m MaybeMap__SectorOnChainInfo) Exists() bool

+ func (m MaybeMap__SectorOnChainInfo) IsAbsent() bool

+ func (m MaybeMap__SectorOnChainInfo) IsNull() bool

+ func (m MaybeMap__SectorOnChainInfo) Must() Map__SectorOnChainInfo

+ type MaybeMap__SectorPreCommitOnChainInfo = *_Map__SectorPreCommitOnChainInfo__Maybe

+ func (m MaybeMap__SectorPreCommitOnChainInfo) AsNode() ipld.Node

+ func (m MaybeMap__SectorPreCommitOnChainInfo) Exists() bool

+ func (m MaybeMap__SectorPreCommitOnChainInfo) IsAbsent() bool

+ func (m MaybeMap__SectorPreCommitOnChainInfo) IsNull() bool

+ func (m MaybeMap__SectorPreCommitOnChainInfo) Must() Map__SectorPreCommitOnChainInfo

+ type MaybeMap__SectorV2OnChainInfo = *_Map__SectorV2OnChainInfo__Maybe

+ func (m MaybeMap__SectorV2OnChainInfo) AsNode() ipld.Node

+ func (m MaybeMap__SectorV2OnChainInfo) Exists() bool

+ func (m MaybeMap__SectorV2OnChainInfo) IsAbsent() bool

+ func (m MaybeMap__SectorV2OnChainInfo) IsNull() bool

+ func (m MaybeMap__SectorV2OnChainInfo) Must() Map__SectorV2OnChainInfo

+ type MaybeMap__SectorV3OnChainInfo = *_Map__SectorV3OnChainInfo__Maybe

+ func (m MaybeMap__SectorV3OnChainInfo) AsNode() ipld.Node

+ func (m MaybeMap__SectorV3OnChainInfo) Exists() bool

+ func (m MaybeMap__SectorV3OnChainInfo) IsAbsent() bool

+ func (m MaybeMap__SectorV3OnChainInfo) IsNull() bool

+ func (m MaybeMap__SectorV3OnChainInfo) Must() Map__SectorV3OnChainInfo

+ type MaybeMap__V3ActorID = *_Map__V3ActorID__Maybe

+ func (m MaybeMap__V3ActorID) AsNode() ipld.Node

+ func (m MaybeMap__V3ActorID) Exists() bool

+ func (m MaybeMap__V3ActorID) IsAbsent() bool

+ func (m MaybeMap__V3ActorID) IsNull() bool

+ func (m MaybeMap__V3ActorID) Must() Map__V3ActorID

+ type MaybeMap__V3BalanceTable = *_Map__V3BalanceTable__Maybe

+ func (m MaybeMap__V3BalanceTable) AsNode() ipld.Node

+ func (m MaybeMap__V3BalanceTable) Exists() bool

+ func (m MaybeMap__V3BalanceTable) IsAbsent() bool

+ func (m MaybeMap__V3BalanceTable) IsNull() bool

+ func (m MaybeMap__V3BalanceTable) Must() Map__V3BalanceTable

+ type MaybeMap__V3DataCap = *_Map__V3DataCap__Maybe

+ func (m MaybeMap__V3DataCap) AsNode() ipld.Node

+ func (m MaybeMap__V3DataCap) Exists() bool

+ func (m MaybeMap__V3DataCap) IsAbsent() bool

+ func (m MaybeMap__V3DataCap) IsNull() bool

+ func (m MaybeMap__V3DataCap) Must() Map__V3DataCap

+ type MaybeMap__V3SectorPreCommitOnChainInfo = *_Map__V3SectorPreCommitOnChainInfo__Maybe

+ func (m MaybeMap__V3SectorPreCommitOnChainInfo) AsNode() ipld.Node

+ func (m MaybeMap__V3SectorPreCommitOnChainInfo) Exists() bool

+ func (m MaybeMap__V3SectorPreCommitOnChainInfo) IsAbsent() bool

+ func (m MaybeMap__V3SectorPreCommitOnChainInfo) IsNull() bool

+ func (m MaybeMap__V3SectorPreCommitOnChainInfo) Must() Map__V3SectorPreCommitOnChainInfo

+ type MaybeMapv3__LotusActors = *_Mapv3__LotusActors__Maybe

+ func (m MaybeMapv3__LotusActors) AsNode() ipld.Node

+ func (m MaybeMapv3__LotusActors) Exists() bool

+ func (m MaybeMapv3__LotusActors) IsAbsent() bool

+ func (m MaybeMapv3__LotusActors) IsNull() bool

+ func (m MaybeMapv3__LotusActors) Must() Mapv3__LotusActors

+ type MaybeMarketClientDealProposal = *_MarketClientDealProposal__Maybe

+ func (m MaybeMarketClientDealProposal) AsNode() ipld.Node

+ func (m MaybeMarketClientDealProposal) Exists() bool

+ func (m MaybeMarketClientDealProposal) IsAbsent() bool

+ func (m MaybeMarketClientDealProposal) IsNull() bool

+ func (m MaybeMarketClientDealProposal) Must() MarketClientDealProposal

+ type MaybeMarketV0DealProposal = *_MarketV0DealProposal__Maybe

+ func (m MaybeMarketV0DealProposal) AsNode() ipld.Node

+ func (m MaybeMarketV0DealProposal) Exists() bool

+ func (m MaybeMarketV0DealProposal) IsAbsent() bool

+ func (m MaybeMarketV0DealProposal) IsNull() bool

+ func (m MaybeMarketV0DealProposal) Must() MarketV0DealProposal

+ type MaybeMarketV0DealState = *_MarketV0DealState__Maybe

+ func (m MaybeMarketV0DealState) AsNode() ipld.Node

+ func (m MaybeMarketV0DealState) Exists() bool

+ func (m MaybeMarketV0DealState) IsAbsent() bool

+ func (m MaybeMarketV0DealState) IsNull() bool

+ func (m MaybeMarketV0DealState) Must() MarketV0DealState

+ type MaybeMarketV0State = *_MarketV0State__Maybe

+ func (m MaybeMarketV0State) AsNode() ipld.Node

+ func (m MaybeMarketV0State) Exists() bool

+ func (m MaybeMarketV0State) IsAbsent() bool

+ func (m MaybeMarketV0State) IsNull() bool

+ func (m MaybeMarketV0State) Must() MarketV0State

+ type MaybeMarketV2DealProposal = *_MarketV2DealProposal__Maybe

+ func (m MaybeMarketV2DealProposal) AsNode() ipld.Node

+ func (m MaybeMarketV2DealProposal) Exists() bool

+ func (m MaybeMarketV2DealProposal) IsAbsent() bool

+ func (m MaybeMarketV2DealProposal) IsNull() bool

+ func (m MaybeMarketV2DealProposal) Must() MarketV2DealProposal

+ type MaybeMarketV2State = *_MarketV2State__Maybe

+ func (m MaybeMarketV2State) AsNode() ipld.Node

+ func (m MaybeMarketV2State) Exists() bool

+ func (m MaybeMarketV2State) IsAbsent() bool

+ func (m MaybeMarketV2State) IsNull() bool

+ func (m MaybeMarketV2State) Must() MarketV2State

+ type MaybeMarketV3State = *_MarketV3State__Maybe

+ func (m MaybeMarketV3State) AsNode() ipld.Node

+ func (m MaybeMarketV3State) Exists() bool

+ func (m MaybeMarketV3State) IsAbsent() bool

+ func (m MaybeMarketV3State) IsNull() bool

+ func (m MaybeMarketV3State) Must() MarketV3State

+ type MaybeMarketV5State = *_MarketV5State__Maybe

+ func (m MaybeMarketV5State) AsNode() ipld.Node

+ func (m MaybeMarketV5State) Exists() bool

+ func (m MaybeMarketV5State) IsAbsent() bool

+ func (m MaybeMarketV5State) IsNull() bool

+ func (m MaybeMarketV5State) Must() MarketV5State

+ type MaybeMerge = *_Merge__Maybe

+ func (m MaybeMerge) AsNode() ipld.Node

+ func (m MaybeMerge) Exists() bool

+ func (m MaybeMerge) IsAbsent() bool

+ func (m MaybeMerge) IsNull() bool

+ func (m MaybeMerge) Must() Merge

+ type MaybeMessageParamsInitExecParams = *_MessageParamsInitExecParams__Maybe

+ func (m MaybeMessageParamsInitExecParams) AsNode() ipld.Node

+ func (m MaybeMessageParamsInitExecParams) Exists() bool

+ func (m MaybeMessageParamsInitExecParams) IsAbsent() bool

+ func (m MaybeMessageParamsInitExecParams) IsNull() bool

+ func (m MaybeMessageParamsInitExecParams) Must() MessageParamsInitExecParams

+ type MaybeMessageParamsMarketActivateDeals = *_MessageParamsMarketActivateDeals__Maybe

+ func (m MaybeMessageParamsMarketActivateDeals) AsNode() ipld.Node

+ func (m MaybeMessageParamsMarketActivateDeals) Exists() bool

+ func (m MaybeMessageParamsMarketActivateDeals) IsAbsent() bool

+ func (m MaybeMessageParamsMarketActivateDeals) IsNull() bool

+ func (m MaybeMessageParamsMarketActivateDeals) Must() MessageParamsMarketActivateDeals

+ type MaybeMessageParamsMarketComputeCommitment = *_MessageParamsMarketComputeCommitment__Maybe

+ func (m MaybeMessageParamsMarketComputeCommitment) AsNode() ipld.Node

+ func (m MaybeMessageParamsMarketComputeCommitment) Exists() bool

+ func (m MaybeMessageParamsMarketComputeCommitment) IsAbsent() bool

+ func (m MaybeMessageParamsMarketComputeCommitment) IsNull() bool

+ func (m MaybeMessageParamsMarketComputeCommitment) Must() MessageParamsMarketComputeCommitment

+ type MaybeMessageParamsMarketPublishDeals = *_MessageParamsMarketPublishDeals__Maybe

+ func (m MaybeMessageParamsMarketPublishDeals) AsNode() ipld.Node

+ func (m MaybeMessageParamsMarketPublishDeals) Exists() bool

+ func (m MaybeMessageParamsMarketPublishDeals) IsAbsent() bool

+ func (m MaybeMessageParamsMarketPublishDeals) IsNull() bool

+ func (m MaybeMessageParamsMarketPublishDeals) Must() MessageParamsMarketPublishDeals

+ type MaybeMessageParamsMarketTerminateDeals = *_MessageParamsMarketTerminateDeals__Maybe

+ func (m MaybeMessageParamsMarketTerminateDeals) AsNode() ipld.Node

+ func (m MaybeMessageParamsMarketTerminateDeals) Exists() bool

+ func (m MaybeMessageParamsMarketTerminateDeals) IsAbsent() bool

+ func (m MaybeMessageParamsMarketTerminateDeals) IsNull() bool

+ func (m MaybeMessageParamsMarketTerminateDeals) Must() MessageParamsMarketTerminateDeals

+ type MaybeMessageParamsMarketV5ComputeCommitment = *_MessageParamsMarketV5ComputeCommitment__Maybe

+ func (m MaybeMessageParamsMarketV5ComputeCommitment) AsNode() ipld.Node

+ func (m MaybeMessageParamsMarketV5ComputeCommitment) Exists() bool

+ func (m MaybeMessageParamsMarketV5ComputeCommitment) IsAbsent() bool

+ func (m MaybeMessageParamsMarketV5ComputeCommitment) IsNull() bool

+ func (m MaybeMessageParamsMarketV5ComputeCommitment) Must() MessageParamsMarketV5ComputeCommitment

+ type MaybeMessageParamsMarketVerifyDeals = *_MessageParamsMarketVerifyDeals__Maybe

+ func (m MaybeMessageParamsMarketVerifyDeals) AsNode() ipld.Node

+ func (m MaybeMessageParamsMarketVerifyDeals) Exists() bool

+ func (m MaybeMessageParamsMarketVerifyDeals) IsAbsent() bool

+ func (m MaybeMessageParamsMarketVerifyDeals) IsNull() bool

+ func (m MaybeMessageParamsMarketVerifyDeals) Must() MessageParamsMarketVerifyDeals

+ type MaybeMessageParamsMarketWithdrawBalance = *_MessageParamsMarketWithdrawBalance__Maybe

+ func (m MaybeMessageParamsMarketWithdrawBalance) AsNode() ipld.Node

+ func (m MaybeMessageParamsMarketWithdrawBalance) Exists() bool

+ func (m MaybeMessageParamsMarketWithdrawBalance) IsAbsent() bool

+ func (m MaybeMessageParamsMarketWithdrawBalance) IsNull() bool

+ func (m MaybeMessageParamsMarketWithdrawBalance) Must() MessageParamsMarketWithdrawBalance

+ type MaybeMessageParamsMinerChangeAddress = *_MessageParamsMinerChangeAddress__Maybe

+ func (m MaybeMessageParamsMinerChangeAddress) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerChangeAddress) Exists() bool

+ func (m MaybeMessageParamsMinerChangeAddress) IsAbsent() bool

+ func (m MaybeMessageParamsMinerChangeAddress) IsNull() bool

+ func (m MaybeMessageParamsMinerChangeAddress) Must() MessageParamsMinerChangeAddress

+ type MaybeMessageParamsMinerChangeMultiaddrs = *_MessageParamsMinerChangeMultiaddrs__Maybe

+ func (m MaybeMessageParamsMinerChangeMultiaddrs) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerChangeMultiaddrs) Exists() bool

+ func (m MaybeMessageParamsMinerChangeMultiaddrs) IsAbsent() bool

+ func (m MaybeMessageParamsMinerChangeMultiaddrs) IsNull() bool

+ func (m MaybeMessageParamsMinerChangeMultiaddrs) Must() MessageParamsMinerChangeMultiaddrs

+ type MaybeMessageParamsMinerChangePeerID = *_MessageParamsMinerChangePeerID__Maybe

+ func (m MaybeMessageParamsMinerChangePeerID) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerChangePeerID) Exists() bool

+ func (m MaybeMessageParamsMinerChangePeerID) IsAbsent() bool

+ func (m MaybeMessageParamsMinerChangePeerID) IsNull() bool

+ func (m MaybeMessageParamsMinerChangePeerID) Must() MessageParamsMinerChangePeerID

+ type MaybeMessageParamsMinerCheckSectorProven = *_MessageParamsMinerCheckSectorProven__Maybe

+ func (m MaybeMessageParamsMinerCheckSectorProven) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerCheckSectorProven) Exists() bool

+ func (m MaybeMessageParamsMinerCheckSectorProven) IsAbsent() bool

+ func (m MaybeMessageParamsMinerCheckSectorProven) IsNull() bool

+ func (m MaybeMessageParamsMinerCheckSectorProven) Must() MessageParamsMinerCheckSectorProven

+ type MaybeMessageParamsMinerCompactPartitions = *_MessageParamsMinerCompactPartitions__Maybe

+ func (m MaybeMessageParamsMinerCompactPartitions) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerCompactPartitions) Exists() bool

+ func (m MaybeMessageParamsMinerCompactPartitions) IsAbsent() bool

+ func (m MaybeMessageParamsMinerCompactPartitions) IsNull() bool

+ func (m MaybeMessageParamsMinerCompactPartitions) Must() MessageParamsMinerCompactPartitions

+ type MaybeMessageParamsMinerCompactSectorNumbers = *_MessageParamsMinerCompactSectorNumbers__Maybe

+ func (m MaybeMessageParamsMinerCompactSectorNumbers) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerCompactSectorNumbers) Exists() bool

+ func (m MaybeMessageParamsMinerCompactSectorNumbers) IsAbsent() bool

+ func (m MaybeMessageParamsMinerCompactSectorNumbers) IsNull() bool

+ func (m MaybeMessageParamsMinerCompactSectorNumbers) Must() MessageParamsMinerCompactSectorNumbers

+ type MaybeMessageParamsMinerConfirmSectorProofs = *_MessageParamsMinerConfirmSectorProofs__Maybe

+ func (m MaybeMessageParamsMinerConfirmSectorProofs) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerConfirmSectorProofs) Exists() bool

+ func (m MaybeMessageParamsMinerConfirmSectorProofs) IsAbsent() bool

+ func (m MaybeMessageParamsMinerConfirmSectorProofs) IsNull() bool

+ func (m MaybeMessageParamsMinerConfirmSectorProofs) Must() MessageParamsMinerConfirmSectorProofs

+ type MaybeMessageParamsMinerConstructor = *_MessageParamsMinerConstructor__Maybe

+ func (m MaybeMessageParamsMinerConstructor) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerConstructor) Exists() bool

+ func (m MaybeMessageParamsMinerConstructor) IsAbsent() bool

+ func (m MaybeMessageParamsMinerConstructor) IsNull() bool

+ func (m MaybeMessageParamsMinerConstructor) Must() MessageParamsMinerConstructor

+ type MaybeMessageParamsMinerDeclareFaults = *_MessageParamsMinerDeclareFaults__Maybe

+ func (m MaybeMessageParamsMinerDeclareFaults) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerDeclareFaults) Exists() bool

+ func (m MaybeMessageParamsMinerDeclareFaults) IsAbsent() bool

+ func (m MaybeMessageParamsMinerDeclareFaults) IsNull() bool

+ func (m MaybeMessageParamsMinerDeclareFaults) Must() MessageParamsMinerDeclareFaults

+ type MaybeMessageParamsMinerDeclareFaultsRecovered = *_MessageParamsMinerDeclareFaultsRecovered__Maybe

+ func (m MaybeMessageParamsMinerDeclareFaultsRecovered) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerDeclareFaultsRecovered) Exists() bool

+ func (m MaybeMessageParamsMinerDeclareFaultsRecovered) IsAbsent() bool

+ func (m MaybeMessageParamsMinerDeclareFaultsRecovered) IsNull() bool

+ func (m MaybeMessageParamsMinerDeclareFaultsRecovered) Must() MessageParamsMinerDeclareFaultsRecovered

+ type MaybeMessageParamsMinerDeferredCron = *_MessageParamsMinerDeferredCron__Maybe

+ func (m MaybeMessageParamsMinerDeferredCron) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerDeferredCron) Exists() bool

+ func (m MaybeMessageParamsMinerDeferredCron) IsAbsent() bool

+ func (m MaybeMessageParamsMinerDeferredCron) IsNull() bool

+ func (m MaybeMessageParamsMinerDeferredCron) Must() MessageParamsMinerDeferredCron

+ type MaybeMessageParamsMinerDisputeWindowedPoSt = *_MessageParamsMinerDisputeWindowedPoSt__Maybe

+ func (m MaybeMessageParamsMinerDisputeWindowedPoSt) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerDisputeWindowedPoSt) Exists() bool

+ func (m MaybeMessageParamsMinerDisputeWindowedPoSt) IsAbsent() bool

+ func (m MaybeMessageParamsMinerDisputeWindowedPoSt) IsNull() bool

+ func (m MaybeMessageParamsMinerDisputeWindowedPoSt) Must() MessageParamsMinerDisputeWindowedPoSt

+ type MaybeMessageParamsMinerExtendSectorExpiration = *_MessageParamsMinerExtendSectorExpiration__Maybe

+ func (m MaybeMessageParamsMinerExtendSectorExpiration) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerExtendSectorExpiration) Exists() bool

+ func (m MaybeMessageParamsMinerExtendSectorExpiration) IsAbsent() bool

+ func (m MaybeMessageParamsMinerExtendSectorExpiration) IsNull() bool

+ func (m MaybeMessageParamsMinerExtendSectorExpiration) Must() MessageParamsMinerExtendSectorExpiration

+ type MaybeMessageParamsMinerPreCommitSectorBatch = *_MessageParamsMinerPreCommitSectorBatch__Maybe

+ func (m MaybeMessageParamsMinerPreCommitSectorBatch) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerPreCommitSectorBatch) Exists() bool

+ func (m MaybeMessageParamsMinerPreCommitSectorBatch) IsAbsent() bool

+ func (m MaybeMessageParamsMinerPreCommitSectorBatch) IsNull() bool

+ func (m MaybeMessageParamsMinerPreCommitSectorBatch) Must() MessageParamsMinerPreCommitSectorBatch

+ type MaybeMessageParamsMinerProveCommitAggregate = *_MessageParamsMinerProveCommitAggregate__Maybe

+ func (m MaybeMessageParamsMinerProveCommitAggregate) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerProveCommitAggregate) Exists() bool

+ func (m MaybeMessageParamsMinerProveCommitAggregate) IsAbsent() bool

+ func (m MaybeMessageParamsMinerProveCommitAggregate) IsNull() bool

+ func (m MaybeMessageParamsMinerProveCommitAggregate) Must() MessageParamsMinerProveCommitAggregate

+ type MaybeMessageParamsMinerProveCommitSector = *_MessageParamsMinerProveCommitSector__Maybe

+ func (m MaybeMessageParamsMinerProveCommitSector) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerProveCommitSector) Exists() bool

+ func (m MaybeMessageParamsMinerProveCommitSector) IsAbsent() bool

+ func (m MaybeMessageParamsMinerProveCommitSector) IsNull() bool

+ func (m MaybeMessageParamsMinerProveCommitSector) Must() MessageParamsMinerProveCommitSector

+ type MaybeMessageParamsMinerReportFault = *_MessageParamsMinerReportFault__Maybe

+ func (m MaybeMessageParamsMinerReportFault) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerReportFault) Exists() bool

+ func (m MaybeMessageParamsMinerReportFault) IsAbsent() bool

+ func (m MaybeMessageParamsMinerReportFault) IsNull() bool

+ func (m MaybeMessageParamsMinerReportFault) Must() MessageParamsMinerReportFault

+ type MaybeMessageParamsMinerSubmitWindowedPoSt = *_MessageParamsMinerSubmitWindowedPoSt__Maybe

+ func (m MaybeMessageParamsMinerSubmitWindowedPoSt) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerSubmitWindowedPoSt) Exists() bool

+ func (m MaybeMessageParamsMinerSubmitWindowedPoSt) IsAbsent() bool

+ func (m MaybeMessageParamsMinerSubmitWindowedPoSt) IsNull() bool

+ func (m MaybeMessageParamsMinerSubmitWindowedPoSt) Must() MessageParamsMinerSubmitWindowedPoSt

+ type MaybeMessageParamsMinerTerminateSectors = *_MessageParamsMinerTerminateSectors__Maybe

+ func (m MaybeMessageParamsMinerTerminateSectors) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerTerminateSectors) Exists() bool

+ func (m MaybeMessageParamsMinerTerminateSectors) IsAbsent() bool

+ func (m MaybeMessageParamsMinerTerminateSectors) IsNull() bool

+ func (m MaybeMessageParamsMinerTerminateSectors) Must() MessageParamsMinerTerminateSectors

+ type MaybeMessageParamsMinerWithdrawBalance = *_MessageParamsMinerWithdrawBalance__Maybe

+ func (m MaybeMessageParamsMinerWithdrawBalance) AsNode() ipld.Node

+ func (m MaybeMessageParamsMinerWithdrawBalance) Exists() bool

+ func (m MaybeMessageParamsMinerWithdrawBalance) IsAbsent() bool

+ func (m MaybeMessageParamsMinerWithdrawBalance) IsNull() bool

+ func (m MaybeMessageParamsMinerWithdrawBalance) Must() MessageParamsMinerWithdrawBalance

+ type MaybeMessageParamsMultisigAddSigner = *_MessageParamsMultisigAddSigner__Maybe

+ func (m MaybeMessageParamsMultisigAddSigner) AsNode() ipld.Node

+ func (m MaybeMessageParamsMultisigAddSigner) Exists() bool

+ func (m MaybeMessageParamsMultisigAddSigner) IsAbsent() bool

+ func (m MaybeMessageParamsMultisigAddSigner) IsNull() bool

+ func (m MaybeMessageParamsMultisigAddSigner) Must() MessageParamsMultisigAddSigner

+ type MaybeMessageParamsMultisigChangeThreshold = *_MessageParamsMultisigChangeThreshold__Maybe

+ func (m MaybeMessageParamsMultisigChangeThreshold) AsNode() ipld.Node

+ func (m MaybeMessageParamsMultisigChangeThreshold) Exists() bool

+ func (m MaybeMessageParamsMultisigChangeThreshold) IsAbsent() bool

+ func (m MaybeMessageParamsMultisigChangeThreshold) IsNull() bool

+ func (m MaybeMessageParamsMultisigChangeThreshold) Must() MessageParamsMultisigChangeThreshold

+ type MaybeMessageParamsMultisigConstructor = *_MessageParamsMultisigConstructor__Maybe

+ func (m MaybeMessageParamsMultisigConstructor) AsNode() ipld.Node

+ func (m MaybeMessageParamsMultisigConstructor) Exists() bool

+ func (m MaybeMessageParamsMultisigConstructor) IsAbsent() bool

+ func (m MaybeMessageParamsMultisigConstructor) IsNull() bool

+ func (m MaybeMessageParamsMultisigConstructor) Must() MessageParamsMultisigConstructor

+ type MaybeMessageParamsMultisigLockBalance = *_MessageParamsMultisigLockBalance__Maybe

+ func (m MaybeMessageParamsMultisigLockBalance) AsNode() ipld.Node

+ func (m MaybeMessageParamsMultisigLockBalance) Exists() bool

+ func (m MaybeMessageParamsMultisigLockBalance) IsAbsent() bool

+ func (m MaybeMessageParamsMultisigLockBalance) IsNull() bool

+ func (m MaybeMessageParamsMultisigLockBalance) Must() MessageParamsMultisigLockBalance

+ type MaybeMessageParamsMultisigPropose = *_MessageParamsMultisigPropose__Maybe

+ func (m MaybeMessageParamsMultisigPropose) AsNode() ipld.Node

+ func (m MaybeMessageParamsMultisigPropose) Exists() bool

+ func (m MaybeMessageParamsMultisigPropose) IsAbsent() bool

+ func (m MaybeMessageParamsMultisigPropose) IsNull() bool

+ func (m MaybeMessageParamsMultisigPropose) Must() MessageParamsMultisigPropose

+ type MaybeMessageParamsMultisigRemoveSigner = *_MessageParamsMultisigRemoveSigner__Maybe

+ func (m MaybeMessageParamsMultisigRemoveSigner) AsNode() ipld.Node

+ func (m MaybeMessageParamsMultisigRemoveSigner) Exists() bool

+ func (m MaybeMessageParamsMultisigRemoveSigner) IsAbsent() bool

+ func (m MaybeMessageParamsMultisigRemoveSigner) IsNull() bool

+ func (m MaybeMessageParamsMultisigRemoveSigner) Must() MessageParamsMultisigRemoveSigner

+ type MaybeMessageParamsMultisigSwapSigner = *_MessageParamsMultisigSwapSigner__Maybe

+ func (m MaybeMessageParamsMultisigSwapSigner) AsNode() ipld.Node

+ func (m MaybeMessageParamsMultisigSwapSigner) Exists() bool

+ func (m MaybeMessageParamsMultisigSwapSigner) IsAbsent() bool

+ func (m MaybeMessageParamsMultisigSwapSigner) IsNull() bool

+ func (m MaybeMessageParamsMultisigSwapSigner) Must() MessageParamsMultisigSwapSigner

+ type MaybeMessageParamsMultisigTxnID = *_MessageParamsMultisigTxnID__Maybe

+ func (m MaybeMessageParamsMultisigTxnID) AsNode() ipld.Node

+ func (m MaybeMessageParamsMultisigTxnID) Exists() bool

+ func (m MaybeMessageParamsMultisigTxnID) IsAbsent() bool

+ func (m MaybeMessageParamsMultisigTxnID) IsNull() bool

+ func (m MaybeMessageParamsMultisigTxnID) Must() MessageParamsMultisigTxnID

+ type MaybeMessageParamsPaychConstructor = *_MessageParamsPaychConstructor__Maybe

+ func (m MaybeMessageParamsPaychConstructor) AsNode() ipld.Node

+ func (m MaybeMessageParamsPaychConstructor) Exists() bool

+ func (m MaybeMessageParamsPaychConstructor) IsAbsent() bool

+ func (m MaybeMessageParamsPaychConstructor) IsNull() bool

+ func (m MaybeMessageParamsPaychConstructor) Must() MessageParamsPaychConstructor

+ type MaybeMessageParamsPaychUpdateChannelState = *_MessageParamsPaychUpdateChannelState__Maybe

+ func (m MaybeMessageParamsPaychUpdateChannelState) AsNode() ipld.Node

+ func (m MaybeMessageParamsPaychUpdateChannelState) Exists() bool

+ func (m MaybeMessageParamsPaychUpdateChannelState) IsAbsent() bool

+ func (m MaybeMessageParamsPaychUpdateChannelState) IsNull() bool

+ func (m MaybeMessageParamsPaychUpdateChannelState) Must() MessageParamsPaychUpdateChannelState

+ type MaybeMessageParamsPowerCreateMiner = *_MessageParamsPowerCreateMiner__Maybe

+ func (m MaybeMessageParamsPowerCreateMiner) AsNode() ipld.Node

+ func (m MaybeMessageParamsPowerCreateMiner) Exists() bool

+ func (m MaybeMessageParamsPowerCreateMiner) IsAbsent() bool

+ func (m MaybeMessageParamsPowerCreateMiner) IsNull() bool

+ func (m MaybeMessageParamsPowerCreateMiner) Must() MessageParamsPowerCreateMiner

+ type MaybeMessageParamsPowerCurrentTotal = *_MessageParamsPowerCurrentTotal__Maybe

+ func (m MaybeMessageParamsPowerCurrentTotal) AsNode() ipld.Node

+ func (m MaybeMessageParamsPowerCurrentTotal) Exists() bool

+ func (m MaybeMessageParamsPowerCurrentTotal) IsAbsent() bool

+ func (m MaybeMessageParamsPowerCurrentTotal) IsNull() bool

+ func (m MaybeMessageParamsPowerCurrentTotal) Must() MessageParamsPowerCurrentTotal

+ type MaybeMessageParamsPowerEnrollCron = *_MessageParamsPowerEnrollCron__Maybe

+ func (m MaybeMessageParamsPowerEnrollCron) AsNode() ipld.Node

+ func (m MaybeMessageParamsPowerEnrollCron) Exists() bool

+ func (m MaybeMessageParamsPowerEnrollCron) IsAbsent() bool

+ func (m MaybeMessageParamsPowerEnrollCron) IsNull() bool

+ func (m MaybeMessageParamsPowerEnrollCron) Must() MessageParamsPowerEnrollCron

+ type MaybeMessageParamsPowerUpdateClaimed = *_MessageParamsPowerUpdateClaimed__Maybe

+ func (m MaybeMessageParamsPowerUpdateClaimed) AsNode() ipld.Node

+ func (m MaybeMessageParamsPowerUpdateClaimed) Exists() bool

+ func (m MaybeMessageParamsPowerUpdateClaimed) IsAbsent() bool

+ func (m MaybeMessageParamsPowerUpdateClaimed) IsNull() bool

+ func (m MaybeMessageParamsPowerUpdateClaimed) Must() MessageParamsPowerUpdateClaimed

+ type MaybeMessageParamsRewardAwardBlock = *_MessageParamsRewardAwardBlock__Maybe

+ func (m MaybeMessageParamsRewardAwardBlock) AsNode() ipld.Node

+ func (m MaybeMessageParamsRewardAwardBlock) Exists() bool

+ func (m MaybeMessageParamsRewardAwardBlock) IsAbsent() bool

+ func (m MaybeMessageParamsRewardAwardBlock) IsNull() bool

+ func (m MaybeMessageParamsRewardAwardBlock) Must() MessageParamsRewardAwardBlock

+ type MaybeMessageParamsVerifregAddVerifier = *_MessageParamsVerifregAddVerifier__Maybe

+ func (m MaybeMessageParamsVerifregAddVerifier) AsNode() ipld.Node

+ func (m MaybeMessageParamsVerifregAddVerifier) Exists() bool

+ func (m MaybeMessageParamsVerifregAddVerifier) IsAbsent() bool

+ func (m MaybeMessageParamsVerifregAddVerifier) IsNull() bool

+ func (m MaybeMessageParamsVerifregAddVerifier) Must() MessageParamsVerifregAddVerifier

+ type MaybeMessageParamsVerifregUseBytes = *_MessageParamsVerifregUseBytes__Maybe

+ func (m MaybeMessageParamsVerifregUseBytes) AsNode() ipld.Node

+ func (m MaybeMessageParamsVerifregUseBytes) Exists() bool

+ func (m MaybeMessageParamsVerifregUseBytes) IsAbsent() bool

+ func (m MaybeMessageParamsVerifregUseBytes) IsNull() bool

+ func (m MaybeMessageParamsVerifregUseBytes) Must() MessageParamsVerifregUseBytes

+ type MaybeMethodNum = *_MethodNum__Maybe

+ func (m MaybeMethodNum) AsNode() ipld.Node

+ func (m MaybeMethodNum) Exists() bool

+ func (m MaybeMethodNum) IsAbsent() bool

+ func (m MaybeMethodNum) IsNull() bool

+ func (m MaybeMethodNum) Must() MethodNum

+ type MaybeMinerExpirationExtend = *_MinerExpirationExtend__Maybe

+ func (m MaybeMinerExpirationExtend) AsNode() ipld.Node

+ func (m MaybeMinerExpirationExtend) Exists() bool

+ func (m MaybeMinerExpirationExtend) IsAbsent() bool

+ func (m MaybeMinerExpirationExtend) IsNull() bool

+ func (m MaybeMinerExpirationExtend) Must() MinerExpirationExtend

+ type MaybeMinerPostPartition = *_MinerPostPartition__Maybe

+ func (m MaybeMinerPostPartition) AsNode() ipld.Node

+ func (m MaybeMinerPostPartition) Exists() bool

+ func (m MaybeMinerPostPartition) IsAbsent() bool

+ func (m MaybeMinerPostPartition) IsNull() bool

+ func (m MaybeMinerPostPartition) Must() MinerPostPartition

+ type MaybeMinerPostProof = *_MinerPostProof__Maybe

+ func (m MaybeMinerPostProof) AsNode() ipld.Node

+ func (m MaybeMinerPostProof) Exists() bool

+ func (m MaybeMinerPostProof) IsAbsent() bool

+ func (m MaybeMinerPostProof) IsNull() bool

+ func (m MaybeMinerPostProof) Must() MinerPostProof

+ type MaybeMinerTerminationDecl = *_MinerTerminationDecl__Maybe

+ func (m MaybeMinerTerminationDecl) AsNode() ipld.Node

+ func (m MaybeMinerTerminationDecl) Exists() bool

+ func (m MaybeMinerTerminationDecl) IsAbsent() bool

+ func (m MaybeMinerTerminationDecl) IsNull() bool

+ func (m MaybeMinerTerminationDecl) Must() MinerTerminationDecl

+ type MaybeMinerV0Deadline = *_MinerV0Deadline__Maybe

+ func (m MaybeMinerV0Deadline) AsNode() ipld.Node

+ func (m MaybeMinerV0Deadline) Exists() bool

+ func (m MaybeMinerV0Deadline) IsAbsent() bool

+ func (m MaybeMinerV0Deadline) IsNull() bool

+ func (m MaybeMinerV0Deadline) Must() MinerV0Deadline

+ type MaybeMinerV0Deadlines = *_MinerV0Deadlines__Maybe

+ func (m MaybeMinerV0Deadlines) AsNode() ipld.Node

+ func (m MaybeMinerV0Deadlines) Exists() bool

+ func (m MaybeMinerV0Deadlines) IsAbsent() bool

+ func (m MaybeMinerV0Deadlines) IsNull() bool

+ func (m MaybeMinerV0Deadlines) Must() MinerV0Deadlines

+ type MaybeMinerV0ExpirationSet = *_MinerV0ExpirationSet__Maybe

+ func (m MaybeMinerV0ExpirationSet) AsNode() ipld.Node

+ func (m MaybeMinerV0ExpirationSet) Exists() bool

+ func (m MaybeMinerV0ExpirationSet) IsAbsent() bool

+ func (m MaybeMinerV0ExpirationSet) IsNull() bool

+ func (m MaybeMinerV0ExpirationSet) Must() MinerV0ExpirationSet

+ type MaybeMinerV0Info = *_MinerV0Info__Maybe

+ func (m MaybeMinerV0Info) AsNode() ipld.Node

+ func (m MaybeMinerV0Info) Exists() bool

+ func (m MaybeMinerV0Info) IsAbsent() bool

+ func (m MaybeMinerV0Info) IsNull() bool

+ func (m MaybeMinerV0Info) Must() MinerV0Info

+ type MaybeMinerV0Partition = *_MinerV0Partition__Maybe

+ func (m MaybeMinerV0Partition) AsNode() ipld.Node

+ func (m MaybeMinerV0Partition) Exists() bool

+ func (m MaybeMinerV0Partition) IsAbsent() bool

+ func (m MaybeMinerV0Partition) IsNull() bool

+ func (m MaybeMinerV0Partition) Must() MinerV0Partition

+ type MaybeMinerV0PowerPair = *_MinerV0PowerPair__Maybe

+ func (m MaybeMinerV0PowerPair) AsNode() ipld.Node

+ func (m MaybeMinerV0PowerPair) Exists() bool

+ func (m MaybeMinerV0PowerPair) IsAbsent() bool

+ func (m MaybeMinerV0PowerPair) IsNull() bool

+ func (m MaybeMinerV0PowerPair) Must() MinerV0PowerPair

+ type MaybeMinerV0SectorOnChainInfo = *_MinerV0SectorOnChainInfo__Maybe

+ func (m MaybeMinerV0SectorOnChainInfo) AsNode() ipld.Node

+ func (m MaybeMinerV0SectorOnChainInfo) Exists() bool

+ func (m MaybeMinerV0SectorOnChainInfo) IsAbsent() bool

+ func (m MaybeMinerV0SectorOnChainInfo) IsNull() bool

+ func (m MaybeMinerV0SectorOnChainInfo) Must() MinerV0SectorOnChainInfo

+ type MaybeMinerV0SectorPreCommitInfo = *_MinerV0SectorPreCommitInfo__Maybe

+ func (m MaybeMinerV0SectorPreCommitInfo) AsNode() ipld.Node

+ func (m MaybeMinerV0SectorPreCommitInfo) Exists() bool

+ func (m MaybeMinerV0SectorPreCommitInfo) IsAbsent() bool

+ func (m MaybeMinerV0SectorPreCommitInfo) IsNull() bool

+ func (m MaybeMinerV0SectorPreCommitInfo) Must() MinerV0SectorPreCommitInfo

+ type MaybeMinerV0SectorPreCommitOnChainInfo = *_MinerV0SectorPreCommitOnChainInfo__Maybe

+ func (m MaybeMinerV0SectorPreCommitOnChainInfo) AsNode() ipld.Node

+ func (m MaybeMinerV0SectorPreCommitOnChainInfo) Exists() bool

+ func (m MaybeMinerV0SectorPreCommitOnChainInfo) IsAbsent() bool

+ func (m MaybeMinerV0SectorPreCommitOnChainInfo) IsNull() bool

+ func (m MaybeMinerV0SectorPreCommitOnChainInfo) Must() MinerV0SectorPreCommitOnChainInfo

+ type MaybeMinerV0State = *_MinerV0State__Maybe

+ func (m MaybeMinerV0State) AsNode() ipld.Node

+ func (m MaybeMinerV0State) Exists() bool

+ func (m MaybeMinerV0State) IsAbsent() bool

+ func (m MaybeMinerV0State) IsNull() bool

+ func (m MaybeMinerV0State) Must() MinerV0State

+ type MaybeMinerV0VestingFund = *_MinerV0VestingFund__Maybe

+ func (m MaybeMinerV0VestingFund) AsNode() ipld.Node

+ func (m MaybeMinerV0VestingFund) Exists() bool

+ func (m MaybeMinerV0VestingFund) IsAbsent() bool

+ func (m MaybeMinerV0VestingFund) IsNull() bool

+ func (m MaybeMinerV0VestingFund) Must() MinerV0VestingFund

+ type MaybeMinerV0VestingFunds = *_MinerV0VestingFunds__Maybe

+ func (m MaybeMinerV0VestingFunds) AsNode() ipld.Node

+ func (m MaybeMinerV0VestingFunds) Exists() bool

+ func (m MaybeMinerV0VestingFunds) IsAbsent() bool

+ func (m MaybeMinerV0VestingFunds) IsNull() bool

+ func (m MaybeMinerV0VestingFunds) Must() MinerV0VestingFunds

+ type MaybeMinerV0WorkerChangeKey = *_MinerV0WorkerChangeKey__Maybe

+ func (m MaybeMinerV0WorkerChangeKey) AsNode() ipld.Node

+ func (m MaybeMinerV0WorkerChangeKey) Exists() bool

+ func (m MaybeMinerV0WorkerChangeKey) IsAbsent() bool

+ func (m MaybeMinerV0WorkerChangeKey) IsNull() bool

+ func (m MaybeMinerV0WorkerChangeKey) Must() MinerV0WorkerChangeKey

+ type MaybeMinerV2Deadline = *_MinerV2Deadline__Maybe

+ func (m MaybeMinerV2Deadline) AsNode() ipld.Node

+ func (m MaybeMinerV2Deadline) Exists() bool

+ func (m MaybeMinerV2Deadline) IsAbsent() bool

+ func (m MaybeMinerV2Deadline) IsNull() bool

+ func (m MaybeMinerV2Deadline) Must() MinerV2Deadline

+ type MaybeMinerV2Deadlines = *_MinerV2Deadlines__Maybe

+ func (m MaybeMinerV2Deadlines) AsNode() ipld.Node

+ func (m MaybeMinerV2Deadlines) Exists() bool

+ func (m MaybeMinerV2Deadlines) IsAbsent() bool

+ func (m MaybeMinerV2Deadlines) IsNull() bool

+ func (m MaybeMinerV2Deadlines) Must() MinerV2Deadlines

+ type MaybeMinerV2Info = *_MinerV2Info__Maybe

+ func (m MaybeMinerV2Info) AsNode() ipld.Node

+ func (m MaybeMinerV2Info) Exists() bool

+ func (m MaybeMinerV2Info) IsAbsent() bool

+ func (m MaybeMinerV2Info) IsNull() bool

+ func (m MaybeMinerV2Info) Must() MinerV2Info

+ type MaybeMinerV2Partition = *_MinerV2Partition__Maybe

+ func (m MaybeMinerV2Partition) AsNode() ipld.Node

+ func (m MaybeMinerV2Partition) Exists() bool

+ func (m MaybeMinerV2Partition) IsAbsent() bool

+ func (m MaybeMinerV2Partition) IsNull() bool

+ func (m MaybeMinerV2Partition) Must() MinerV2Partition

+ type MaybeMinerV2SectorOnChainInfo = *_MinerV2SectorOnChainInfo__Maybe

+ func (m MaybeMinerV2SectorOnChainInfo) AsNode() ipld.Node

+ func (m MaybeMinerV2SectorOnChainInfo) Exists() bool

+ func (m MaybeMinerV2SectorOnChainInfo) IsAbsent() bool

+ func (m MaybeMinerV2SectorOnChainInfo) IsNull() bool

+ func (m MaybeMinerV2SectorOnChainInfo) Must() MinerV2SectorOnChainInfo

+ type MaybeMinerV2State = *_MinerV2State__Maybe

+ func (m MaybeMinerV2State) AsNode() ipld.Node

+ func (m MaybeMinerV2State) Exists() bool

+ func (m MaybeMinerV2State) IsAbsent() bool

+ func (m MaybeMinerV2State) IsNull() bool

+ func (m MaybeMinerV2State) Must() MinerV2State

+ type MaybeMinerV3Deadline = *_MinerV3Deadline__Maybe

+ func (m MaybeMinerV3Deadline) AsNode() ipld.Node

+ func (m MaybeMinerV3Deadline) Exists() bool

+ func (m MaybeMinerV3Deadline) IsAbsent() bool

+ func (m MaybeMinerV3Deadline) IsNull() bool

+ func (m MaybeMinerV3Deadline) Must() MinerV3Deadline

+ type MaybeMinerV3Deadlines = *_MinerV3Deadlines__Maybe

+ func (m MaybeMinerV3Deadlines) AsNode() ipld.Node

+ func (m MaybeMinerV3Deadlines) Exists() bool

+ func (m MaybeMinerV3Deadlines) IsAbsent() bool

+ func (m MaybeMinerV3Deadlines) IsNull() bool

+ func (m MaybeMinerV3Deadlines) Must() MinerV3Deadlines

+ type MaybeMinerV3Partition = *_MinerV3Partition__Maybe

+ func (m MaybeMinerV3Partition) AsNode() ipld.Node

+ func (m MaybeMinerV3Partition) Exists() bool

+ func (m MaybeMinerV3Partition) IsAbsent() bool

+ func (m MaybeMinerV3Partition) IsNull() bool

+ func (m MaybeMinerV3Partition) Must() MinerV3Partition

+ type MaybeMinerV3State = *_MinerV3State__Maybe

+ func (m MaybeMinerV3State) AsNode() ipld.Node

+ func (m MaybeMinerV3State) Exists() bool

+ func (m MaybeMinerV3State) IsAbsent() bool

+ func (m MaybeMinerV3State) IsNull() bool

+ func (m MaybeMinerV3State) Must() MinerV3State

+ type MaybeMinerV4State = *_MinerV4State__Maybe

+ func (m MaybeMinerV4State) AsNode() ipld.Node

+ func (m MaybeMinerV4State) Exists() bool

+ func (m MaybeMinerV4State) IsAbsent() bool

+ func (m MaybeMinerV4State) IsNull() bool

+ func (m MaybeMinerV4State) Must() MinerV4State

+ type MaybeMinerV5State = *_MinerV5State__Maybe

+ func (m MaybeMinerV5State) AsNode() ipld.Node

+ func (m MaybeMinerV5State) Exists() bool

+ func (m MaybeMinerV5State) IsAbsent() bool

+ func (m MaybeMinerV5State) IsNull() bool

+ func (m MaybeMinerV5State) Must() MinerV5State

+ type MaybeModVerifyParams = *_ModVerifyParams__Maybe

+ func (m MaybeModVerifyParams) AsNode() ipld.Node

+ func (m MaybeModVerifyParams) Exists() bool

+ func (m MaybeModVerifyParams) IsAbsent() bool

+ func (m MaybeModVerifyParams) IsNull() bool

+ func (m MaybeModVerifyParams) Must() ModVerifyParams

+ type MaybeMultiaddr = *_Multiaddr__Maybe

+ func (m MaybeMultiaddr) AsNode() ipld.Node

+ func (m MaybeMultiaddr) Exists() bool

+ func (m MaybeMultiaddr) IsAbsent() bool

+ func (m MaybeMultiaddr) IsNull() bool

+ func (m MaybeMultiaddr) Must() Multiaddr

+ type MaybeMultimap__PowerV0CronEvent = *_Multimap__PowerV0CronEvent__Maybe

+ func (m MaybeMultimap__PowerV0CronEvent) AsNode() ipld.Node

+ func (m MaybeMultimap__PowerV0CronEvent) Exists() bool

+ func (m MaybeMultimap__PowerV0CronEvent) IsAbsent() bool

+ func (m MaybeMultimap__PowerV0CronEvent) IsNull() bool

+ func (m MaybeMultimap__PowerV0CronEvent) Must() Multimap__PowerV0CronEvent

+ type MaybeMultimap__PowerV3CronEvent = *_Multimap__PowerV3CronEvent__Maybe

+ func (m MaybeMultimap__PowerV3CronEvent) AsNode() ipld.Node

+ func (m MaybeMultimap__PowerV3CronEvent) Exists() bool

+ func (m MaybeMultimap__PowerV3CronEvent) IsAbsent() bool

+ func (m MaybeMultimap__PowerV3CronEvent) IsNull() bool

+ func (m MaybeMultimap__PowerV3CronEvent) Must() Multimap__PowerV3CronEvent

+ type MaybeMultisigV0State = *_MultisigV0State__Maybe

+ func (m MaybeMultisigV0State) AsNode() ipld.Node

+ func (m MaybeMultisigV0State) Exists() bool

+ func (m MaybeMultisigV0State) IsAbsent() bool

+ func (m MaybeMultisigV0State) IsNull() bool

+ func (m MaybeMultisigV0State) Must() MultisigV0State

+ type MaybeMultisigV0Transaction = *_MultisigV0Transaction__Maybe

+ func (m MaybeMultisigV0Transaction) AsNode() ipld.Node

+ func (m MaybeMultisigV0Transaction) Exists() bool

+ func (m MaybeMultisigV0Transaction) IsAbsent() bool

+ func (m MaybeMultisigV0Transaction) IsNull() bool

+ func (m MaybeMultisigV0Transaction) Must() MultisigV0Transaction

+ type MaybeMultisigV3State = *_MultisigV3State__Maybe

+ func (m MaybeMultisigV3State) AsNode() ipld.Node

+ func (m MaybeMultisigV3State) Exists() bool

+ func (m MaybeMultisigV3State) IsAbsent() bool

+ func (m MaybeMultisigV3State) IsNull() bool

+ func (m MaybeMultisigV3State) Must() MultisigV3State

+ type MaybePaddedPieceSize = *_PaddedPieceSize__Maybe

+ func (m MaybePaddedPieceSize) AsNode() ipld.Node

+ func (m MaybePaddedPieceSize) Exists() bool

+ func (m MaybePaddedPieceSize) IsAbsent() bool

+ func (m MaybePaddedPieceSize) IsNull() bool

+ func (m MaybePaddedPieceSize) Must() PaddedPieceSize

+ type MaybePaychV0LaneState = *_PaychV0LaneState__Maybe

+ func (m MaybePaychV0LaneState) AsNode() ipld.Node

+ func (m MaybePaychV0LaneState) Exists() bool

+ func (m MaybePaychV0LaneState) IsAbsent() bool

+ func (m MaybePaychV0LaneState) IsNull() bool

+ func (m MaybePaychV0LaneState) Must() PaychV0LaneState

+ type MaybePaychV0State = *_PaychV0State__Maybe

+ func (m MaybePaychV0State) AsNode() ipld.Node

+ func (m MaybePaychV0State) Exists() bool

+ func (m MaybePaychV0State) IsAbsent() bool

+ func (m MaybePaychV0State) IsNull() bool

+ func (m MaybePaychV0State) Must() PaychV0State

+ type MaybePaychV3State = *_PaychV3State__Maybe

+ func (m MaybePaychV3State) AsNode() ipld.Node

+ func (m MaybePaychV3State) Exists() bool

+ func (m MaybePaychV3State) IsAbsent() bool

+ func (m MaybePaychV3State) IsNull() bool

+ func (m MaybePaychV3State) Must() PaychV3State

+ type MaybePeerID = *_PeerID__Maybe

+ func (m MaybePeerID) AsNode() ipld.Node

+ func (m MaybePeerID) Exists() bool

+ func (m MaybePeerID) IsAbsent() bool

+ func (m MaybePeerID) IsNull() bool

+ func (m MaybePeerID) Must() PeerID

+ type MaybePoStProof = *_PoStProof__Maybe

+ func (m MaybePoStProof) AsNode() ipld.Node

+ func (m MaybePoStProof) Exists() bool

+ func (m MaybePoStProof) IsAbsent() bool

+ func (m MaybePoStProof) IsNull() bool

+ func (m MaybePoStProof) Must() PoStProof

+ type MaybePowerV0Claim = *_PowerV0Claim__Maybe

+ func (m MaybePowerV0Claim) AsNode() ipld.Node

+ func (m MaybePowerV0Claim) Exists() bool

+ func (m MaybePowerV0Claim) IsAbsent() bool

+ func (m MaybePowerV0Claim) IsNull() bool

+ func (m MaybePowerV0Claim) Must() PowerV0Claim

+ type MaybePowerV0CronEvent = *_PowerV0CronEvent__Maybe

+ func (m MaybePowerV0CronEvent) AsNode() ipld.Node

+ func (m MaybePowerV0CronEvent) Exists() bool

+ func (m MaybePowerV0CronEvent) IsAbsent() bool

+ func (m MaybePowerV0CronEvent) IsNull() bool

+ func (m MaybePowerV0CronEvent) Must() PowerV0CronEvent

+ type MaybePowerV0State = *_PowerV0State__Maybe

+ func (m MaybePowerV0State) AsNode() ipld.Node

+ func (m MaybePowerV0State) Exists() bool

+ func (m MaybePowerV0State) IsAbsent() bool

+ func (m MaybePowerV0State) IsNull() bool

+ func (m MaybePowerV0State) Must() PowerV0State

+ type MaybePowerV2Claim = *_PowerV2Claim__Maybe

+ func (m MaybePowerV2Claim) AsNode() ipld.Node

+ func (m MaybePowerV2Claim) Exists() bool

+ func (m MaybePowerV2Claim) IsAbsent() bool

+ func (m MaybePowerV2Claim) IsNull() bool

+ func (m MaybePowerV2Claim) Must() PowerV2Claim

+ type MaybePowerV2State = *_PowerV2State__Maybe

+ func (m MaybePowerV2State) AsNode() ipld.Node

+ func (m MaybePowerV2State) Exists() bool

+ func (m MaybePowerV2State) IsAbsent() bool

+ func (m MaybePowerV2State) IsNull() bool

+ func (m MaybePowerV2State) Must() PowerV2State

+ type MaybePowerV3State = *_PowerV3State__Maybe

+ func (m MaybePowerV3State) AsNode() ipld.Node

+ func (m MaybePowerV3State) Exists() bool

+ func (m MaybePowerV3State) IsAbsent() bool

+ func (m MaybePowerV3State) IsNull() bool

+ func (m MaybePowerV3State) Must() PowerV3State

+ type MaybeRawAddress = *_RawAddress__Maybe

+ func (m MaybeRawAddress) AsNode() ipld.Node

+ func (m MaybeRawAddress) Exists() bool

+ func (m MaybeRawAddress) IsAbsent() bool

+ func (m MaybeRawAddress) IsNull() bool

+ func (m MaybeRawAddress) Must() RawAddress

+ type MaybeRegisteredSealProof = *_RegisteredSealProof__Maybe

+ func (m MaybeRegisteredSealProof) AsNode() ipld.Node

+ func (m MaybeRegisteredSealProof) Exists() bool

+ func (m MaybeRegisteredSealProof) IsAbsent() bool

+ func (m MaybeRegisteredSealProof) IsNull() bool

+ func (m MaybeRegisteredSealProof) Must() RegisteredSealProof

+ type MaybeRewardV0State = *_RewardV0State__Maybe

+ func (m MaybeRewardV0State) AsNode() ipld.Node

+ func (m MaybeRewardV0State) Exists() bool

+ func (m MaybeRewardV0State) IsAbsent() bool

+ func (m MaybeRewardV0State) IsNull() bool

+ func (m MaybeRewardV0State) Must() RewardV0State

+ type MaybeRewardV2State = *_RewardV2State__Maybe

+ func (m MaybeRewardV2State) AsNode() ipld.Node

+ func (m MaybeRewardV2State) Exists() bool

+ func (m MaybeRewardV2State) IsAbsent() bool

+ func (m MaybeRewardV2State) IsNull() bool

+ func (m MaybeRewardV2State) Must() RewardV2State

+ type MaybeSealVerifyInfo = *_SealVerifyInfo__Maybe

+ func (m MaybeSealVerifyInfo) AsNode() ipld.Node

+ func (m MaybeSealVerifyInfo) Exists() bool

+ func (m MaybeSealVerifyInfo) IsAbsent() bool

+ func (m MaybeSealVerifyInfo) IsNull() bool

+ func (m MaybeSealVerifyInfo) Must() SealVerifyInfo

+ type MaybeSectorDataSpec = *_SectorDataSpec__Maybe

+ func (m MaybeSectorDataSpec) AsNode() ipld.Node

+ func (m MaybeSectorDataSpec) Exists() bool

+ func (m MaybeSectorDataSpec) IsAbsent() bool

+ func (m MaybeSectorDataSpec) IsNull() bool

+ func (m MaybeSectorDataSpec) Must() SectorDataSpec

+ type MaybeSectorNumber = *_SectorNumber__Maybe

+ func (m MaybeSectorNumber) AsNode() ipld.Node

+ func (m MaybeSectorNumber) Exists() bool

+ func (m MaybeSectorNumber) IsAbsent() bool

+ func (m MaybeSectorNumber) IsNull() bool

+ func (m MaybeSectorNumber) Must() SectorNumber

+ type MaybeSectorSize = *_SectorSize__Maybe

+ func (m MaybeSectorSize) AsNode() ipld.Node

+ func (m MaybeSectorSize) Exists() bool

+ func (m MaybeSectorSize) IsAbsent() bool

+ func (m MaybeSectorSize) IsNull() bool

+ func (m MaybeSectorSize) Must() SectorSize

+ type MaybeSignature = *_Signature__Maybe

+ func (m MaybeSignature) AsNode() ipld.Node

+ func (m MaybeSignature) Exists() bool

+ func (m MaybeSignature) IsAbsent() bool

+ func (m MaybeSignature) IsNull() bool

+ func (m MaybeSignature) Must() Signature

+ type MaybeSignedVoucher = *_SignedVoucher__Maybe

+ func (m MaybeSignedVoucher) AsNode() ipld.Node

+ func (m MaybeSignedVoucher) Exists() bool

+ func (m MaybeSignedVoucher) IsAbsent() bool

+ func (m MaybeSignedVoucher) IsNull() bool

+ func (m MaybeSignedVoucher) Must() SignedVoucher

+ type MaybeString = *_String__Maybe

+ func (m MaybeString) AsNode() ipld.Node

+ func (m MaybeString) Exists() bool

+ func (m MaybeString) IsAbsent() bool

+ func (m MaybeString) IsNull() bool

+ func (m MaybeString) Must() String

+ type MaybeUnpaddedPieceSize = *_UnpaddedPieceSize__Maybe

+ func (m MaybeUnpaddedPieceSize) AsNode() ipld.Node

+ func (m MaybeUnpaddedPieceSize) Exists() bool

+ func (m MaybeUnpaddedPieceSize) IsAbsent() bool

+ func (m MaybeUnpaddedPieceSize) IsNull() bool

+ func (m MaybeUnpaddedPieceSize) Must() UnpaddedPieceSize

+ type MaybeV0FilterEstimate = *_V0FilterEstimate__Maybe

+ func (m MaybeV0FilterEstimate) AsNode() ipld.Node

+ func (m MaybeV0FilterEstimate) Exists() bool

+ func (m MaybeV0FilterEstimate) IsAbsent() bool

+ func (m MaybeV0FilterEstimate) IsNull() bool

+ func (m MaybeV0FilterEstimate) Must() V0FilterEstimate

+ type MaybeVerifregV0State = *_VerifregV0State__Maybe

+ func (m MaybeVerifregV0State) AsNode() ipld.Node

+ func (m MaybeVerifregV0State) Exists() bool

+ func (m MaybeVerifregV0State) IsAbsent() bool

+ func (m MaybeVerifregV0State) IsNull() bool

+ func (m MaybeVerifregV0State) Must() VerifregV0State

+ type MaybeVerifregV3State = *_VerifregV3State__Maybe

+ func (m MaybeVerifregV3State) AsNode() ipld.Node

+ func (m MaybeVerifregV3State) Exists() bool

+ func (m MaybeVerifregV3State) IsAbsent() bool

+ func (m MaybeVerifregV3State) IsNull() bool

+ func (m MaybeVerifregV3State) Must() VerifregV3State

+ type Merge = *_Merge

+ func (Merge) AsBool() (bool, error)

+ func (Merge) AsBytes() ([]byte, error)

+ func (Merge) AsFloat() (float64, error)

+ func (Merge) AsInt() (int64, error)

+ func (Merge) AsLink() (ipld.Link, error)

+ func (Merge) AsString() (string, error)

+ func (Merge) IsAbsent() bool

+ func (Merge) IsNull() bool

+ func (Merge) Kind() ipld.Kind

+ func (Merge) Length() int64

+ func (Merge) ListIterator() ipld.ListIterator

+ func (Merge) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Merge) Prototype() ipld.NodePrototype

+ func (Merge) Type() schema.Type

+ func (n Merge) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n Merge) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Merge) LookupByString(key string) (ipld.Node, error)

+ func (n Merge) MapIterator() ipld.MapIterator

+ func (n Merge) Representation() ipld.Node

+ type MessageParamsInitExecParams = *_MessageParamsInitExecParams

+ func (MessageParamsInitExecParams) AsBool() (bool, error)

+ func (MessageParamsInitExecParams) AsBytes() ([]byte, error)

+ func (MessageParamsInitExecParams) AsFloat() (float64, error)

+ func (MessageParamsInitExecParams) AsInt() (int64, error)

+ func (MessageParamsInitExecParams) AsLink() (ipld.Link, error)

+ func (MessageParamsInitExecParams) AsString() (string, error)

+ func (MessageParamsInitExecParams) IsAbsent() bool

+ func (MessageParamsInitExecParams) IsNull() bool

+ func (MessageParamsInitExecParams) Kind() ipld.Kind

+ func (MessageParamsInitExecParams) Length() int64

+ func (MessageParamsInitExecParams) ListIterator() ipld.ListIterator

+ func (MessageParamsInitExecParams) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsInitExecParams) Prototype() ipld.NodePrototype

+ func (MessageParamsInitExecParams) Type() schema.Type

+ func (n MessageParamsInitExecParams) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsInitExecParams) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsInitExecParams) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsInitExecParams) MapIterator() ipld.MapIterator

+ func (n MessageParamsInitExecParams) Representation() ipld.Node

+ type MessageParamsMarketActivateDeals = *_MessageParamsMarketActivateDeals

+ func (MessageParamsMarketActivateDeals) AsBool() (bool, error)

+ func (MessageParamsMarketActivateDeals) AsBytes() ([]byte, error)

+ func (MessageParamsMarketActivateDeals) AsFloat() (float64, error)

+ func (MessageParamsMarketActivateDeals) AsInt() (int64, error)

+ func (MessageParamsMarketActivateDeals) AsLink() (ipld.Link, error)

+ func (MessageParamsMarketActivateDeals) AsString() (string, error)

+ func (MessageParamsMarketActivateDeals) IsAbsent() bool

+ func (MessageParamsMarketActivateDeals) IsNull() bool

+ func (MessageParamsMarketActivateDeals) Kind() ipld.Kind

+ func (MessageParamsMarketActivateDeals) Length() int64

+ func (MessageParamsMarketActivateDeals) ListIterator() ipld.ListIterator

+ func (MessageParamsMarketActivateDeals) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMarketActivateDeals) Prototype() ipld.NodePrototype

+ func (MessageParamsMarketActivateDeals) Type() schema.Type

+ func (n MessageParamsMarketActivateDeals) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMarketActivateDeals) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMarketActivateDeals) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMarketActivateDeals) MapIterator() ipld.MapIterator

+ func (n MessageParamsMarketActivateDeals) Representation() ipld.Node

+ type MessageParamsMarketComputeCommitment = *_MessageParamsMarketComputeCommitment

+ func (MessageParamsMarketComputeCommitment) AsBool() (bool, error)

+ func (MessageParamsMarketComputeCommitment) AsBytes() ([]byte, error)

+ func (MessageParamsMarketComputeCommitment) AsFloat() (float64, error)

+ func (MessageParamsMarketComputeCommitment) AsInt() (int64, error)

+ func (MessageParamsMarketComputeCommitment) AsLink() (ipld.Link, error)

+ func (MessageParamsMarketComputeCommitment) AsString() (string, error)

+ func (MessageParamsMarketComputeCommitment) IsAbsent() bool

+ func (MessageParamsMarketComputeCommitment) IsNull() bool

+ func (MessageParamsMarketComputeCommitment) Kind() ipld.Kind

+ func (MessageParamsMarketComputeCommitment) Length() int64

+ func (MessageParamsMarketComputeCommitment) ListIterator() ipld.ListIterator

+ func (MessageParamsMarketComputeCommitment) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMarketComputeCommitment) Prototype() ipld.NodePrototype

+ func (MessageParamsMarketComputeCommitment) Type() schema.Type

+ func (n MessageParamsMarketComputeCommitment) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMarketComputeCommitment) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMarketComputeCommitment) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMarketComputeCommitment) MapIterator() ipld.MapIterator

+ func (n MessageParamsMarketComputeCommitment) Representation() ipld.Node

+ type MessageParamsMarketPublishDeals = *_MessageParamsMarketPublishDeals

+ func (MessageParamsMarketPublishDeals) AsBool() (bool, error)

+ func (MessageParamsMarketPublishDeals) AsBytes() ([]byte, error)

+ func (MessageParamsMarketPublishDeals) AsFloat() (float64, error)

+ func (MessageParamsMarketPublishDeals) AsInt() (int64, error)

+ func (MessageParamsMarketPublishDeals) AsLink() (ipld.Link, error)

+ func (MessageParamsMarketPublishDeals) AsString() (string, error)

+ func (MessageParamsMarketPublishDeals) IsAbsent() bool

+ func (MessageParamsMarketPublishDeals) IsNull() bool

+ func (MessageParamsMarketPublishDeals) Kind() ipld.Kind

+ func (MessageParamsMarketPublishDeals) Length() int64

+ func (MessageParamsMarketPublishDeals) ListIterator() ipld.ListIterator

+ func (MessageParamsMarketPublishDeals) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMarketPublishDeals) Prototype() ipld.NodePrototype

+ func (MessageParamsMarketPublishDeals) Type() schema.Type

+ func (n MessageParamsMarketPublishDeals) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMarketPublishDeals) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMarketPublishDeals) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMarketPublishDeals) MapIterator() ipld.MapIterator

+ func (n MessageParamsMarketPublishDeals) Representation() ipld.Node

+ type MessageParamsMarketTerminateDeals = *_MessageParamsMarketTerminateDeals

+ func (MessageParamsMarketTerminateDeals) AsBool() (bool, error)

+ func (MessageParamsMarketTerminateDeals) AsBytes() ([]byte, error)

+ func (MessageParamsMarketTerminateDeals) AsFloat() (float64, error)

+ func (MessageParamsMarketTerminateDeals) AsInt() (int64, error)

+ func (MessageParamsMarketTerminateDeals) AsLink() (ipld.Link, error)

+ func (MessageParamsMarketTerminateDeals) AsString() (string, error)

+ func (MessageParamsMarketTerminateDeals) IsAbsent() bool

+ func (MessageParamsMarketTerminateDeals) IsNull() bool

+ func (MessageParamsMarketTerminateDeals) Kind() ipld.Kind

+ func (MessageParamsMarketTerminateDeals) Length() int64

+ func (MessageParamsMarketTerminateDeals) ListIterator() ipld.ListIterator

+ func (MessageParamsMarketTerminateDeals) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMarketTerminateDeals) Prototype() ipld.NodePrototype

+ func (MessageParamsMarketTerminateDeals) Type() schema.Type

+ func (n MessageParamsMarketTerminateDeals) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMarketTerminateDeals) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMarketTerminateDeals) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMarketTerminateDeals) MapIterator() ipld.MapIterator

+ func (n MessageParamsMarketTerminateDeals) Representation() ipld.Node

+ type MessageParamsMarketV5ComputeCommitment = *_MessageParamsMarketV5ComputeCommitment

+ func (MessageParamsMarketV5ComputeCommitment) AsBool() (bool, error)

+ func (MessageParamsMarketV5ComputeCommitment) AsBytes() ([]byte, error)

+ func (MessageParamsMarketV5ComputeCommitment) AsFloat() (float64, error)

+ func (MessageParamsMarketV5ComputeCommitment) AsInt() (int64, error)

+ func (MessageParamsMarketV5ComputeCommitment) AsLink() (ipld.Link, error)

+ func (MessageParamsMarketV5ComputeCommitment) AsString() (string, error)

+ func (MessageParamsMarketV5ComputeCommitment) IsAbsent() bool

+ func (MessageParamsMarketV5ComputeCommitment) IsNull() bool

+ func (MessageParamsMarketV5ComputeCommitment) Kind() ipld.Kind

+ func (MessageParamsMarketV5ComputeCommitment) Length() int64

+ func (MessageParamsMarketV5ComputeCommitment) ListIterator() ipld.ListIterator

+ func (MessageParamsMarketV5ComputeCommitment) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMarketV5ComputeCommitment) Prototype() ipld.NodePrototype

+ func (MessageParamsMarketV5ComputeCommitment) Type() schema.Type

+ func (n MessageParamsMarketV5ComputeCommitment) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMarketV5ComputeCommitment) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMarketV5ComputeCommitment) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMarketV5ComputeCommitment) MapIterator() ipld.MapIterator

+ func (n MessageParamsMarketV5ComputeCommitment) Representation() ipld.Node

+ type MessageParamsMarketVerifyDeals = *_MessageParamsMarketVerifyDeals

+ func (MessageParamsMarketVerifyDeals) AsBool() (bool, error)

+ func (MessageParamsMarketVerifyDeals) AsBytes() ([]byte, error)

+ func (MessageParamsMarketVerifyDeals) AsFloat() (float64, error)

+ func (MessageParamsMarketVerifyDeals) AsInt() (int64, error)

+ func (MessageParamsMarketVerifyDeals) AsLink() (ipld.Link, error)

+ func (MessageParamsMarketVerifyDeals) AsString() (string, error)

+ func (MessageParamsMarketVerifyDeals) IsAbsent() bool

+ func (MessageParamsMarketVerifyDeals) IsNull() bool

+ func (MessageParamsMarketVerifyDeals) Kind() ipld.Kind

+ func (MessageParamsMarketVerifyDeals) Length() int64

+ func (MessageParamsMarketVerifyDeals) ListIterator() ipld.ListIterator

+ func (MessageParamsMarketVerifyDeals) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMarketVerifyDeals) Prototype() ipld.NodePrototype

+ func (MessageParamsMarketVerifyDeals) Type() schema.Type

+ func (n MessageParamsMarketVerifyDeals) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMarketVerifyDeals) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMarketVerifyDeals) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMarketVerifyDeals) MapIterator() ipld.MapIterator

+ func (n MessageParamsMarketVerifyDeals) Representation() ipld.Node

+ type MessageParamsMarketWithdrawBalance = *_MessageParamsMarketWithdrawBalance

+ func (MessageParamsMarketWithdrawBalance) AsBool() (bool, error)

+ func (MessageParamsMarketWithdrawBalance) AsBytes() ([]byte, error)

+ func (MessageParamsMarketWithdrawBalance) AsFloat() (float64, error)

+ func (MessageParamsMarketWithdrawBalance) AsInt() (int64, error)

+ func (MessageParamsMarketWithdrawBalance) AsLink() (ipld.Link, error)

+ func (MessageParamsMarketWithdrawBalance) AsString() (string, error)

+ func (MessageParamsMarketWithdrawBalance) IsAbsent() bool

+ func (MessageParamsMarketWithdrawBalance) IsNull() bool

+ func (MessageParamsMarketWithdrawBalance) Kind() ipld.Kind

+ func (MessageParamsMarketWithdrawBalance) Length() int64

+ func (MessageParamsMarketWithdrawBalance) ListIterator() ipld.ListIterator

+ func (MessageParamsMarketWithdrawBalance) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMarketWithdrawBalance) Prototype() ipld.NodePrototype

+ func (MessageParamsMarketWithdrawBalance) Type() schema.Type

+ func (n MessageParamsMarketWithdrawBalance) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMarketWithdrawBalance) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMarketWithdrawBalance) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMarketWithdrawBalance) MapIterator() ipld.MapIterator

+ func (n MessageParamsMarketWithdrawBalance) Representation() ipld.Node

+ type MessageParamsMinerChangeAddress = *_MessageParamsMinerChangeAddress

+ func (MessageParamsMinerChangeAddress) AsBool() (bool, error)

+ func (MessageParamsMinerChangeAddress) AsBytes() ([]byte, error)

+ func (MessageParamsMinerChangeAddress) AsFloat() (float64, error)

+ func (MessageParamsMinerChangeAddress) AsInt() (int64, error)

+ func (MessageParamsMinerChangeAddress) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerChangeAddress) AsString() (string, error)

+ func (MessageParamsMinerChangeAddress) IsAbsent() bool

+ func (MessageParamsMinerChangeAddress) IsNull() bool

+ func (MessageParamsMinerChangeAddress) Kind() ipld.Kind

+ func (MessageParamsMinerChangeAddress) Length() int64

+ func (MessageParamsMinerChangeAddress) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerChangeAddress) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerChangeAddress) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerChangeAddress) Type() schema.Type

+ func (n MessageParamsMinerChangeAddress) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerChangeAddress) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerChangeAddress) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerChangeAddress) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerChangeAddress) Representation() ipld.Node

+ type MessageParamsMinerChangeMultiaddrs = *_MessageParamsMinerChangeMultiaddrs

+ func (MessageParamsMinerChangeMultiaddrs) AsBool() (bool, error)

+ func (MessageParamsMinerChangeMultiaddrs) AsBytes() ([]byte, error)

+ func (MessageParamsMinerChangeMultiaddrs) AsFloat() (float64, error)

+ func (MessageParamsMinerChangeMultiaddrs) AsInt() (int64, error)

+ func (MessageParamsMinerChangeMultiaddrs) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerChangeMultiaddrs) AsString() (string, error)

+ func (MessageParamsMinerChangeMultiaddrs) IsAbsent() bool

+ func (MessageParamsMinerChangeMultiaddrs) IsNull() bool

+ func (MessageParamsMinerChangeMultiaddrs) Kind() ipld.Kind

+ func (MessageParamsMinerChangeMultiaddrs) Length() int64

+ func (MessageParamsMinerChangeMultiaddrs) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerChangeMultiaddrs) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerChangeMultiaddrs) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerChangeMultiaddrs) Type() schema.Type

+ func (n MessageParamsMinerChangeMultiaddrs) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerChangeMultiaddrs) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerChangeMultiaddrs) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerChangeMultiaddrs) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerChangeMultiaddrs) Representation() ipld.Node

+ type MessageParamsMinerChangePeerID = *_MessageParamsMinerChangePeerID

+ func (MessageParamsMinerChangePeerID) AsBool() (bool, error)

+ func (MessageParamsMinerChangePeerID) AsBytes() ([]byte, error)

+ func (MessageParamsMinerChangePeerID) AsFloat() (float64, error)

+ func (MessageParamsMinerChangePeerID) AsInt() (int64, error)

+ func (MessageParamsMinerChangePeerID) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerChangePeerID) AsString() (string, error)

+ func (MessageParamsMinerChangePeerID) IsAbsent() bool

+ func (MessageParamsMinerChangePeerID) IsNull() bool

+ func (MessageParamsMinerChangePeerID) Kind() ipld.Kind

+ func (MessageParamsMinerChangePeerID) Length() int64

+ func (MessageParamsMinerChangePeerID) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerChangePeerID) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerChangePeerID) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerChangePeerID) Type() schema.Type

+ func (n MessageParamsMinerChangePeerID) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerChangePeerID) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerChangePeerID) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerChangePeerID) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerChangePeerID) Representation() ipld.Node

+ type MessageParamsMinerCheckSectorProven = *_MessageParamsMinerCheckSectorProven

+ func (MessageParamsMinerCheckSectorProven) AsBool() (bool, error)

+ func (MessageParamsMinerCheckSectorProven) AsBytes() ([]byte, error)

+ func (MessageParamsMinerCheckSectorProven) AsFloat() (float64, error)

+ func (MessageParamsMinerCheckSectorProven) AsInt() (int64, error)

+ func (MessageParamsMinerCheckSectorProven) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerCheckSectorProven) AsString() (string, error)

+ func (MessageParamsMinerCheckSectorProven) IsAbsent() bool

+ func (MessageParamsMinerCheckSectorProven) IsNull() bool

+ func (MessageParamsMinerCheckSectorProven) Kind() ipld.Kind

+ func (MessageParamsMinerCheckSectorProven) Length() int64

+ func (MessageParamsMinerCheckSectorProven) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerCheckSectorProven) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerCheckSectorProven) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerCheckSectorProven) Type() schema.Type

+ func (n MessageParamsMinerCheckSectorProven) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerCheckSectorProven) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerCheckSectorProven) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerCheckSectorProven) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerCheckSectorProven) Representation() ipld.Node

+ type MessageParamsMinerCompactPartitions = *_MessageParamsMinerCompactPartitions

+ func (MessageParamsMinerCompactPartitions) AsBool() (bool, error)

+ func (MessageParamsMinerCompactPartitions) AsBytes() ([]byte, error)

+ func (MessageParamsMinerCompactPartitions) AsFloat() (float64, error)

+ func (MessageParamsMinerCompactPartitions) AsInt() (int64, error)

+ func (MessageParamsMinerCompactPartitions) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerCompactPartitions) AsString() (string, error)

+ func (MessageParamsMinerCompactPartitions) IsAbsent() bool

+ func (MessageParamsMinerCompactPartitions) IsNull() bool

+ func (MessageParamsMinerCompactPartitions) Kind() ipld.Kind

+ func (MessageParamsMinerCompactPartitions) Length() int64

+ func (MessageParamsMinerCompactPartitions) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerCompactPartitions) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerCompactPartitions) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerCompactPartitions) Type() schema.Type

+ func (n MessageParamsMinerCompactPartitions) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerCompactPartitions) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerCompactPartitions) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerCompactPartitions) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerCompactPartitions) Representation() ipld.Node

+ type MessageParamsMinerCompactSectorNumbers = *_MessageParamsMinerCompactSectorNumbers

+ func (MessageParamsMinerCompactSectorNumbers) AsBool() (bool, error)

+ func (MessageParamsMinerCompactSectorNumbers) AsBytes() ([]byte, error)

+ func (MessageParamsMinerCompactSectorNumbers) AsFloat() (float64, error)

+ func (MessageParamsMinerCompactSectorNumbers) AsInt() (int64, error)

+ func (MessageParamsMinerCompactSectorNumbers) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerCompactSectorNumbers) AsString() (string, error)

+ func (MessageParamsMinerCompactSectorNumbers) IsAbsent() bool

+ func (MessageParamsMinerCompactSectorNumbers) IsNull() bool

+ func (MessageParamsMinerCompactSectorNumbers) Kind() ipld.Kind

+ func (MessageParamsMinerCompactSectorNumbers) Length() int64

+ func (MessageParamsMinerCompactSectorNumbers) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerCompactSectorNumbers) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerCompactSectorNumbers) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerCompactSectorNumbers) Type() schema.Type

+ func (n MessageParamsMinerCompactSectorNumbers) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerCompactSectorNumbers) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerCompactSectorNumbers) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerCompactSectorNumbers) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerCompactSectorNumbers) Representation() ipld.Node

+ type MessageParamsMinerConfirmSectorProofs = *_MessageParamsMinerConfirmSectorProofs

+ func (MessageParamsMinerConfirmSectorProofs) AsBool() (bool, error)

+ func (MessageParamsMinerConfirmSectorProofs) AsBytes() ([]byte, error)

+ func (MessageParamsMinerConfirmSectorProofs) AsFloat() (float64, error)

+ func (MessageParamsMinerConfirmSectorProofs) AsInt() (int64, error)

+ func (MessageParamsMinerConfirmSectorProofs) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerConfirmSectorProofs) AsString() (string, error)

+ func (MessageParamsMinerConfirmSectorProofs) IsAbsent() bool

+ func (MessageParamsMinerConfirmSectorProofs) IsNull() bool

+ func (MessageParamsMinerConfirmSectorProofs) Kind() ipld.Kind

+ func (MessageParamsMinerConfirmSectorProofs) Length() int64

+ func (MessageParamsMinerConfirmSectorProofs) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerConfirmSectorProofs) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerConfirmSectorProofs) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerConfirmSectorProofs) Type() schema.Type

+ func (n MessageParamsMinerConfirmSectorProofs) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerConfirmSectorProofs) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerConfirmSectorProofs) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerConfirmSectorProofs) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerConfirmSectorProofs) Representation() ipld.Node

+ type MessageParamsMinerConstructor = *_MessageParamsMinerConstructor

+ func (MessageParamsMinerConstructor) AsBool() (bool, error)

+ func (MessageParamsMinerConstructor) AsBytes() ([]byte, error)

+ func (MessageParamsMinerConstructor) AsFloat() (float64, error)

+ func (MessageParamsMinerConstructor) AsInt() (int64, error)

+ func (MessageParamsMinerConstructor) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerConstructor) AsString() (string, error)

+ func (MessageParamsMinerConstructor) IsAbsent() bool

+ func (MessageParamsMinerConstructor) IsNull() bool

+ func (MessageParamsMinerConstructor) Kind() ipld.Kind

+ func (MessageParamsMinerConstructor) Length() int64

+ func (MessageParamsMinerConstructor) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerConstructor) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerConstructor) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerConstructor) Type() schema.Type

+ func (n MessageParamsMinerConstructor) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerConstructor) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerConstructor) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerConstructor) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerConstructor) Representation() ipld.Node

+ type MessageParamsMinerDeclareFaults = *_MessageParamsMinerDeclareFaults

+ func (MessageParamsMinerDeclareFaults) AsBool() (bool, error)

+ func (MessageParamsMinerDeclareFaults) AsBytes() ([]byte, error)

+ func (MessageParamsMinerDeclareFaults) AsFloat() (float64, error)

+ func (MessageParamsMinerDeclareFaults) AsInt() (int64, error)

+ func (MessageParamsMinerDeclareFaults) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerDeclareFaults) AsString() (string, error)

+ func (MessageParamsMinerDeclareFaults) IsAbsent() bool

+ func (MessageParamsMinerDeclareFaults) IsNull() bool

+ func (MessageParamsMinerDeclareFaults) Kind() ipld.Kind

+ func (MessageParamsMinerDeclareFaults) Length() int64

+ func (MessageParamsMinerDeclareFaults) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerDeclareFaults) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerDeclareFaults) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerDeclareFaults) Type() schema.Type

+ func (n MessageParamsMinerDeclareFaults) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerDeclareFaults) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerDeclareFaults) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerDeclareFaults) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerDeclareFaults) Representation() ipld.Node

+ type MessageParamsMinerDeclareFaultsRecovered = *_MessageParamsMinerDeclareFaultsRecovered

+ func (MessageParamsMinerDeclareFaultsRecovered) AsBool() (bool, error)

+ func (MessageParamsMinerDeclareFaultsRecovered) AsBytes() ([]byte, error)

+ func (MessageParamsMinerDeclareFaultsRecovered) AsFloat() (float64, error)

+ func (MessageParamsMinerDeclareFaultsRecovered) AsInt() (int64, error)

+ func (MessageParamsMinerDeclareFaultsRecovered) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerDeclareFaultsRecovered) AsString() (string, error)

+ func (MessageParamsMinerDeclareFaultsRecovered) IsAbsent() bool

+ func (MessageParamsMinerDeclareFaultsRecovered) IsNull() bool

+ func (MessageParamsMinerDeclareFaultsRecovered) Kind() ipld.Kind

+ func (MessageParamsMinerDeclareFaultsRecovered) Length() int64

+ func (MessageParamsMinerDeclareFaultsRecovered) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerDeclareFaultsRecovered) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerDeclareFaultsRecovered) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerDeclareFaultsRecovered) Type() schema.Type

+ func (n MessageParamsMinerDeclareFaultsRecovered) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerDeclareFaultsRecovered) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerDeclareFaultsRecovered) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerDeclareFaultsRecovered) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerDeclareFaultsRecovered) Representation() ipld.Node

+ type MessageParamsMinerDeferredCron = *_MessageParamsMinerDeferredCron

+ func (MessageParamsMinerDeferredCron) AsBool() (bool, error)

+ func (MessageParamsMinerDeferredCron) AsBytes() ([]byte, error)

+ func (MessageParamsMinerDeferredCron) AsFloat() (float64, error)

+ func (MessageParamsMinerDeferredCron) AsInt() (int64, error)

+ func (MessageParamsMinerDeferredCron) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerDeferredCron) AsString() (string, error)

+ func (MessageParamsMinerDeferredCron) IsAbsent() bool

+ func (MessageParamsMinerDeferredCron) IsNull() bool

+ func (MessageParamsMinerDeferredCron) Kind() ipld.Kind

+ func (MessageParamsMinerDeferredCron) Length() int64

+ func (MessageParamsMinerDeferredCron) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerDeferredCron) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerDeferredCron) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerDeferredCron) Type() schema.Type

+ func (n MessageParamsMinerDeferredCron) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerDeferredCron) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerDeferredCron) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerDeferredCron) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerDeferredCron) Representation() ipld.Node

+ type MessageParamsMinerDisputeWindowedPoSt = *_MessageParamsMinerDisputeWindowedPoSt

+ func (MessageParamsMinerDisputeWindowedPoSt) AsBool() (bool, error)

+ func (MessageParamsMinerDisputeWindowedPoSt) AsBytes() ([]byte, error)

+ func (MessageParamsMinerDisputeWindowedPoSt) AsFloat() (float64, error)

+ func (MessageParamsMinerDisputeWindowedPoSt) AsInt() (int64, error)

+ func (MessageParamsMinerDisputeWindowedPoSt) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerDisputeWindowedPoSt) AsString() (string, error)

+ func (MessageParamsMinerDisputeWindowedPoSt) IsAbsent() bool

+ func (MessageParamsMinerDisputeWindowedPoSt) IsNull() bool

+ func (MessageParamsMinerDisputeWindowedPoSt) Kind() ipld.Kind

+ func (MessageParamsMinerDisputeWindowedPoSt) Length() int64

+ func (MessageParamsMinerDisputeWindowedPoSt) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerDisputeWindowedPoSt) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerDisputeWindowedPoSt) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerDisputeWindowedPoSt) Type() schema.Type

+ func (n MessageParamsMinerDisputeWindowedPoSt) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerDisputeWindowedPoSt) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerDisputeWindowedPoSt) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerDisputeWindowedPoSt) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerDisputeWindowedPoSt) Representation() ipld.Node

+ type MessageParamsMinerExtendSectorExpiration = *_MessageParamsMinerExtendSectorExpiration

+ func (MessageParamsMinerExtendSectorExpiration) AsBool() (bool, error)

+ func (MessageParamsMinerExtendSectorExpiration) AsBytes() ([]byte, error)

+ func (MessageParamsMinerExtendSectorExpiration) AsFloat() (float64, error)

+ func (MessageParamsMinerExtendSectorExpiration) AsInt() (int64, error)

+ func (MessageParamsMinerExtendSectorExpiration) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerExtendSectorExpiration) AsString() (string, error)

+ func (MessageParamsMinerExtendSectorExpiration) IsAbsent() bool

+ func (MessageParamsMinerExtendSectorExpiration) IsNull() bool

+ func (MessageParamsMinerExtendSectorExpiration) Kind() ipld.Kind

+ func (MessageParamsMinerExtendSectorExpiration) Length() int64

+ func (MessageParamsMinerExtendSectorExpiration) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerExtendSectorExpiration) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerExtendSectorExpiration) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerExtendSectorExpiration) Type() schema.Type

+ func (n MessageParamsMinerExtendSectorExpiration) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerExtendSectorExpiration) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerExtendSectorExpiration) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerExtendSectorExpiration) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerExtendSectorExpiration) Representation() ipld.Node

+ type MessageParamsMinerPreCommitSectorBatch = *_MessageParamsMinerPreCommitSectorBatch

+ func (MessageParamsMinerPreCommitSectorBatch) AsBool() (bool, error)

+ func (MessageParamsMinerPreCommitSectorBatch) AsBytes() ([]byte, error)

+ func (MessageParamsMinerPreCommitSectorBatch) AsFloat() (float64, error)

+ func (MessageParamsMinerPreCommitSectorBatch) AsInt() (int64, error)

+ func (MessageParamsMinerPreCommitSectorBatch) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerPreCommitSectorBatch) AsString() (string, error)

+ func (MessageParamsMinerPreCommitSectorBatch) IsAbsent() bool

+ func (MessageParamsMinerPreCommitSectorBatch) IsNull() bool

+ func (MessageParamsMinerPreCommitSectorBatch) Kind() ipld.Kind

+ func (MessageParamsMinerPreCommitSectorBatch) Length() int64

+ func (MessageParamsMinerPreCommitSectorBatch) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerPreCommitSectorBatch) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerPreCommitSectorBatch) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerPreCommitSectorBatch) Type() schema.Type

+ func (n MessageParamsMinerPreCommitSectorBatch) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerPreCommitSectorBatch) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerPreCommitSectorBatch) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerPreCommitSectorBatch) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerPreCommitSectorBatch) Representation() ipld.Node

+ type MessageParamsMinerProveCommitAggregate = *_MessageParamsMinerProveCommitAggregate

+ func (MessageParamsMinerProveCommitAggregate) AsBool() (bool, error)

+ func (MessageParamsMinerProveCommitAggregate) AsBytes() ([]byte, error)

+ func (MessageParamsMinerProveCommitAggregate) AsFloat() (float64, error)

+ func (MessageParamsMinerProveCommitAggregate) AsInt() (int64, error)

+ func (MessageParamsMinerProveCommitAggregate) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerProveCommitAggregate) AsString() (string, error)

+ func (MessageParamsMinerProveCommitAggregate) IsAbsent() bool

+ func (MessageParamsMinerProveCommitAggregate) IsNull() bool

+ func (MessageParamsMinerProveCommitAggregate) Kind() ipld.Kind

+ func (MessageParamsMinerProveCommitAggregate) Length() int64

+ func (MessageParamsMinerProveCommitAggregate) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerProveCommitAggregate) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerProveCommitAggregate) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerProveCommitAggregate) Type() schema.Type

+ func (n MessageParamsMinerProveCommitAggregate) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerProveCommitAggregate) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerProveCommitAggregate) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerProveCommitAggregate) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerProveCommitAggregate) Representation() ipld.Node

+ type MessageParamsMinerProveCommitSector = *_MessageParamsMinerProveCommitSector

+ func (MessageParamsMinerProveCommitSector) AsBool() (bool, error)

+ func (MessageParamsMinerProveCommitSector) AsBytes() ([]byte, error)

+ func (MessageParamsMinerProveCommitSector) AsFloat() (float64, error)

+ func (MessageParamsMinerProveCommitSector) AsInt() (int64, error)

+ func (MessageParamsMinerProveCommitSector) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerProveCommitSector) AsString() (string, error)

+ func (MessageParamsMinerProveCommitSector) IsAbsent() bool

+ func (MessageParamsMinerProveCommitSector) IsNull() bool

+ func (MessageParamsMinerProveCommitSector) Kind() ipld.Kind

+ func (MessageParamsMinerProveCommitSector) Length() int64

+ func (MessageParamsMinerProveCommitSector) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerProveCommitSector) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerProveCommitSector) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerProveCommitSector) Type() schema.Type

+ func (n MessageParamsMinerProveCommitSector) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerProveCommitSector) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerProveCommitSector) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerProveCommitSector) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerProveCommitSector) Representation() ipld.Node

+ type MessageParamsMinerReportFault = *_MessageParamsMinerReportFault

+ func (MessageParamsMinerReportFault) AsBool() (bool, error)

+ func (MessageParamsMinerReportFault) AsBytes() ([]byte, error)

+ func (MessageParamsMinerReportFault) AsFloat() (float64, error)

+ func (MessageParamsMinerReportFault) AsInt() (int64, error)

+ func (MessageParamsMinerReportFault) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerReportFault) AsString() (string, error)

+ func (MessageParamsMinerReportFault) IsAbsent() bool

+ func (MessageParamsMinerReportFault) IsNull() bool

+ func (MessageParamsMinerReportFault) Kind() ipld.Kind

+ func (MessageParamsMinerReportFault) Length() int64

+ func (MessageParamsMinerReportFault) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerReportFault) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerReportFault) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerReportFault) Type() schema.Type

+ func (n MessageParamsMinerReportFault) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerReportFault) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerReportFault) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerReportFault) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerReportFault) Representation() ipld.Node

+ type MessageParamsMinerSubmitWindowedPoSt = *_MessageParamsMinerSubmitWindowedPoSt

+ func (MessageParamsMinerSubmitWindowedPoSt) AsBool() (bool, error)

+ func (MessageParamsMinerSubmitWindowedPoSt) AsBytes() ([]byte, error)

+ func (MessageParamsMinerSubmitWindowedPoSt) AsFloat() (float64, error)

+ func (MessageParamsMinerSubmitWindowedPoSt) AsInt() (int64, error)

+ func (MessageParamsMinerSubmitWindowedPoSt) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerSubmitWindowedPoSt) AsString() (string, error)

+ func (MessageParamsMinerSubmitWindowedPoSt) IsAbsent() bool

+ func (MessageParamsMinerSubmitWindowedPoSt) IsNull() bool

+ func (MessageParamsMinerSubmitWindowedPoSt) Kind() ipld.Kind

+ func (MessageParamsMinerSubmitWindowedPoSt) Length() int64

+ func (MessageParamsMinerSubmitWindowedPoSt) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerSubmitWindowedPoSt) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerSubmitWindowedPoSt) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerSubmitWindowedPoSt) Type() schema.Type

+ func (n MessageParamsMinerSubmitWindowedPoSt) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerSubmitWindowedPoSt) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerSubmitWindowedPoSt) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerSubmitWindowedPoSt) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerSubmitWindowedPoSt) Representation() ipld.Node

+ type MessageParamsMinerTerminateSectors = *_MessageParamsMinerTerminateSectors

+ func (MessageParamsMinerTerminateSectors) AsBool() (bool, error)

+ func (MessageParamsMinerTerminateSectors) AsBytes() ([]byte, error)

+ func (MessageParamsMinerTerminateSectors) AsFloat() (float64, error)

+ func (MessageParamsMinerTerminateSectors) AsInt() (int64, error)

+ func (MessageParamsMinerTerminateSectors) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerTerminateSectors) AsString() (string, error)

+ func (MessageParamsMinerTerminateSectors) IsAbsent() bool

+ func (MessageParamsMinerTerminateSectors) IsNull() bool

+ func (MessageParamsMinerTerminateSectors) Kind() ipld.Kind

+ func (MessageParamsMinerTerminateSectors) Length() int64

+ func (MessageParamsMinerTerminateSectors) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerTerminateSectors) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerTerminateSectors) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerTerminateSectors) Type() schema.Type

+ func (n MessageParamsMinerTerminateSectors) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerTerminateSectors) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerTerminateSectors) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerTerminateSectors) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerTerminateSectors) Representation() ipld.Node

+ type MessageParamsMinerWithdrawBalance = *_MessageParamsMinerWithdrawBalance

+ func (MessageParamsMinerWithdrawBalance) AsBool() (bool, error)

+ func (MessageParamsMinerWithdrawBalance) AsBytes() ([]byte, error)

+ func (MessageParamsMinerWithdrawBalance) AsFloat() (float64, error)

+ func (MessageParamsMinerWithdrawBalance) AsInt() (int64, error)

+ func (MessageParamsMinerWithdrawBalance) AsLink() (ipld.Link, error)

+ func (MessageParamsMinerWithdrawBalance) AsString() (string, error)

+ func (MessageParamsMinerWithdrawBalance) IsAbsent() bool

+ func (MessageParamsMinerWithdrawBalance) IsNull() bool

+ func (MessageParamsMinerWithdrawBalance) Kind() ipld.Kind

+ func (MessageParamsMinerWithdrawBalance) Length() int64

+ func (MessageParamsMinerWithdrawBalance) ListIterator() ipld.ListIterator

+ func (MessageParamsMinerWithdrawBalance) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMinerWithdrawBalance) Prototype() ipld.NodePrototype

+ func (MessageParamsMinerWithdrawBalance) Type() schema.Type

+ func (n MessageParamsMinerWithdrawBalance) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMinerWithdrawBalance) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMinerWithdrawBalance) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMinerWithdrawBalance) MapIterator() ipld.MapIterator

+ func (n MessageParamsMinerWithdrawBalance) Representation() ipld.Node

+ type MessageParamsMultisigAddSigner = *_MessageParamsMultisigAddSigner

+ func (MessageParamsMultisigAddSigner) AsBool() (bool, error)

+ func (MessageParamsMultisigAddSigner) AsBytes() ([]byte, error)

+ func (MessageParamsMultisigAddSigner) AsFloat() (float64, error)

+ func (MessageParamsMultisigAddSigner) AsInt() (int64, error)

+ func (MessageParamsMultisigAddSigner) AsLink() (ipld.Link, error)

+ func (MessageParamsMultisigAddSigner) AsString() (string, error)

+ func (MessageParamsMultisigAddSigner) IsAbsent() bool

+ func (MessageParamsMultisigAddSigner) IsNull() bool

+ func (MessageParamsMultisigAddSigner) Kind() ipld.Kind

+ func (MessageParamsMultisigAddSigner) Length() int64

+ func (MessageParamsMultisigAddSigner) ListIterator() ipld.ListIterator

+ func (MessageParamsMultisigAddSigner) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMultisigAddSigner) Prototype() ipld.NodePrototype

+ func (MessageParamsMultisigAddSigner) Type() schema.Type

+ func (n MessageParamsMultisigAddSigner) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMultisigAddSigner) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMultisigAddSigner) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMultisigAddSigner) MapIterator() ipld.MapIterator

+ func (n MessageParamsMultisigAddSigner) Representation() ipld.Node

+ type MessageParamsMultisigChangeThreshold = *_MessageParamsMultisigChangeThreshold

+ func (MessageParamsMultisigChangeThreshold) AsBool() (bool, error)

+ func (MessageParamsMultisigChangeThreshold) AsBytes() ([]byte, error)

+ func (MessageParamsMultisigChangeThreshold) AsFloat() (float64, error)

+ func (MessageParamsMultisigChangeThreshold) AsInt() (int64, error)

+ func (MessageParamsMultisigChangeThreshold) AsLink() (ipld.Link, error)

+ func (MessageParamsMultisigChangeThreshold) AsString() (string, error)

+ func (MessageParamsMultisigChangeThreshold) IsAbsent() bool

+ func (MessageParamsMultisigChangeThreshold) IsNull() bool

+ func (MessageParamsMultisigChangeThreshold) Kind() ipld.Kind

+ func (MessageParamsMultisigChangeThreshold) Length() int64

+ func (MessageParamsMultisigChangeThreshold) ListIterator() ipld.ListIterator

+ func (MessageParamsMultisigChangeThreshold) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMultisigChangeThreshold) Prototype() ipld.NodePrototype

+ func (MessageParamsMultisigChangeThreshold) Type() schema.Type

+ func (n MessageParamsMultisigChangeThreshold) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMultisigChangeThreshold) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMultisigChangeThreshold) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMultisigChangeThreshold) MapIterator() ipld.MapIterator

+ func (n MessageParamsMultisigChangeThreshold) Representation() ipld.Node

+ type MessageParamsMultisigConstructor = *_MessageParamsMultisigConstructor

+ func (MessageParamsMultisigConstructor) AsBool() (bool, error)

+ func (MessageParamsMultisigConstructor) AsBytes() ([]byte, error)

+ func (MessageParamsMultisigConstructor) AsFloat() (float64, error)

+ func (MessageParamsMultisigConstructor) AsInt() (int64, error)

+ func (MessageParamsMultisigConstructor) AsLink() (ipld.Link, error)

+ func (MessageParamsMultisigConstructor) AsString() (string, error)

+ func (MessageParamsMultisigConstructor) IsAbsent() bool

+ func (MessageParamsMultisigConstructor) IsNull() bool

+ func (MessageParamsMultisigConstructor) Kind() ipld.Kind

+ func (MessageParamsMultisigConstructor) Length() int64

+ func (MessageParamsMultisigConstructor) ListIterator() ipld.ListIterator

+ func (MessageParamsMultisigConstructor) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMultisigConstructor) Prototype() ipld.NodePrototype

+ func (MessageParamsMultisigConstructor) Type() schema.Type

+ func (n MessageParamsMultisigConstructor) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMultisigConstructor) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMultisigConstructor) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMultisigConstructor) MapIterator() ipld.MapIterator

+ func (n MessageParamsMultisigConstructor) Representation() ipld.Node

+ type MessageParamsMultisigLockBalance = *_MessageParamsMultisigLockBalance

+ func (MessageParamsMultisigLockBalance) AsBool() (bool, error)

+ func (MessageParamsMultisigLockBalance) AsBytes() ([]byte, error)

+ func (MessageParamsMultisigLockBalance) AsFloat() (float64, error)

+ func (MessageParamsMultisigLockBalance) AsInt() (int64, error)

+ func (MessageParamsMultisigLockBalance) AsLink() (ipld.Link, error)

+ func (MessageParamsMultisigLockBalance) AsString() (string, error)

+ func (MessageParamsMultisigLockBalance) IsAbsent() bool

+ func (MessageParamsMultisigLockBalance) IsNull() bool

+ func (MessageParamsMultisigLockBalance) Kind() ipld.Kind

+ func (MessageParamsMultisigLockBalance) Length() int64

+ func (MessageParamsMultisigLockBalance) ListIterator() ipld.ListIterator

+ func (MessageParamsMultisigLockBalance) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMultisigLockBalance) Prototype() ipld.NodePrototype

+ func (MessageParamsMultisigLockBalance) Type() schema.Type

+ func (n MessageParamsMultisigLockBalance) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMultisigLockBalance) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMultisigLockBalance) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMultisigLockBalance) MapIterator() ipld.MapIterator

+ func (n MessageParamsMultisigLockBalance) Representation() ipld.Node

+ type MessageParamsMultisigPropose = *_MessageParamsMultisigPropose

+ func (MessageParamsMultisigPropose) AsBool() (bool, error)

+ func (MessageParamsMultisigPropose) AsBytes() ([]byte, error)

+ func (MessageParamsMultisigPropose) AsFloat() (float64, error)

+ func (MessageParamsMultisigPropose) AsInt() (int64, error)

+ func (MessageParamsMultisigPropose) AsLink() (ipld.Link, error)

+ func (MessageParamsMultisigPropose) AsString() (string, error)

+ func (MessageParamsMultisigPropose) IsAbsent() bool

+ func (MessageParamsMultisigPropose) IsNull() bool

+ func (MessageParamsMultisigPropose) Kind() ipld.Kind

+ func (MessageParamsMultisigPropose) Length() int64

+ func (MessageParamsMultisigPropose) ListIterator() ipld.ListIterator

+ func (MessageParamsMultisigPropose) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMultisigPropose) Prototype() ipld.NodePrototype

+ func (MessageParamsMultisigPropose) Type() schema.Type

+ func (n MessageParamsMultisigPropose) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMultisigPropose) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMultisigPropose) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMultisigPropose) MapIterator() ipld.MapIterator

+ func (n MessageParamsMultisigPropose) Representation() ipld.Node

+ type MessageParamsMultisigRemoveSigner = *_MessageParamsMultisigRemoveSigner

+ func (MessageParamsMultisigRemoveSigner) AsBool() (bool, error)

+ func (MessageParamsMultisigRemoveSigner) AsBytes() ([]byte, error)

+ func (MessageParamsMultisigRemoveSigner) AsFloat() (float64, error)

+ func (MessageParamsMultisigRemoveSigner) AsInt() (int64, error)

+ func (MessageParamsMultisigRemoveSigner) AsLink() (ipld.Link, error)

+ func (MessageParamsMultisigRemoveSigner) AsString() (string, error)

+ func (MessageParamsMultisigRemoveSigner) IsAbsent() bool

+ func (MessageParamsMultisigRemoveSigner) IsNull() bool

+ func (MessageParamsMultisigRemoveSigner) Kind() ipld.Kind

+ func (MessageParamsMultisigRemoveSigner) Length() int64

+ func (MessageParamsMultisigRemoveSigner) ListIterator() ipld.ListIterator

+ func (MessageParamsMultisigRemoveSigner) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMultisigRemoveSigner) Prototype() ipld.NodePrototype

+ func (MessageParamsMultisigRemoveSigner) Type() schema.Type

+ func (n MessageParamsMultisigRemoveSigner) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMultisigRemoveSigner) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMultisigRemoveSigner) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMultisigRemoveSigner) MapIterator() ipld.MapIterator

+ func (n MessageParamsMultisigRemoveSigner) Representation() ipld.Node

+ type MessageParamsMultisigSwapSigner = *_MessageParamsMultisigSwapSigner

+ func (MessageParamsMultisigSwapSigner) AsBool() (bool, error)

+ func (MessageParamsMultisigSwapSigner) AsBytes() ([]byte, error)

+ func (MessageParamsMultisigSwapSigner) AsFloat() (float64, error)

+ func (MessageParamsMultisigSwapSigner) AsInt() (int64, error)

+ func (MessageParamsMultisigSwapSigner) AsLink() (ipld.Link, error)

+ func (MessageParamsMultisigSwapSigner) AsString() (string, error)

+ func (MessageParamsMultisigSwapSigner) IsAbsent() bool

+ func (MessageParamsMultisigSwapSigner) IsNull() bool

+ func (MessageParamsMultisigSwapSigner) Kind() ipld.Kind

+ func (MessageParamsMultisigSwapSigner) Length() int64

+ func (MessageParamsMultisigSwapSigner) ListIterator() ipld.ListIterator

+ func (MessageParamsMultisigSwapSigner) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMultisigSwapSigner) Prototype() ipld.NodePrototype

+ func (MessageParamsMultisigSwapSigner) Type() schema.Type

+ func (n MessageParamsMultisigSwapSigner) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMultisigSwapSigner) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMultisigSwapSigner) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMultisigSwapSigner) MapIterator() ipld.MapIterator

+ func (n MessageParamsMultisigSwapSigner) Representation() ipld.Node

+ type MessageParamsMultisigTxnID = *_MessageParamsMultisigTxnID

+ func (MessageParamsMultisigTxnID) AsBool() (bool, error)

+ func (MessageParamsMultisigTxnID) AsBytes() ([]byte, error)

+ func (MessageParamsMultisigTxnID) AsFloat() (float64, error)

+ func (MessageParamsMultisigTxnID) AsInt() (int64, error)

+ func (MessageParamsMultisigTxnID) AsLink() (ipld.Link, error)

+ func (MessageParamsMultisigTxnID) AsString() (string, error)

+ func (MessageParamsMultisigTxnID) IsAbsent() bool

+ func (MessageParamsMultisigTxnID) IsNull() bool

+ func (MessageParamsMultisigTxnID) Kind() ipld.Kind

+ func (MessageParamsMultisigTxnID) Length() int64

+ func (MessageParamsMultisigTxnID) ListIterator() ipld.ListIterator

+ func (MessageParamsMultisigTxnID) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsMultisigTxnID) Prototype() ipld.NodePrototype

+ func (MessageParamsMultisigTxnID) Type() schema.Type

+ func (n MessageParamsMultisigTxnID) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsMultisigTxnID) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsMultisigTxnID) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsMultisigTxnID) MapIterator() ipld.MapIterator

+ func (n MessageParamsMultisigTxnID) Representation() ipld.Node

+ type MessageParamsPaychConstructor = *_MessageParamsPaychConstructor

+ func (MessageParamsPaychConstructor) AsBool() (bool, error)

+ func (MessageParamsPaychConstructor) AsBytes() ([]byte, error)

+ func (MessageParamsPaychConstructor) AsFloat() (float64, error)

+ func (MessageParamsPaychConstructor) AsInt() (int64, error)

+ func (MessageParamsPaychConstructor) AsLink() (ipld.Link, error)

+ func (MessageParamsPaychConstructor) AsString() (string, error)

+ func (MessageParamsPaychConstructor) IsAbsent() bool

+ func (MessageParamsPaychConstructor) IsNull() bool

+ func (MessageParamsPaychConstructor) Kind() ipld.Kind

+ func (MessageParamsPaychConstructor) Length() int64

+ func (MessageParamsPaychConstructor) ListIterator() ipld.ListIterator

+ func (MessageParamsPaychConstructor) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsPaychConstructor) Prototype() ipld.NodePrototype

+ func (MessageParamsPaychConstructor) Type() schema.Type

+ func (n MessageParamsPaychConstructor) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsPaychConstructor) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsPaychConstructor) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsPaychConstructor) MapIterator() ipld.MapIterator

+ func (n MessageParamsPaychConstructor) Representation() ipld.Node

+ type MessageParamsPaychUpdateChannelState = *_MessageParamsPaychUpdateChannelState

+ func (MessageParamsPaychUpdateChannelState) AsBool() (bool, error)

+ func (MessageParamsPaychUpdateChannelState) AsBytes() ([]byte, error)

+ func (MessageParamsPaychUpdateChannelState) AsFloat() (float64, error)

+ func (MessageParamsPaychUpdateChannelState) AsInt() (int64, error)

+ func (MessageParamsPaychUpdateChannelState) AsLink() (ipld.Link, error)

+ func (MessageParamsPaychUpdateChannelState) AsString() (string, error)

+ func (MessageParamsPaychUpdateChannelState) IsAbsent() bool

+ func (MessageParamsPaychUpdateChannelState) IsNull() bool

+ func (MessageParamsPaychUpdateChannelState) Kind() ipld.Kind

+ func (MessageParamsPaychUpdateChannelState) Length() int64

+ func (MessageParamsPaychUpdateChannelState) ListIterator() ipld.ListIterator

+ func (MessageParamsPaychUpdateChannelState) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsPaychUpdateChannelState) Prototype() ipld.NodePrototype

+ func (MessageParamsPaychUpdateChannelState) Type() schema.Type

+ func (n MessageParamsPaychUpdateChannelState) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsPaychUpdateChannelState) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsPaychUpdateChannelState) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsPaychUpdateChannelState) MapIterator() ipld.MapIterator

+ func (n MessageParamsPaychUpdateChannelState) Representation() ipld.Node

+ type MessageParamsPowerCreateMiner = *_MessageParamsPowerCreateMiner

+ func (MessageParamsPowerCreateMiner) AsBool() (bool, error)

+ func (MessageParamsPowerCreateMiner) AsBytes() ([]byte, error)

+ func (MessageParamsPowerCreateMiner) AsFloat() (float64, error)

+ func (MessageParamsPowerCreateMiner) AsInt() (int64, error)

+ func (MessageParamsPowerCreateMiner) AsLink() (ipld.Link, error)

+ func (MessageParamsPowerCreateMiner) AsString() (string, error)

+ func (MessageParamsPowerCreateMiner) IsAbsent() bool

+ func (MessageParamsPowerCreateMiner) IsNull() bool

+ func (MessageParamsPowerCreateMiner) Kind() ipld.Kind

+ func (MessageParamsPowerCreateMiner) Length() int64

+ func (MessageParamsPowerCreateMiner) ListIterator() ipld.ListIterator

+ func (MessageParamsPowerCreateMiner) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsPowerCreateMiner) Prototype() ipld.NodePrototype

+ func (MessageParamsPowerCreateMiner) Type() schema.Type

+ func (n MessageParamsPowerCreateMiner) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsPowerCreateMiner) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsPowerCreateMiner) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsPowerCreateMiner) MapIterator() ipld.MapIterator

+ func (n MessageParamsPowerCreateMiner) Representation() ipld.Node

+ type MessageParamsPowerCurrentTotal = *_MessageParamsPowerCurrentTotal

+ func (MessageParamsPowerCurrentTotal) AsBool() (bool, error)

+ func (MessageParamsPowerCurrentTotal) AsBytes() ([]byte, error)

+ func (MessageParamsPowerCurrentTotal) AsFloat() (float64, error)

+ func (MessageParamsPowerCurrentTotal) AsInt() (int64, error)

+ func (MessageParamsPowerCurrentTotal) AsLink() (ipld.Link, error)

+ func (MessageParamsPowerCurrentTotal) AsString() (string, error)

+ func (MessageParamsPowerCurrentTotal) IsAbsent() bool

+ func (MessageParamsPowerCurrentTotal) IsNull() bool

+ func (MessageParamsPowerCurrentTotal) Kind() ipld.Kind

+ func (MessageParamsPowerCurrentTotal) Length() int64

+ func (MessageParamsPowerCurrentTotal) ListIterator() ipld.ListIterator

+ func (MessageParamsPowerCurrentTotal) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsPowerCurrentTotal) Prototype() ipld.NodePrototype

+ func (MessageParamsPowerCurrentTotal) Type() schema.Type

+ func (n MessageParamsPowerCurrentTotal) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsPowerCurrentTotal) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsPowerCurrentTotal) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsPowerCurrentTotal) MapIterator() ipld.MapIterator

+ func (n MessageParamsPowerCurrentTotal) Representation() ipld.Node

+ type MessageParamsPowerEnrollCron = *_MessageParamsPowerEnrollCron

+ func (MessageParamsPowerEnrollCron) AsBool() (bool, error)

+ func (MessageParamsPowerEnrollCron) AsBytes() ([]byte, error)

+ func (MessageParamsPowerEnrollCron) AsFloat() (float64, error)

+ func (MessageParamsPowerEnrollCron) AsInt() (int64, error)

+ func (MessageParamsPowerEnrollCron) AsLink() (ipld.Link, error)

+ func (MessageParamsPowerEnrollCron) AsString() (string, error)

+ func (MessageParamsPowerEnrollCron) IsAbsent() bool

+ func (MessageParamsPowerEnrollCron) IsNull() bool

+ func (MessageParamsPowerEnrollCron) Kind() ipld.Kind

+ func (MessageParamsPowerEnrollCron) Length() int64

+ func (MessageParamsPowerEnrollCron) ListIterator() ipld.ListIterator

+ func (MessageParamsPowerEnrollCron) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsPowerEnrollCron) Prototype() ipld.NodePrototype

+ func (MessageParamsPowerEnrollCron) Type() schema.Type

+ func (n MessageParamsPowerEnrollCron) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsPowerEnrollCron) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsPowerEnrollCron) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsPowerEnrollCron) MapIterator() ipld.MapIterator

+ func (n MessageParamsPowerEnrollCron) Representation() ipld.Node

+ type MessageParamsPowerUpdateClaimed = *_MessageParamsPowerUpdateClaimed

+ func (MessageParamsPowerUpdateClaimed) AsBool() (bool, error)

+ func (MessageParamsPowerUpdateClaimed) AsBytes() ([]byte, error)

+ func (MessageParamsPowerUpdateClaimed) AsFloat() (float64, error)

+ func (MessageParamsPowerUpdateClaimed) AsInt() (int64, error)

+ func (MessageParamsPowerUpdateClaimed) AsLink() (ipld.Link, error)

+ func (MessageParamsPowerUpdateClaimed) AsString() (string, error)

+ func (MessageParamsPowerUpdateClaimed) IsAbsent() bool

+ func (MessageParamsPowerUpdateClaimed) IsNull() bool

+ func (MessageParamsPowerUpdateClaimed) Kind() ipld.Kind

+ func (MessageParamsPowerUpdateClaimed) Length() int64

+ func (MessageParamsPowerUpdateClaimed) ListIterator() ipld.ListIterator

+ func (MessageParamsPowerUpdateClaimed) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsPowerUpdateClaimed) Prototype() ipld.NodePrototype

+ func (MessageParamsPowerUpdateClaimed) Type() schema.Type

+ func (n MessageParamsPowerUpdateClaimed) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsPowerUpdateClaimed) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsPowerUpdateClaimed) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsPowerUpdateClaimed) MapIterator() ipld.MapIterator

+ func (n MessageParamsPowerUpdateClaimed) Representation() ipld.Node

+ type MessageParamsRewardAwardBlock = *_MessageParamsRewardAwardBlock

+ func (MessageParamsRewardAwardBlock) AsBool() (bool, error)

+ func (MessageParamsRewardAwardBlock) AsBytes() ([]byte, error)

+ func (MessageParamsRewardAwardBlock) AsFloat() (float64, error)

+ func (MessageParamsRewardAwardBlock) AsInt() (int64, error)

+ func (MessageParamsRewardAwardBlock) AsLink() (ipld.Link, error)

+ func (MessageParamsRewardAwardBlock) AsString() (string, error)

+ func (MessageParamsRewardAwardBlock) IsAbsent() bool

+ func (MessageParamsRewardAwardBlock) IsNull() bool

+ func (MessageParamsRewardAwardBlock) Kind() ipld.Kind

+ func (MessageParamsRewardAwardBlock) Length() int64

+ func (MessageParamsRewardAwardBlock) ListIterator() ipld.ListIterator

+ func (MessageParamsRewardAwardBlock) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsRewardAwardBlock) Prototype() ipld.NodePrototype

+ func (MessageParamsRewardAwardBlock) Type() schema.Type

+ func (n MessageParamsRewardAwardBlock) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsRewardAwardBlock) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsRewardAwardBlock) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsRewardAwardBlock) MapIterator() ipld.MapIterator

+ func (n MessageParamsRewardAwardBlock) Representation() ipld.Node

+ type MessageParamsVerifregAddVerifier = *_MessageParamsVerifregAddVerifier

+ func (MessageParamsVerifregAddVerifier) AsBool() (bool, error)

+ func (MessageParamsVerifregAddVerifier) AsBytes() ([]byte, error)

+ func (MessageParamsVerifregAddVerifier) AsFloat() (float64, error)

+ func (MessageParamsVerifregAddVerifier) AsInt() (int64, error)

+ func (MessageParamsVerifregAddVerifier) AsLink() (ipld.Link, error)

+ func (MessageParamsVerifregAddVerifier) AsString() (string, error)

+ func (MessageParamsVerifregAddVerifier) IsAbsent() bool

+ func (MessageParamsVerifregAddVerifier) IsNull() bool

+ func (MessageParamsVerifregAddVerifier) Kind() ipld.Kind

+ func (MessageParamsVerifregAddVerifier) Length() int64

+ func (MessageParamsVerifregAddVerifier) ListIterator() ipld.ListIterator

+ func (MessageParamsVerifregAddVerifier) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsVerifregAddVerifier) Prototype() ipld.NodePrototype

+ func (MessageParamsVerifregAddVerifier) Type() schema.Type

+ func (n MessageParamsVerifregAddVerifier) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsVerifregAddVerifier) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsVerifregAddVerifier) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsVerifregAddVerifier) MapIterator() ipld.MapIterator

+ func (n MessageParamsVerifregAddVerifier) Representation() ipld.Node

+ type MessageParamsVerifregUseBytes = *_MessageParamsVerifregUseBytes

+ func (MessageParamsVerifregUseBytes) AsBool() (bool, error)

+ func (MessageParamsVerifregUseBytes) AsBytes() ([]byte, error)

+ func (MessageParamsVerifregUseBytes) AsFloat() (float64, error)

+ func (MessageParamsVerifregUseBytes) AsInt() (int64, error)

+ func (MessageParamsVerifregUseBytes) AsLink() (ipld.Link, error)

+ func (MessageParamsVerifregUseBytes) AsString() (string, error)

+ func (MessageParamsVerifregUseBytes) IsAbsent() bool

+ func (MessageParamsVerifregUseBytes) IsNull() bool

+ func (MessageParamsVerifregUseBytes) Kind() ipld.Kind

+ func (MessageParamsVerifregUseBytes) Length() int64

+ func (MessageParamsVerifregUseBytes) ListIterator() ipld.ListIterator

+ func (MessageParamsVerifregUseBytes) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MessageParamsVerifregUseBytes) Prototype() ipld.NodePrototype

+ func (MessageParamsVerifregUseBytes) Type() schema.Type

+ func (n MessageParamsVerifregUseBytes) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MessageParamsVerifregUseBytes) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MessageParamsVerifregUseBytes) LookupByString(key string) (ipld.Node, error)

+ func (n MessageParamsVerifregUseBytes) MapIterator() ipld.MapIterator

+ func (n MessageParamsVerifregUseBytes) Representation() ipld.Node

+ type MethodNum = *_MethodNum

+ func (MethodNum) AsBool() (bool, error)

+ func (MethodNum) AsBytes() ([]byte, error)

+ func (MethodNum) AsFloat() (float64, error)

+ func (MethodNum) AsLink() (ipld.Link, error)

+ func (MethodNum) AsString() (string, error)

+ func (MethodNum) IsAbsent() bool

+ func (MethodNum) IsNull() bool

+ func (MethodNum) Kind() ipld.Kind

+ func (MethodNum) Length() int64

+ func (MethodNum) ListIterator() ipld.ListIterator

+ func (MethodNum) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MethodNum) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (MethodNum) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (MethodNum) LookupByString(string) (ipld.Node, error)

+ func (MethodNum) MapIterator() ipld.MapIterator

+ func (MethodNum) Prototype() ipld.NodePrototype

+ func (MethodNum) Type() schema.Type

+ func (n MethodNum) AsInt() (int64, error)

+ func (n MethodNum) Int() int64

+ func (n MethodNum) Representation() ipld.Node

+ type MinerExpirationExtend = *_MinerExpirationExtend

+ func (MinerExpirationExtend) AsBool() (bool, error)

+ func (MinerExpirationExtend) AsBytes() ([]byte, error)

+ func (MinerExpirationExtend) AsFloat() (float64, error)

+ func (MinerExpirationExtend) AsInt() (int64, error)

+ func (MinerExpirationExtend) AsLink() (ipld.Link, error)

+ func (MinerExpirationExtend) AsString() (string, error)

+ func (MinerExpirationExtend) IsAbsent() bool

+ func (MinerExpirationExtend) IsNull() bool

+ func (MinerExpirationExtend) Kind() ipld.Kind

+ func (MinerExpirationExtend) Length() int64

+ func (MinerExpirationExtend) ListIterator() ipld.ListIterator

+ func (MinerExpirationExtend) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerExpirationExtend) Prototype() ipld.NodePrototype

+ func (MinerExpirationExtend) Type() schema.Type

+ func (n MinerExpirationExtend) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerExpirationExtend) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerExpirationExtend) LookupByString(key string) (ipld.Node, error)

+ func (n MinerExpirationExtend) MapIterator() ipld.MapIterator

+ func (n MinerExpirationExtend) Representation() ipld.Node

+ type MinerPostPartition = *_MinerPostPartition

+ func (MinerPostPartition) AsBool() (bool, error)

+ func (MinerPostPartition) AsBytes() ([]byte, error)

+ func (MinerPostPartition) AsFloat() (float64, error)

+ func (MinerPostPartition) AsInt() (int64, error)

+ func (MinerPostPartition) AsLink() (ipld.Link, error)

+ func (MinerPostPartition) AsString() (string, error)

+ func (MinerPostPartition) IsAbsent() bool

+ func (MinerPostPartition) IsNull() bool

+ func (MinerPostPartition) Kind() ipld.Kind

+ func (MinerPostPartition) Length() int64

+ func (MinerPostPartition) ListIterator() ipld.ListIterator

+ func (MinerPostPartition) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerPostPartition) Prototype() ipld.NodePrototype

+ func (MinerPostPartition) Type() schema.Type

+ func (n MinerPostPartition) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerPostPartition) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerPostPartition) LookupByString(key string) (ipld.Node, error)

+ func (n MinerPostPartition) MapIterator() ipld.MapIterator

+ func (n MinerPostPartition) Representation() ipld.Node

+ type MinerPostProof = *_MinerPostProof

+ func (MinerPostProof) AsBool() (bool, error)

+ func (MinerPostProof) AsBytes() ([]byte, error)

+ func (MinerPostProof) AsFloat() (float64, error)

+ func (MinerPostProof) AsInt() (int64, error)

+ func (MinerPostProof) AsLink() (ipld.Link, error)

+ func (MinerPostProof) AsString() (string, error)

+ func (MinerPostProof) IsAbsent() bool

+ func (MinerPostProof) IsNull() bool

+ func (MinerPostProof) Kind() ipld.Kind

+ func (MinerPostProof) Length() int64

+ func (MinerPostProof) ListIterator() ipld.ListIterator

+ func (MinerPostProof) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerPostProof) Prototype() ipld.NodePrototype

+ func (MinerPostProof) Type() schema.Type

+ func (n MinerPostProof) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerPostProof) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerPostProof) LookupByString(key string) (ipld.Node, error)

+ func (n MinerPostProof) MapIterator() ipld.MapIterator

+ func (n MinerPostProof) Representation() ipld.Node

+ type MinerTerminationDecl = *_MinerTerminationDecl

+ func (MinerTerminationDecl) AsBool() (bool, error)

+ func (MinerTerminationDecl) AsBytes() ([]byte, error)

+ func (MinerTerminationDecl) AsFloat() (float64, error)

+ func (MinerTerminationDecl) AsInt() (int64, error)

+ func (MinerTerminationDecl) AsLink() (ipld.Link, error)

+ func (MinerTerminationDecl) AsString() (string, error)

+ func (MinerTerminationDecl) IsAbsent() bool

+ func (MinerTerminationDecl) IsNull() bool

+ func (MinerTerminationDecl) Kind() ipld.Kind

+ func (MinerTerminationDecl) Length() int64

+ func (MinerTerminationDecl) ListIterator() ipld.ListIterator

+ func (MinerTerminationDecl) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerTerminationDecl) Prototype() ipld.NodePrototype

+ func (MinerTerminationDecl) Type() schema.Type

+ func (n MinerTerminationDecl) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerTerminationDecl) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerTerminationDecl) LookupByString(key string) (ipld.Node, error)

+ func (n MinerTerminationDecl) MapIterator() ipld.MapIterator

+ func (n MinerTerminationDecl) Representation() ipld.Node

+ type MinerV0Deadline = *_MinerV0Deadline

+ func (MinerV0Deadline) AsBool() (bool, error)

+ func (MinerV0Deadline) AsBytes() ([]byte, error)

+ func (MinerV0Deadline) AsFloat() (float64, error)

+ func (MinerV0Deadline) AsInt() (int64, error)

+ func (MinerV0Deadline) AsLink() (ipld.Link, error)

+ func (MinerV0Deadline) AsString() (string, error)

+ func (MinerV0Deadline) IsAbsent() bool

+ func (MinerV0Deadline) IsNull() bool

+ func (MinerV0Deadline) Kind() ipld.Kind

+ func (MinerV0Deadline) Length() int64

+ func (MinerV0Deadline) ListIterator() ipld.ListIterator

+ func (MinerV0Deadline) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV0Deadline) Prototype() ipld.NodePrototype

+ func (MinerV0Deadline) Type() schema.Type

+ func (n MinerV0Deadline) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV0Deadline) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV0Deadline) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV0Deadline) MapIterator() ipld.MapIterator

+ func (n MinerV0Deadline) Representation() ipld.Node

+ type MinerV0Deadlines = *_MinerV0Deadlines

+ func (MinerV0Deadlines) AsBool() (bool, error)

+ func (MinerV0Deadlines) AsBytes() ([]byte, error)

+ func (MinerV0Deadlines) AsFloat() (float64, error)

+ func (MinerV0Deadlines) AsInt() (int64, error)

+ func (MinerV0Deadlines) AsLink() (ipld.Link, error)

+ func (MinerV0Deadlines) AsString() (string, error)

+ func (MinerV0Deadlines) IsAbsent() bool

+ func (MinerV0Deadlines) IsNull() bool

+ func (MinerV0Deadlines) Kind() ipld.Kind

+ func (MinerV0Deadlines) Length() int64

+ func (MinerV0Deadlines) ListIterator() ipld.ListIterator

+ func (MinerV0Deadlines) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV0Deadlines) Prototype() ipld.NodePrototype

+ func (MinerV0Deadlines) Type() schema.Type

+ func (n MinerV0Deadlines) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV0Deadlines) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV0Deadlines) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV0Deadlines) MapIterator() ipld.MapIterator

+ func (n MinerV0Deadlines) Representation() ipld.Node

+ type MinerV0ExpirationSet = *_MinerV0ExpirationSet

+ func (MinerV0ExpirationSet) AsBool() (bool, error)

+ func (MinerV0ExpirationSet) AsBytes() ([]byte, error)

+ func (MinerV0ExpirationSet) AsFloat() (float64, error)

+ func (MinerV0ExpirationSet) AsInt() (int64, error)

+ func (MinerV0ExpirationSet) AsLink() (ipld.Link, error)

+ func (MinerV0ExpirationSet) AsString() (string, error)

+ func (MinerV0ExpirationSet) IsAbsent() bool

+ func (MinerV0ExpirationSet) IsNull() bool

+ func (MinerV0ExpirationSet) Kind() ipld.Kind

+ func (MinerV0ExpirationSet) Length() int64

+ func (MinerV0ExpirationSet) ListIterator() ipld.ListIterator

+ func (MinerV0ExpirationSet) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV0ExpirationSet) Prototype() ipld.NodePrototype

+ func (MinerV0ExpirationSet) Type() schema.Type

+ func (n MinerV0ExpirationSet) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV0ExpirationSet) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV0ExpirationSet) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV0ExpirationSet) MapIterator() ipld.MapIterator

+ func (n MinerV0ExpirationSet) Representation() ipld.Node

+ type MinerV0Info = *_MinerV0Info

+ func (MinerV0Info) AsBool() (bool, error)

+ func (MinerV0Info) AsBytes() ([]byte, error)

+ func (MinerV0Info) AsFloat() (float64, error)

+ func (MinerV0Info) AsInt() (int64, error)

+ func (MinerV0Info) AsLink() (ipld.Link, error)

+ func (MinerV0Info) AsString() (string, error)

+ func (MinerV0Info) IsAbsent() bool

+ func (MinerV0Info) IsNull() bool

+ func (MinerV0Info) Kind() ipld.Kind

+ func (MinerV0Info) Length() int64

+ func (MinerV0Info) ListIterator() ipld.ListIterator

+ func (MinerV0Info) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV0Info) Prototype() ipld.NodePrototype

+ func (MinerV0Info) Type() schema.Type

+ func (n MinerV0Info) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV0Info) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV0Info) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV0Info) MapIterator() ipld.MapIterator

+ func (n MinerV0Info) Representation() ipld.Node

+ type MinerV0Partition = *_MinerV0Partition

+ func (MinerV0Partition) AsBool() (bool, error)

+ func (MinerV0Partition) AsBytes() ([]byte, error)

+ func (MinerV0Partition) AsFloat() (float64, error)

+ func (MinerV0Partition) AsInt() (int64, error)

+ func (MinerV0Partition) AsLink() (ipld.Link, error)

+ func (MinerV0Partition) AsString() (string, error)

+ func (MinerV0Partition) IsAbsent() bool

+ func (MinerV0Partition) IsNull() bool

+ func (MinerV0Partition) Kind() ipld.Kind

+ func (MinerV0Partition) Length() int64

+ func (MinerV0Partition) ListIterator() ipld.ListIterator

+ func (MinerV0Partition) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV0Partition) Prototype() ipld.NodePrototype

+ func (MinerV0Partition) Type() schema.Type

+ func (n MinerV0Partition) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV0Partition) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV0Partition) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV0Partition) MapIterator() ipld.MapIterator

+ func (n MinerV0Partition) Representation() ipld.Node

+ type MinerV0PowerPair = *_MinerV0PowerPair

+ func (MinerV0PowerPair) AsBool() (bool, error)

+ func (MinerV0PowerPair) AsBytes() ([]byte, error)

+ func (MinerV0PowerPair) AsFloat() (float64, error)

+ func (MinerV0PowerPair) AsInt() (int64, error)

+ func (MinerV0PowerPair) AsLink() (ipld.Link, error)

+ func (MinerV0PowerPair) AsString() (string, error)

+ func (MinerV0PowerPair) IsAbsent() bool

+ func (MinerV0PowerPair) IsNull() bool

+ func (MinerV0PowerPair) Kind() ipld.Kind

+ func (MinerV0PowerPair) Length() int64

+ func (MinerV0PowerPair) ListIterator() ipld.ListIterator

+ func (MinerV0PowerPair) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV0PowerPair) Prototype() ipld.NodePrototype

+ func (MinerV0PowerPair) Type() schema.Type

+ func (n MinerV0PowerPair) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV0PowerPair) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV0PowerPair) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV0PowerPair) MapIterator() ipld.MapIterator

+ func (n MinerV0PowerPair) Representation() ipld.Node

+ type MinerV0SectorOnChainInfo = *_MinerV0SectorOnChainInfo

+ func (MinerV0SectorOnChainInfo) AsBool() (bool, error)

+ func (MinerV0SectorOnChainInfo) AsBytes() ([]byte, error)

+ func (MinerV0SectorOnChainInfo) AsFloat() (float64, error)

+ func (MinerV0SectorOnChainInfo) AsInt() (int64, error)

+ func (MinerV0SectorOnChainInfo) AsLink() (ipld.Link, error)

+ func (MinerV0SectorOnChainInfo) AsString() (string, error)

+ func (MinerV0SectorOnChainInfo) IsAbsent() bool

+ func (MinerV0SectorOnChainInfo) IsNull() bool

+ func (MinerV0SectorOnChainInfo) Kind() ipld.Kind

+ func (MinerV0SectorOnChainInfo) Length() int64

+ func (MinerV0SectorOnChainInfo) ListIterator() ipld.ListIterator

+ func (MinerV0SectorOnChainInfo) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV0SectorOnChainInfo) Prototype() ipld.NodePrototype

+ func (MinerV0SectorOnChainInfo) Type() schema.Type

+ func (n MinerV0SectorOnChainInfo) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV0SectorOnChainInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV0SectorOnChainInfo) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV0SectorOnChainInfo) MapIterator() ipld.MapIterator

+ func (n MinerV0SectorOnChainInfo) Representation() ipld.Node

+ type MinerV0SectorPreCommitInfo = *_MinerV0SectorPreCommitInfo

+ func (MinerV0SectorPreCommitInfo) AsBool() (bool, error)

+ func (MinerV0SectorPreCommitInfo) AsBytes() ([]byte, error)

+ func (MinerV0SectorPreCommitInfo) AsFloat() (float64, error)

+ func (MinerV0SectorPreCommitInfo) AsInt() (int64, error)

+ func (MinerV0SectorPreCommitInfo) AsLink() (ipld.Link, error)

+ func (MinerV0SectorPreCommitInfo) AsString() (string, error)

+ func (MinerV0SectorPreCommitInfo) IsAbsent() bool

+ func (MinerV0SectorPreCommitInfo) IsNull() bool

+ func (MinerV0SectorPreCommitInfo) Kind() ipld.Kind

+ func (MinerV0SectorPreCommitInfo) Length() int64

+ func (MinerV0SectorPreCommitInfo) ListIterator() ipld.ListIterator

+ func (MinerV0SectorPreCommitInfo) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV0SectorPreCommitInfo) Prototype() ipld.NodePrototype

+ func (MinerV0SectorPreCommitInfo) Type() schema.Type

+ func (n MinerV0SectorPreCommitInfo) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV0SectorPreCommitInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV0SectorPreCommitInfo) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV0SectorPreCommitInfo) MapIterator() ipld.MapIterator

+ func (n MinerV0SectorPreCommitInfo) Representation() ipld.Node

+ type MinerV0SectorPreCommitOnChainInfo = *_MinerV0SectorPreCommitOnChainInfo

+ func (MinerV0SectorPreCommitOnChainInfo) AsBool() (bool, error)

+ func (MinerV0SectorPreCommitOnChainInfo) AsBytes() ([]byte, error)

+ func (MinerV0SectorPreCommitOnChainInfo) AsFloat() (float64, error)

+ func (MinerV0SectorPreCommitOnChainInfo) AsInt() (int64, error)

+ func (MinerV0SectorPreCommitOnChainInfo) AsLink() (ipld.Link, error)

+ func (MinerV0SectorPreCommitOnChainInfo) AsString() (string, error)

+ func (MinerV0SectorPreCommitOnChainInfo) IsAbsent() bool

+ func (MinerV0SectorPreCommitOnChainInfo) IsNull() bool

+ func (MinerV0SectorPreCommitOnChainInfo) Kind() ipld.Kind

+ func (MinerV0SectorPreCommitOnChainInfo) Length() int64

+ func (MinerV0SectorPreCommitOnChainInfo) ListIterator() ipld.ListIterator

+ func (MinerV0SectorPreCommitOnChainInfo) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV0SectorPreCommitOnChainInfo) Prototype() ipld.NodePrototype

+ func (MinerV0SectorPreCommitOnChainInfo) Type() schema.Type

+ func (n MinerV0SectorPreCommitOnChainInfo) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV0SectorPreCommitOnChainInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV0SectorPreCommitOnChainInfo) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV0SectorPreCommitOnChainInfo) MapIterator() ipld.MapIterator

+ func (n MinerV0SectorPreCommitOnChainInfo) Representation() ipld.Node

+ type MinerV0State = *_MinerV0State

+ func (MinerV0State) AsBool() (bool, error)

+ func (MinerV0State) AsBytes() ([]byte, error)

+ func (MinerV0State) AsFloat() (float64, error)

+ func (MinerV0State) AsInt() (int64, error)

+ func (MinerV0State) AsLink() (ipld.Link, error)

+ func (MinerV0State) AsString() (string, error)

+ func (MinerV0State) IsAbsent() bool

+ func (MinerV0State) IsNull() bool

+ func (MinerV0State) Kind() ipld.Kind

+ func (MinerV0State) Length() int64

+ func (MinerV0State) ListIterator() ipld.ListIterator

+ func (MinerV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV0State) Prototype() ipld.NodePrototype

+ func (MinerV0State) Type() schema.Type

+ func (n MinerV0State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV0State) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV0State) MapIterator() ipld.MapIterator

+ func (n MinerV0State) Representation() ipld.Node

+ type MinerV0VestingFund = *_MinerV0VestingFund

+ func (MinerV0VestingFund) AsBool() (bool, error)

+ func (MinerV0VestingFund) AsBytes() ([]byte, error)

+ func (MinerV0VestingFund) AsFloat() (float64, error)

+ func (MinerV0VestingFund) AsInt() (int64, error)

+ func (MinerV0VestingFund) AsLink() (ipld.Link, error)

+ func (MinerV0VestingFund) AsString() (string, error)

+ func (MinerV0VestingFund) IsAbsent() bool

+ func (MinerV0VestingFund) IsNull() bool

+ func (MinerV0VestingFund) Kind() ipld.Kind

+ func (MinerV0VestingFund) Length() int64

+ func (MinerV0VestingFund) ListIterator() ipld.ListIterator

+ func (MinerV0VestingFund) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV0VestingFund) Prototype() ipld.NodePrototype

+ func (MinerV0VestingFund) Type() schema.Type

+ func (n MinerV0VestingFund) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV0VestingFund) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV0VestingFund) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV0VestingFund) MapIterator() ipld.MapIterator

+ func (n MinerV0VestingFund) Representation() ipld.Node

+ type MinerV0VestingFunds = *_MinerV0VestingFunds

+ func (MinerV0VestingFunds) AsBool() (bool, error)

+ func (MinerV0VestingFunds) AsBytes() ([]byte, error)

+ func (MinerV0VestingFunds) AsFloat() (float64, error)

+ func (MinerV0VestingFunds) AsInt() (int64, error)

+ func (MinerV0VestingFunds) AsLink() (ipld.Link, error)

+ func (MinerV0VestingFunds) AsString() (string, error)

+ func (MinerV0VestingFunds) IsAbsent() bool

+ func (MinerV0VestingFunds) IsNull() bool

+ func (MinerV0VestingFunds) Kind() ipld.Kind

+ func (MinerV0VestingFunds) Length() int64

+ func (MinerV0VestingFunds) ListIterator() ipld.ListIterator

+ func (MinerV0VestingFunds) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV0VestingFunds) Prototype() ipld.NodePrototype

+ func (MinerV0VestingFunds) Type() schema.Type

+ func (n MinerV0VestingFunds) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV0VestingFunds) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV0VestingFunds) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV0VestingFunds) MapIterator() ipld.MapIterator

+ func (n MinerV0VestingFunds) Representation() ipld.Node

+ type MinerV0WorkerChangeKey = *_MinerV0WorkerChangeKey

+ func (MinerV0WorkerChangeKey) AsBool() (bool, error)

+ func (MinerV0WorkerChangeKey) AsBytes() ([]byte, error)

+ func (MinerV0WorkerChangeKey) AsFloat() (float64, error)

+ func (MinerV0WorkerChangeKey) AsInt() (int64, error)

+ func (MinerV0WorkerChangeKey) AsLink() (ipld.Link, error)

+ func (MinerV0WorkerChangeKey) AsString() (string, error)

+ func (MinerV0WorkerChangeKey) IsAbsent() bool

+ func (MinerV0WorkerChangeKey) IsNull() bool

+ func (MinerV0WorkerChangeKey) Kind() ipld.Kind

+ func (MinerV0WorkerChangeKey) Length() int64

+ func (MinerV0WorkerChangeKey) ListIterator() ipld.ListIterator

+ func (MinerV0WorkerChangeKey) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV0WorkerChangeKey) Prototype() ipld.NodePrototype

+ func (MinerV0WorkerChangeKey) Type() schema.Type

+ func (n MinerV0WorkerChangeKey) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV0WorkerChangeKey) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV0WorkerChangeKey) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV0WorkerChangeKey) MapIterator() ipld.MapIterator

+ func (n MinerV0WorkerChangeKey) Representation() ipld.Node

+ type MinerV2Deadline = *_MinerV2Deadline

+ func (MinerV2Deadline) AsBool() (bool, error)

+ func (MinerV2Deadline) AsBytes() ([]byte, error)

+ func (MinerV2Deadline) AsFloat() (float64, error)

+ func (MinerV2Deadline) AsInt() (int64, error)

+ func (MinerV2Deadline) AsLink() (ipld.Link, error)

+ func (MinerV2Deadline) AsString() (string, error)

+ func (MinerV2Deadline) IsAbsent() bool

+ func (MinerV2Deadline) IsNull() bool

+ func (MinerV2Deadline) Kind() ipld.Kind

+ func (MinerV2Deadline) Length() int64

+ func (MinerV2Deadline) ListIterator() ipld.ListIterator

+ func (MinerV2Deadline) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV2Deadline) Prototype() ipld.NodePrototype

+ func (MinerV2Deadline) Type() schema.Type

+ func (n MinerV2Deadline) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV2Deadline) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV2Deadline) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV2Deadline) MapIterator() ipld.MapIterator

+ func (n MinerV2Deadline) Representation() ipld.Node

+ type MinerV2Deadlines = *_MinerV2Deadlines

+ func (MinerV2Deadlines) AsBool() (bool, error)

+ func (MinerV2Deadlines) AsBytes() ([]byte, error)

+ func (MinerV2Deadlines) AsFloat() (float64, error)

+ func (MinerV2Deadlines) AsInt() (int64, error)

+ func (MinerV2Deadlines) AsLink() (ipld.Link, error)

+ func (MinerV2Deadlines) AsString() (string, error)

+ func (MinerV2Deadlines) IsAbsent() bool

+ func (MinerV2Deadlines) IsNull() bool

+ func (MinerV2Deadlines) Kind() ipld.Kind

+ func (MinerV2Deadlines) Length() int64

+ func (MinerV2Deadlines) ListIterator() ipld.ListIterator

+ func (MinerV2Deadlines) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV2Deadlines) Prototype() ipld.NodePrototype

+ func (MinerV2Deadlines) Type() schema.Type

+ func (n MinerV2Deadlines) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV2Deadlines) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV2Deadlines) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV2Deadlines) MapIterator() ipld.MapIterator

+ func (n MinerV2Deadlines) Representation() ipld.Node

+ type MinerV2Info = *_MinerV2Info

+ func (MinerV2Info) AsBool() (bool, error)

+ func (MinerV2Info) AsBytes() ([]byte, error)

+ func (MinerV2Info) AsFloat() (float64, error)

+ func (MinerV2Info) AsInt() (int64, error)

+ func (MinerV2Info) AsLink() (ipld.Link, error)

+ func (MinerV2Info) AsString() (string, error)

+ func (MinerV2Info) IsAbsent() bool

+ func (MinerV2Info) IsNull() bool

+ func (MinerV2Info) Kind() ipld.Kind

+ func (MinerV2Info) Length() int64

+ func (MinerV2Info) ListIterator() ipld.ListIterator

+ func (MinerV2Info) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV2Info) Prototype() ipld.NodePrototype

+ func (MinerV2Info) Type() schema.Type

+ func (n MinerV2Info) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV2Info) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV2Info) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV2Info) MapIterator() ipld.MapIterator

+ func (n MinerV2Info) Representation() ipld.Node

+ type MinerV2Partition = *_MinerV2Partition

+ func (MinerV2Partition) AsBool() (bool, error)

+ func (MinerV2Partition) AsBytes() ([]byte, error)

+ func (MinerV2Partition) AsFloat() (float64, error)

+ func (MinerV2Partition) AsInt() (int64, error)

+ func (MinerV2Partition) AsLink() (ipld.Link, error)

+ func (MinerV2Partition) AsString() (string, error)

+ func (MinerV2Partition) IsAbsent() bool

+ func (MinerV2Partition) IsNull() bool

+ func (MinerV2Partition) Kind() ipld.Kind

+ func (MinerV2Partition) Length() int64

+ func (MinerV2Partition) ListIterator() ipld.ListIterator

+ func (MinerV2Partition) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV2Partition) Prototype() ipld.NodePrototype

+ func (MinerV2Partition) Type() schema.Type

+ func (n MinerV2Partition) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV2Partition) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV2Partition) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV2Partition) MapIterator() ipld.MapIterator

+ func (n MinerV2Partition) Representation() ipld.Node

+ type MinerV2SectorOnChainInfo = *_MinerV2SectorOnChainInfo

+ func (MinerV2SectorOnChainInfo) AsBool() (bool, error)

+ func (MinerV2SectorOnChainInfo) AsBytes() ([]byte, error)

+ func (MinerV2SectorOnChainInfo) AsFloat() (float64, error)

+ func (MinerV2SectorOnChainInfo) AsInt() (int64, error)

+ func (MinerV2SectorOnChainInfo) AsLink() (ipld.Link, error)

+ func (MinerV2SectorOnChainInfo) AsString() (string, error)

+ func (MinerV2SectorOnChainInfo) IsAbsent() bool

+ func (MinerV2SectorOnChainInfo) IsNull() bool

+ func (MinerV2SectorOnChainInfo) Kind() ipld.Kind

+ func (MinerV2SectorOnChainInfo) Length() int64

+ func (MinerV2SectorOnChainInfo) ListIterator() ipld.ListIterator

+ func (MinerV2SectorOnChainInfo) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV2SectorOnChainInfo) Prototype() ipld.NodePrototype

+ func (MinerV2SectorOnChainInfo) Type() schema.Type

+ func (n MinerV2SectorOnChainInfo) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV2SectorOnChainInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV2SectorOnChainInfo) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV2SectorOnChainInfo) MapIterator() ipld.MapIterator

+ func (n MinerV2SectorOnChainInfo) Representation() ipld.Node

+ type MinerV2State = *_MinerV2State

+ func (MinerV2State) AsBool() (bool, error)

+ func (MinerV2State) AsBytes() ([]byte, error)

+ func (MinerV2State) AsFloat() (float64, error)

+ func (MinerV2State) AsInt() (int64, error)

+ func (MinerV2State) AsLink() (ipld.Link, error)

+ func (MinerV2State) AsString() (string, error)

+ func (MinerV2State) IsAbsent() bool

+ func (MinerV2State) IsNull() bool

+ func (MinerV2State) Kind() ipld.Kind

+ func (MinerV2State) Length() int64

+ func (MinerV2State) ListIterator() ipld.ListIterator

+ func (MinerV2State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV2State) Prototype() ipld.NodePrototype

+ func (MinerV2State) Type() schema.Type

+ func (n MinerV2State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV2State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV2State) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV2State) MapIterator() ipld.MapIterator

+ func (n MinerV2State) Representation() ipld.Node

+ type MinerV3Deadline = *_MinerV3Deadline

+ func (MinerV3Deadline) AsBool() (bool, error)

+ func (MinerV3Deadline) AsBytes() ([]byte, error)

+ func (MinerV3Deadline) AsFloat() (float64, error)

+ func (MinerV3Deadline) AsInt() (int64, error)

+ func (MinerV3Deadline) AsLink() (ipld.Link, error)

+ func (MinerV3Deadline) AsString() (string, error)

+ func (MinerV3Deadline) IsAbsent() bool

+ func (MinerV3Deadline) IsNull() bool

+ func (MinerV3Deadline) Kind() ipld.Kind

+ func (MinerV3Deadline) Length() int64

+ func (MinerV3Deadline) ListIterator() ipld.ListIterator

+ func (MinerV3Deadline) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV3Deadline) Prototype() ipld.NodePrototype

+ func (MinerV3Deadline) Type() schema.Type

+ func (n MinerV3Deadline) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV3Deadline) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV3Deadline) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV3Deadline) MapIterator() ipld.MapIterator

+ func (n MinerV3Deadline) Representation() ipld.Node

+ type MinerV3Deadlines = *_MinerV3Deadlines

+ func (MinerV3Deadlines) AsBool() (bool, error)

+ func (MinerV3Deadlines) AsBytes() ([]byte, error)

+ func (MinerV3Deadlines) AsFloat() (float64, error)

+ func (MinerV3Deadlines) AsInt() (int64, error)

+ func (MinerV3Deadlines) AsLink() (ipld.Link, error)

+ func (MinerV3Deadlines) AsString() (string, error)

+ func (MinerV3Deadlines) IsAbsent() bool

+ func (MinerV3Deadlines) IsNull() bool

+ func (MinerV3Deadlines) Kind() ipld.Kind

+ func (MinerV3Deadlines) Length() int64

+ func (MinerV3Deadlines) ListIterator() ipld.ListIterator

+ func (MinerV3Deadlines) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV3Deadlines) Prototype() ipld.NodePrototype

+ func (MinerV3Deadlines) Type() schema.Type

+ func (n MinerV3Deadlines) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV3Deadlines) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV3Deadlines) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV3Deadlines) MapIterator() ipld.MapIterator

+ func (n MinerV3Deadlines) Representation() ipld.Node

+ type MinerV3Partition = *_MinerV3Partition

+ func (MinerV3Partition) AsBool() (bool, error)

+ func (MinerV3Partition) AsBytes() ([]byte, error)

+ func (MinerV3Partition) AsFloat() (float64, error)

+ func (MinerV3Partition) AsInt() (int64, error)

+ func (MinerV3Partition) AsLink() (ipld.Link, error)

+ func (MinerV3Partition) AsString() (string, error)

+ func (MinerV3Partition) IsAbsent() bool

+ func (MinerV3Partition) IsNull() bool

+ func (MinerV3Partition) Kind() ipld.Kind

+ func (MinerV3Partition) Length() int64

+ func (MinerV3Partition) ListIterator() ipld.ListIterator

+ func (MinerV3Partition) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV3Partition) Prototype() ipld.NodePrototype

+ func (MinerV3Partition) Type() schema.Type

+ func (n MinerV3Partition) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV3Partition) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV3Partition) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV3Partition) MapIterator() ipld.MapIterator

+ func (n MinerV3Partition) Representation() ipld.Node

+ type MinerV3State = *_MinerV3State

+ func (MinerV3State) AsBool() (bool, error)

+ func (MinerV3State) AsBytes() ([]byte, error)

+ func (MinerV3State) AsFloat() (float64, error)

+ func (MinerV3State) AsInt() (int64, error)

+ func (MinerV3State) AsLink() (ipld.Link, error)

+ func (MinerV3State) AsString() (string, error)

+ func (MinerV3State) IsAbsent() bool

+ func (MinerV3State) IsNull() bool

+ func (MinerV3State) Kind() ipld.Kind

+ func (MinerV3State) Length() int64

+ func (MinerV3State) ListIterator() ipld.ListIterator

+ func (MinerV3State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV3State) Prototype() ipld.NodePrototype

+ func (MinerV3State) Type() schema.Type

+ func (n MinerV3State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV3State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV3State) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV3State) MapIterator() ipld.MapIterator

+ func (n MinerV3State) Representation() ipld.Node

+ type MinerV4State = *_MinerV4State

+ func (MinerV4State) AsBool() (bool, error)

+ func (MinerV4State) AsBytes() ([]byte, error)

+ func (MinerV4State) AsFloat() (float64, error)

+ func (MinerV4State) AsInt() (int64, error)

+ func (MinerV4State) AsLink() (ipld.Link, error)

+ func (MinerV4State) AsString() (string, error)

+ func (MinerV4State) IsAbsent() bool

+ func (MinerV4State) IsNull() bool

+ func (MinerV4State) Kind() ipld.Kind

+ func (MinerV4State) Length() int64

+ func (MinerV4State) ListIterator() ipld.ListIterator

+ func (MinerV4State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV4State) Prototype() ipld.NodePrototype

+ func (MinerV4State) Type() schema.Type

+ func (n MinerV4State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV4State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV4State) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV4State) MapIterator() ipld.MapIterator

+ func (n MinerV4State) Representation() ipld.Node

+ type MinerV5State = *_MinerV5State

+ func (MinerV5State) AsBool() (bool, error)

+ func (MinerV5State) AsBytes() ([]byte, error)

+ func (MinerV5State) AsFloat() (float64, error)

+ func (MinerV5State) AsInt() (int64, error)

+ func (MinerV5State) AsLink() (ipld.Link, error)

+ func (MinerV5State) AsString() (string, error)

+ func (MinerV5State) IsAbsent() bool

+ func (MinerV5State) IsNull() bool

+ func (MinerV5State) Kind() ipld.Kind

+ func (MinerV5State) Length() int64

+ func (MinerV5State) ListIterator() ipld.ListIterator

+ func (MinerV5State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MinerV5State) Prototype() ipld.NodePrototype

+ func (MinerV5State) Type() schema.Type

+ func (n MinerV5State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MinerV5State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MinerV5State) LookupByString(key string) (ipld.Node, error)

+ func (n MinerV5State) MapIterator() ipld.MapIterator

+ func (n MinerV5State) Representation() ipld.Node

+ type ModVerifyParams = *_ModVerifyParams

+ func (ModVerifyParams) AsBool() (bool, error)

+ func (ModVerifyParams) AsBytes() ([]byte, error)

+ func (ModVerifyParams) AsFloat() (float64, error)

+ func (ModVerifyParams) AsInt() (int64, error)

+ func (ModVerifyParams) AsLink() (ipld.Link, error)

+ func (ModVerifyParams) AsString() (string, error)

+ func (ModVerifyParams) IsAbsent() bool

+ func (ModVerifyParams) IsNull() bool

+ func (ModVerifyParams) Kind() ipld.Kind

+ func (ModVerifyParams) Length() int64

+ func (ModVerifyParams) ListIterator() ipld.ListIterator

+ func (ModVerifyParams) LookupByIndex(idx int64) (ipld.Node, error)

+ func (ModVerifyParams) Prototype() ipld.NodePrototype

+ func (ModVerifyParams) Type() schema.Type

+ func (n ModVerifyParams) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n ModVerifyParams) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n ModVerifyParams) LookupByString(key string) (ipld.Node, error)

+ func (n ModVerifyParams) MapIterator() ipld.MapIterator

+ func (n ModVerifyParams) Representation() ipld.Node

+ type Multiaddr = *_Multiaddr

+ func (Multiaddr) AsBool() (bool, error)

+ func (Multiaddr) AsFloat() (float64, error)

+ func (Multiaddr) AsInt() (int64, error)

+ func (Multiaddr) AsLink() (ipld.Link, error)

+ func (Multiaddr) AsString() (string, error)

+ func (Multiaddr) IsAbsent() bool

+ func (Multiaddr) IsNull() bool

+ func (Multiaddr) Kind() ipld.Kind

+ func (Multiaddr) Length() int64

+ func (Multiaddr) ListIterator() ipld.ListIterator

+ func (Multiaddr) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Multiaddr) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Multiaddr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Multiaddr) LookupByString(string) (ipld.Node, error)

+ func (Multiaddr) MapIterator() ipld.MapIterator

+ func (Multiaddr) Prototype() ipld.NodePrototype

+ func (Multiaddr) Type() schema.Type

+ func (n Multiaddr) AsBytes() ([]byte, error)

+ func (n Multiaddr) Bytes() []byte

+ func (n Multiaddr) Representation() ipld.Node

+ type Multimap__PowerV0CronEvent = *_Multimap__PowerV0CronEvent

+ func (Multimap__PowerV0CronEvent) AsBool() (bool, error)

+ func (Multimap__PowerV0CronEvent) AsBytes() ([]byte, error)

+ func (Multimap__PowerV0CronEvent) AsFloat() (float64, error)

+ func (Multimap__PowerV0CronEvent) AsInt() (int64, error)

+ func (Multimap__PowerV0CronEvent) AsLink() (ipld.Link, error)

+ func (Multimap__PowerV0CronEvent) AsString() (string, error)

+ func (Multimap__PowerV0CronEvent) IsAbsent() bool

+ func (Multimap__PowerV0CronEvent) IsNull() bool

+ func (Multimap__PowerV0CronEvent) Kind() ipld.Kind

+ func (Multimap__PowerV0CronEvent) ListIterator() ipld.ListIterator

+ func (Multimap__PowerV0CronEvent) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Multimap__PowerV0CronEvent) Prototype() ipld.NodePrototype

+ func (Multimap__PowerV0CronEvent) Type() schema.Type

+ func (n Multimap__PowerV0CronEvent) Iterator() *Multimap__PowerV0CronEvent__Itr

+ func (n Multimap__PowerV0CronEvent) Length() int64

+ func (n Multimap__PowerV0CronEvent) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Multimap__PowerV0CronEvent) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Multimap__PowerV0CronEvent) LookupByString(k string) (ipld.Node, error)

+ func (n Multimap__PowerV0CronEvent) MapIterator() ipld.MapIterator

+ func (n Multimap__PowerV0CronEvent) Representation() ipld.Node

+ type Multimap__PowerV0CronEvent__Itr struct

+ func (itr *Multimap__PowerV0CronEvent__Itr) Done() bool

+ func (itr *Multimap__PowerV0CronEvent__Itr) Next() (k String, v MaybeMap__PowerV0CronEvent)

+ type Multimap__PowerV3CronEvent = *_Multimap__PowerV3CronEvent

+ func (Multimap__PowerV3CronEvent) AsBool() (bool, error)

+ func (Multimap__PowerV3CronEvent) AsBytes() ([]byte, error)

+ func (Multimap__PowerV3CronEvent) AsFloat() (float64, error)

+ func (Multimap__PowerV3CronEvent) AsInt() (int64, error)

+ func (Multimap__PowerV3CronEvent) AsLink() (ipld.Link, error)

+ func (Multimap__PowerV3CronEvent) AsString() (string, error)

+ func (Multimap__PowerV3CronEvent) IsAbsent() bool

+ func (Multimap__PowerV3CronEvent) IsNull() bool

+ func (Multimap__PowerV3CronEvent) Kind() ipld.Kind

+ func (Multimap__PowerV3CronEvent) ListIterator() ipld.ListIterator

+ func (Multimap__PowerV3CronEvent) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Multimap__PowerV3CronEvent) Prototype() ipld.NodePrototype

+ func (Multimap__PowerV3CronEvent) Type() schema.Type

+ func (n Multimap__PowerV3CronEvent) Iterator() *Multimap__PowerV3CronEvent__Itr

+ func (n Multimap__PowerV3CronEvent) Length() int64

+ func (n Multimap__PowerV3CronEvent) LookupByNode(k ipld.Node) (ipld.Node, error)

+ func (n Multimap__PowerV3CronEvent) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n Multimap__PowerV3CronEvent) LookupByString(k string) (ipld.Node, error)

+ func (n Multimap__PowerV3CronEvent) MapIterator() ipld.MapIterator

+ func (n Multimap__PowerV3CronEvent) Representation() ipld.Node

+ type Multimap__PowerV3CronEvent__Itr struct

+ func (itr *Multimap__PowerV3CronEvent__Itr) Done() bool

+ func (itr *Multimap__PowerV3CronEvent__Itr) Next() (k String, v MaybeMap__PowerV3CronEvent)

+ type MultisigV0State = *_MultisigV0State

+ func (MultisigV0State) AsBool() (bool, error)

+ func (MultisigV0State) AsBytes() ([]byte, error)

+ func (MultisigV0State) AsFloat() (float64, error)

+ func (MultisigV0State) AsInt() (int64, error)

+ func (MultisigV0State) AsLink() (ipld.Link, error)

+ func (MultisigV0State) AsString() (string, error)

+ func (MultisigV0State) IsAbsent() bool

+ func (MultisigV0State) IsNull() bool

+ func (MultisigV0State) Kind() ipld.Kind

+ func (MultisigV0State) Length() int64

+ func (MultisigV0State) ListIterator() ipld.ListIterator

+ func (MultisigV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MultisigV0State) Prototype() ipld.NodePrototype

+ func (MultisigV0State) Type() schema.Type

+ func (n MultisigV0State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MultisigV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MultisigV0State) LookupByString(key string) (ipld.Node, error)

+ func (n MultisigV0State) MapIterator() ipld.MapIterator

+ func (n MultisigV0State) Representation() ipld.Node

+ type MultisigV0Transaction = *_MultisigV0Transaction

+ func (MultisigV0Transaction) AsBool() (bool, error)

+ func (MultisigV0Transaction) AsBytes() ([]byte, error)

+ func (MultisigV0Transaction) AsFloat() (float64, error)

+ func (MultisigV0Transaction) AsInt() (int64, error)

+ func (MultisigV0Transaction) AsLink() (ipld.Link, error)

+ func (MultisigV0Transaction) AsString() (string, error)

+ func (MultisigV0Transaction) IsAbsent() bool

+ func (MultisigV0Transaction) IsNull() bool

+ func (MultisigV0Transaction) Kind() ipld.Kind

+ func (MultisigV0Transaction) Length() int64

+ func (MultisigV0Transaction) ListIterator() ipld.ListIterator

+ func (MultisigV0Transaction) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MultisigV0Transaction) Prototype() ipld.NodePrototype

+ func (MultisigV0Transaction) Type() schema.Type

+ func (n MultisigV0Transaction) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MultisigV0Transaction) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MultisigV0Transaction) LookupByString(key string) (ipld.Node, error)

+ func (n MultisigV0Transaction) MapIterator() ipld.MapIterator

+ func (n MultisigV0Transaction) Representation() ipld.Node

+ type MultisigV3State = *_MultisigV3State

+ func (MultisigV3State) AsBool() (bool, error)

+ func (MultisigV3State) AsBytes() ([]byte, error)

+ func (MultisigV3State) AsFloat() (float64, error)

+ func (MultisigV3State) AsInt() (int64, error)

+ func (MultisigV3State) AsLink() (ipld.Link, error)

+ func (MultisigV3State) AsString() (string, error)

+ func (MultisigV3State) IsAbsent() bool

+ func (MultisigV3State) IsNull() bool

+ func (MultisigV3State) Kind() ipld.Kind

+ func (MultisigV3State) Length() int64

+ func (MultisigV3State) ListIterator() ipld.ListIterator

+ func (MultisigV3State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (MultisigV3State) Prototype() ipld.NodePrototype

+ func (MultisigV3State) Type() schema.Type

+ func (n MultisigV3State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n MultisigV3State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n MultisigV3State) LookupByString(key string) (ipld.Node, error)

+ func (n MultisigV3State) MapIterator() ipld.MapIterator

+ func (n MultisigV3State) Representation() ipld.Node

+ type PaddedPieceSize = *_PaddedPieceSize

+ func (PaddedPieceSize) AsBool() (bool, error)

+ func (PaddedPieceSize) AsBytes() ([]byte, error)

+ func (PaddedPieceSize) AsFloat() (float64, error)

+ func (PaddedPieceSize) AsLink() (ipld.Link, error)

+ func (PaddedPieceSize) AsString() (string, error)

+ func (PaddedPieceSize) IsAbsent() bool

+ func (PaddedPieceSize) IsNull() bool

+ func (PaddedPieceSize) Kind() ipld.Kind

+ func (PaddedPieceSize) Length() int64

+ func (PaddedPieceSize) ListIterator() ipld.ListIterator

+ func (PaddedPieceSize) LookupByIndex(idx int64) (ipld.Node, error)

+ func (PaddedPieceSize) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (PaddedPieceSize) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (PaddedPieceSize) LookupByString(string) (ipld.Node, error)

+ func (PaddedPieceSize) MapIterator() ipld.MapIterator

+ func (PaddedPieceSize) Prototype() ipld.NodePrototype

+ func (PaddedPieceSize) Type() schema.Type

+ func (n PaddedPieceSize) AsInt() (int64, error)

+ func (n PaddedPieceSize) Int() int64

+ func (n PaddedPieceSize) Representation() ipld.Node

+ type PaychV0LaneState = *_PaychV0LaneState

+ func (PaychV0LaneState) AsBool() (bool, error)

+ func (PaychV0LaneState) AsBytes() ([]byte, error)

+ func (PaychV0LaneState) AsFloat() (float64, error)

+ func (PaychV0LaneState) AsInt() (int64, error)

+ func (PaychV0LaneState) AsLink() (ipld.Link, error)

+ func (PaychV0LaneState) AsString() (string, error)

+ func (PaychV0LaneState) IsAbsent() bool

+ func (PaychV0LaneState) IsNull() bool

+ func (PaychV0LaneState) Kind() ipld.Kind

+ func (PaychV0LaneState) Length() int64

+ func (PaychV0LaneState) ListIterator() ipld.ListIterator

+ func (PaychV0LaneState) LookupByIndex(idx int64) (ipld.Node, error)

+ func (PaychV0LaneState) Prototype() ipld.NodePrototype

+ func (PaychV0LaneState) Type() schema.Type

+ func (n PaychV0LaneState) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n PaychV0LaneState) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n PaychV0LaneState) LookupByString(key string) (ipld.Node, error)

+ func (n PaychV0LaneState) MapIterator() ipld.MapIterator

+ func (n PaychV0LaneState) Representation() ipld.Node

+ type PaychV0State = *_PaychV0State

+ func (PaychV0State) AsBool() (bool, error)

+ func (PaychV0State) AsBytes() ([]byte, error)

+ func (PaychV0State) AsFloat() (float64, error)

+ func (PaychV0State) AsInt() (int64, error)

+ func (PaychV0State) AsLink() (ipld.Link, error)

+ func (PaychV0State) AsString() (string, error)

+ func (PaychV0State) IsAbsent() bool

+ func (PaychV0State) IsNull() bool

+ func (PaychV0State) Kind() ipld.Kind

+ func (PaychV0State) Length() int64

+ func (PaychV0State) ListIterator() ipld.ListIterator

+ func (PaychV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (PaychV0State) Prototype() ipld.NodePrototype

+ func (PaychV0State) Type() schema.Type

+ func (n PaychV0State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n PaychV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n PaychV0State) LookupByString(key string) (ipld.Node, error)

+ func (n PaychV0State) MapIterator() ipld.MapIterator

+ func (n PaychV0State) Representation() ipld.Node

+ type PaychV3State = *_PaychV3State

+ func (PaychV3State) AsBool() (bool, error)

+ func (PaychV3State) AsBytes() ([]byte, error)

+ func (PaychV3State) AsFloat() (float64, error)

+ func (PaychV3State) AsInt() (int64, error)

+ func (PaychV3State) AsLink() (ipld.Link, error)

+ func (PaychV3State) AsString() (string, error)

+ func (PaychV3State) IsAbsent() bool

+ func (PaychV3State) IsNull() bool

+ func (PaychV3State) Kind() ipld.Kind

+ func (PaychV3State) Length() int64

+ func (PaychV3State) ListIterator() ipld.ListIterator

+ func (PaychV3State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (PaychV3State) Prototype() ipld.NodePrototype

+ func (PaychV3State) Type() schema.Type

+ func (n PaychV3State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n PaychV3State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n PaychV3State) LookupByString(key string) (ipld.Node, error)

+ func (n PaychV3State) MapIterator() ipld.MapIterator

+ func (n PaychV3State) Representation() ipld.Node

+ type PeerID = *_PeerID

+ func (PeerID) AsBool() (bool, error)

+ func (PeerID) AsFloat() (float64, error)

+ func (PeerID) AsInt() (int64, error)

+ func (PeerID) AsLink() (ipld.Link, error)

+ func (PeerID) AsString() (string, error)

+ func (PeerID) IsAbsent() bool

+ func (PeerID) IsNull() bool

+ func (PeerID) Kind() ipld.Kind

+ func (PeerID) Length() int64

+ func (PeerID) ListIterator() ipld.ListIterator

+ func (PeerID) LookupByIndex(idx int64) (ipld.Node, error)

+ func (PeerID) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (PeerID) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (PeerID) LookupByString(string) (ipld.Node, error)

+ func (PeerID) MapIterator() ipld.MapIterator

+ func (PeerID) Prototype() ipld.NodePrototype

+ func (PeerID) Type() schema.Type

+ func (n PeerID) AsBytes() ([]byte, error)

+ func (n PeerID) Bytes() []byte

+ func (n PeerID) Representation() ipld.Node

+ type PoStProof = *_PoStProof

+ func (PoStProof) AsBool() (bool, error)

+ func (PoStProof) AsBytes() ([]byte, error)

+ func (PoStProof) AsFloat() (float64, error)

+ func (PoStProof) AsInt() (int64, error)

+ func (PoStProof) AsLink() (ipld.Link, error)

+ func (PoStProof) AsString() (string, error)

+ func (PoStProof) IsAbsent() bool

+ func (PoStProof) IsNull() bool

+ func (PoStProof) Kind() ipld.Kind

+ func (PoStProof) Length() int64

+ func (PoStProof) ListIterator() ipld.ListIterator

+ func (PoStProof) LookupByIndex(idx int64) (ipld.Node, error)

+ func (PoStProof) Prototype() ipld.NodePrototype

+ func (PoStProof) Type() schema.Type

+ func (n PoStProof) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n PoStProof) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n PoStProof) LookupByString(key string) (ipld.Node, error)

+ func (n PoStProof) MapIterator() ipld.MapIterator

+ func (n PoStProof) Representation() ipld.Node

+ type PowerV0Claim = *_PowerV0Claim

+ func (PowerV0Claim) AsBool() (bool, error)

+ func (PowerV0Claim) AsBytes() ([]byte, error)

+ func (PowerV0Claim) AsFloat() (float64, error)

+ func (PowerV0Claim) AsInt() (int64, error)

+ func (PowerV0Claim) AsLink() (ipld.Link, error)

+ func (PowerV0Claim) AsString() (string, error)

+ func (PowerV0Claim) IsAbsent() bool

+ func (PowerV0Claim) IsNull() bool

+ func (PowerV0Claim) Kind() ipld.Kind

+ func (PowerV0Claim) Length() int64

+ func (PowerV0Claim) ListIterator() ipld.ListIterator

+ func (PowerV0Claim) LookupByIndex(idx int64) (ipld.Node, error)

+ func (PowerV0Claim) Prototype() ipld.NodePrototype

+ func (PowerV0Claim) Type() schema.Type

+ func (n PowerV0Claim) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n PowerV0Claim) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n PowerV0Claim) LookupByString(key string) (ipld.Node, error)

+ func (n PowerV0Claim) MapIterator() ipld.MapIterator

+ func (n PowerV0Claim) Representation() ipld.Node

+ type PowerV0CronEvent = *_PowerV0CronEvent

+ func (PowerV0CronEvent) AsBool() (bool, error)

+ func (PowerV0CronEvent) AsBytes() ([]byte, error)

+ func (PowerV0CronEvent) AsFloat() (float64, error)

+ func (PowerV0CronEvent) AsInt() (int64, error)

+ func (PowerV0CronEvent) AsLink() (ipld.Link, error)

+ func (PowerV0CronEvent) AsString() (string, error)

+ func (PowerV0CronEvent) IsAbsent() bool

+ func (PowerV0CronEvent) IsNull() bool

+ func (PowerV0CronEvent) Kind() ipld.Kind

+ func (PowerV0CronEvent) Length() int64

+ func (PowerV0CronEvent) ListIterator() ipld.ListIterator

+ func (PowerV0CronEvent) LookupByIndex(idx int64) (ipld.Node, error)

+ func (PowerV0CronEvent) Prototype() ipld.NodePrototype

+ func (PowerV0CronEvent) Type() schema.Type

+ func (n PowerV0CronEvent) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n PowerV0CronEvent) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n PowerV0CronEvent) LookupByString(key string) (ipld.Node, error)

+ func (n PowerV0CronEvent) MapIterator() ipld.MapIterator

+ func (n PowerV0CronEvent) Representation() ipld.Node

+ type PowerV0State = *_PowerV0State

+ func (PowerV0State) AsBool() (bool, error)

+ func (PowerV0State) AsBytes() ([]byte, error)

+ func (PowerV0State) AsFloat() (float64, error)

+ func (PowerV0State) AsInt() (int64, error)

+ func (PowerV0State) AsLink() (ipld.Link, error)

+ func (PowerV0State) AsString() (string, error)

+ func (PowerV0State) IsAbsent() bool

+ func (PowerV0State) IsNull() bool

+ func (PowerV0State) Kind() ipld.Kind

+ func (PowerV0State) Length() int64

+ func (PowerV0State) ListIterator() ipld.ListIterator

+ func (PowerV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (PowerV0State) Prototype() ipld.NodePrototype

+ func (PowerV0State) Type() schema.Type

+ func (n PowerV0State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n PowerV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n PowerV0State) LookupByString(key string) (ipld.Node, error)

+ func (n PowerV0State) MapIterator() ipld.MapIterator

+ func (n PowerV0State) Representation() ipld.Node

+ type PowerV2Claim = *_PowerV2Claim

+ func (PowerV2Claim) AsBool() (bool, error)

+ func (PowerV2Claim) AsBytes() ([]byte, error)

+ func (PowerV2Claim) AsFloat() (float64, error)

+ func (PowerV2Claim) AsInt() (int64, error)

+ func (PowerV2Claim) AsLink() (ipld.Link, error)

+ func (PowerV2Claim) AsString() (string, error)

+ func (PowerV2Claim) IsAbsent() bool

+ func (PowerV2Claim) IsNull() bool

+ func (PowerV2Claim) Kind() ipld.Kind

+ func (PowerV2Claim) Length() int64

+ func (PowerV2Claim) ListIterator() ipld.ListIterator

+ func (PowerV2Claim) LookupByIndex(idx int64) (ipld.Node, error)

+ func (PowerV2Claim) Prototype() ipld.NodePrototype

+ func (PowerV2Claim) Type() schema.Type

+ func (n PowerV2Claim) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n PowerV2Claim) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n PowerV2Claim) LookupByString(key string) (ipld.Node, error)

+ func (n PowerV2Claim) MapIterator() ipld.MapIterator

+ func (n PowerV2Claim) Representation() ipld.Node

+ type PowerV2State = *_PowerV2State

+ func (PowerV2State) AsBool() (bool, error)

+ func (PowerV2State) AsBytes() ([]byte, error)

+ func (PowerV2State) AsFloat() (float64, error)

+ func (PowerV2State) AsInt() (int64, error)

+ func (PowerV2State) AsLink() (ipld.Link, error)

+ func (PowerV2State) AsString() (string, error)

+ func (PowerV2State) IsAbsent() bool

+ func (PowerV2State) IsNull() bool

+ func (PowerV2State) Kind() ipld.Kind

+ func (PowerV2State) Length() int64

+ func (PowerV2State) ListIterator() ipld.ListIterator

+ func (PowerV2State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (PowerV2State) Prototype() ipld.NodePrototype

+ func (PowerV2State) Type() schema.Type

+ func (n PowerV2State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n PowerV2State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n PowerV2State) LookupByString(key string) (ipld.Node, error)

+ func (n PowerV2State) MapIterator() ipld.MapIterator

+ func (n PowerV2State) Representation() ipld.Node

+ type PowerV3State = *_PowerV3State

+ func (PowerV3State) AsBool() (bool, error)

+ func (PowerV3State) AsBytes() ([]byte, error)

+ func (PowerV3State) AsFloat() (float64, error)

+ func (PowerV3State) AsInt() (int64, error)

+ func (PowerV3State) AsLink() (ipld.Link, error)

+ func (PowerV3State) AsString() (string, error)

+ func (PowerV3State) IsAbsent() bool

+ func (PowerV3State) IsNull() bool

+ func (PowerV3State) Kind() ipld.Kind

+ func (PowerV3State) Length() int64

+ func (PowerV3State) ListIterator() ipld.ListIterator

+ func (PowerV3State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (PowerV3State) Prototype() ipld.NodePrototype

+ func (PowerV3State) Type() schema.Type

+ func (n PowerV3State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n PowerV3State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n PowerV3State) LookupByString(key string) (ipld.Node, error)

+ func (n PowerV3State) MapIterator() ipld.MapIterator

+ func (n PowerV3State) Representation() ipld.Node

+ type RawAddress = *_RawAddress

+ func (RawAddress) AsBool() (bool, error)

+ func (RawAddress) AsBytes() ([]byte, error)

+ func (RawAddress) AsFloat() (float64, error)

+ func (RawAddress) AsInt() (int64, error)

+ func (RawAddress) AsLink() (ipld.Link, error)

+ func (RawAddress) IsAbsent() bool

+ func (RawAddress) IsNull() bool

+ func (RawAddress) Kind() ipld.Kind

+ func (RawAddress) Length() int64

+ func (RawAddress) ListIterator() ipld.ListIterator

+ func (RawAddress) LookupByIndex(idx int64) (ipld.Node, error)

+ func (RawAddress) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (RawAddress) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (RawAddress) LookupByString(string) (ipld.Node, error)

+ func (RawAddress) MapIterator() ipld.MapIterator

+ func (RawAddress) Prototype() ipld.NodePrototype

+ func (RawAddress) Type() schema.Type

+ func (n RawAddress) AsString() (string, error)

+ func (n RawAddress) Representation() ipld.Node

+ func (n RawAddress) String() string

+ type RegisteredSealProof = *_RegisteredSealProof

+ func (RegisteredSealProof) AsBool() (bool, error)

+ func (RegisteredSealProof) AsBytes() ([]byte, error)

+ func (RegisteredSealProof) AsFloat() (float64, error)

+ func (RegisteredSealProof) AsInt() (int64, error)

+ func (RegisteredSealProof) AsString() (string, error)

+ func (RegisteredSealProof) IsAbsent() bool

+ func (RegisteredSealProof) IsNull() bool

+ func (RegisteredSealProof) Kind() ipld.Kind

+ func (RegisteredSealProof) Length() int64

+ func (RegisteredSealProof) ListIterator() ipld.ListIterator

+ func (RegisteredSealProof) LookupByIndex(idx int64) (ipld.Node, error)

+ func (RegisteredSealProof) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (RegisteredSealProof) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (RegisteredSealProof) LookupByString(string) (ipld.Node, error)

+ func (RegisteredSealProof) MapIterator() ipld.MapIterator

+ func (RegisteredSealProof) Prototype() ipld.NodePrototype

+ func (RegisteredSealProof) Type() schema.Type

+ func (n RegisteredSealProof) AsLink() (ipld.Link, error)

+ func (n RegisteredSealProof) Link() ipld.Link

+ func (n RegisteredSealProof) Representation() ipld.Node

+ type RewardV0State = *_RewardV0State

+ func (RewardV0State) AsBool() (bool, error)

+ func (RewardV0State) AsBytes() ([]byte, error)

+ func (RewardV0State) AsFloat() (float64, error)

+ func (RewardV0State) AsInt() (int64, error)

+ func (RewardV0State) AsLink() (ipld.Link, error)

+ func (RewardV0State) AsString() (string, error)

+ func (RewardV0State) IsAbsent() bool

+ func (RewardV0State) IsNull() bool

+ func (RewardV0State) Kind() ipld.Kind

+ func (RewardV0State) Length() int64

+ func (RewardV0State) ListIterator() ipld.ListIterator

+ func (RewardV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (RewardV0State) Prototype() ipld.NodePrototype

+ func (RewardV0State) Type() schema.Type

+ func (n RewardV0State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n RewardV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n RewardV0State) LookupByString(key string) (ipld.Node, error)

+ func (n RewardV0State) MapIterator() ipld.MapIterator

+ func (n RewardV0State) Representation() ipld.Node

+ type RewardV2State = *_RewardV2State

+ func (RewardV2State) AsBool() (bool, error)

+ func (RewardV2State) AsBytes() ([]byte, error)

+ func (RewardV2State) AsFloat() (float64, error)

+ func (RewardV2State) AsInt() (int64, error)

+ func (RewardV2State) AsLink() (ipld.Link, error)

+ func (RewardV2State) AsString() (string, error)

+ func (RewardV2State) IsAbsent() bool

+ func (RewardV2State) IsNull() bool

+ func (RewardV2State) Kind() ipld.Kind

+ func (RewardV2State) Length() int64

+ func (RewardV2State) ListIterator() ipld.ListIterator

+ func (RewardV2State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (RewardV2State) Prototype() ipld.NodePrototype

+ func (RewardV2State) Type() schema.Type

+ func (n RewardV2State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n RewardV2State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n RewardV2State) LookupByString(key string) (ipld.Node, error)

+ func (n RewardV2State) MapIterator() ipld.MapIterator

+ func (n RewardV2State) Representation() ipld.Node

+ type SealVerifyInfo = *_SealVerifyInfo

+ func (SealVerifyInfo) AsBool() (bool, error)

+ func (SealVerifyInfo) AsBytes() ([]byte, error)

+ func (SealVerifyInfo) AsFloat() (float64, error)

+ func (SealVerifyInfo) AsInt() (int64, error)

+ func (SealVerifyInfo) AsLink() (ipld.Link, error)

+ func (SealVerifyInfo) AsString() (string, error)

+ func (SealVerifyInfo) IsAbsent() bool

+ func (SealVerifyInfo) IsNull() bool

+ func (SealVerifyInfo) Kind() ipld.Kind

+ func (SealVerifyInfo) Length() int64

+ func (SealVerifyInfo) ListIterator() ipld.ListIterator

+ func (SealVerifyInfo) LookupByIndex(idx int64) (ipld.Node, error)

+ func (SealVerifyInfo) Prototype() ipld.NodePrototype

+ func (SealVerifyInfo) Type() schema.Type

+ func (n SealVerifyInfo) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n SealVerifyInfo) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n SealVerifyInfo) LookupByString(key string) (ipld.Node, error)

+ func (n SealVerifyInfo) MapIterator() ipld.MapIterator

+ func (n SealVerifyInfo) Representation() ipld.Node

+ type SectorDataSpec = *_SectorDataSpec

+ func (SectorDataSpec) AsBool() (bool, error)

+ func (SectorDataSpec) AsBytes() ([]byte, error)

+ func (SectorDataSpec) AsFloat() (float64, error)

+ func (SectorDataSpec) AsInt() (int64, error)

+ func (SectorDataSpec) AsLink() (ipld.Link, error)

+ func (SectorDataSpec) AsString() (string, error)

+ func (SectorDataSpec) IsAbsent() bool

+ func (SectorDataSpec) IsNull() bool

+ func (SectorDataSpec) Kind() ipld.Kind

+ func (SectorDataSpec) Length() int64

+ func (SectorDataSpec) ListIterator() ipld.ListIterator

+ func (SectorDataSpec) LookupByIndex(idx int64) (ipld.Node, error)

+ func (SectorDataSpec) Prototype() ipld.NodePrototype

+ func (SectorDataSpec) Type() schema.Type

+ func (n SectorDataSpec) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n SectorDataSpec) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n SectorDataSpec) LookupByString(key string) (ipld.Node, error)

+ func (n SectorDataSpec) MapIterator() ipld.MapIterator

+ func (n SectorDataSpec) Representation() ipld.Node

+ type SectorNumber = *_SectorNumber

+ func (SectorNumber) AsBool() (bool, error)

+ func (SectorNumber) AsBytes() ([]byte, error)

+ func (SectorNumber) AsFloat() (float64, error)

+ func (SectorNumber) AsLink() (ipld.Link, error)

+ func (SectorNumber) AsString() (string, error)

+ func (SectorNumber) IsAbsent() bool

+ func (SectorNumber) IsNull() bool

+ func (SectorNumber) Kind() ipld.Kind

+ func (SectorNumber) Length() int64

+ func (SectorNumber) ListIterator() ipld.ListIterator

+ func (SectorNumber) LookupByIndex(idx int64) (ipld.Node, error)

+ func (SectorNumber) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (SectorNumber) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (SectorNumber) LookupByString(string) (ipld.Node, error)

+ func (SectorNumber) MapIterator() ipld.MapIterator

+ func (SectorNumber) Prototype() ipld.NodePrototype

+ func (SectorNumber) Type() schema.Type

+ func (n SectorNumber) AsInt() (int64, error)

+ func (n SectorNumber) Int() int64

+ func (n SectorNumber) Representation() ipld.Node

+ type SectorSize = *_SectorSize

+ func (SectorSize) AsBool() (bool, error)

+ func (SectorSize) AsBytes() ([]byte, error)

+ func (SectorSize) AsFloat() (float64, error)

+ func (SectorSize) AsLink() (ipld.Link, error)

+ func (SectorSize) AsString() (string, error)

+ func (SectorSize) IsAbsent() bool

+ func (SectorSize) IsNull() bool

+ func (SectorSize) Kind() ipld.Kind

+ func (SectorSize) Length() int64

+ func (SectorSize) ListIterator() ipld.ListIterator

+ func (SectorSize) LookupByIndex(idx int64) (ipld.Node, error)

+ func (SectorSize) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (SectorSize) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (SectorSize) LookupByString(string) (ipld.Node, error)

+ func (SectorSize) MapIterator() ipld.MapIterator

+ func (SectorSize) Prototype() ipld.NodePrototype

+ func (SectorSize) Type() schema.Type

+ func (n SectorSize) AsInt() (int64, error)

+ func (n SectorSize) Int() int64

+ func (n SectorSize) Representation() ipld.Node

+ type Signature = *_Signature

+ func (Signature) AsBool() (bool, error)

+ func (Signature) AsFloat() (float64, error)

+ func (Signature) AsInt() (int64, error)

+ func (Signature) AsLink() (ipld.Link, error)

+ func (Signature) AsString() (string, error)

+ func (Signature) IsAbsent() bool

+ func (Signature) IsNull() bool

+ func (Signature) Kind() ipld.Kind

+ func (Signature) Length() int64

+ func (Signature) ListIterator() ipld.ListIterator

+ func (Signature) LookupByIndex(idx int64) (ipld.Node, error)

+ func (Signature) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (Signature) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (Signature) LookupByString(string) (ipld.Node, error)

+ func (Signature) MapIterator() ipld.MapIterator

+ func (Signature) Prototype() ipld.NodePrototype

+ func (Signature) Type() schema.Type

+ func (n Signature) AsBytes() ([]byte, error)

+ func (n Signature) Bytes() []byte

+ func (n Signature) Representation() ipld.Node

+ type SignedVoucher = *_SignedVoucher

+ func (SignedVoucher) AsBool() (bool, error)

+ func (SignedVoucher) AsBytes() ([]byte, error)

+ func (SignedVoucher) AsFloat() (float64, error)

+ func (SignedVoucher) AsInt() (int64, error)

+ func (SignedVoucher) AsLink() (ipld.Link, error)

+ func (SignedVoucher) AsString() (string, error)

+ func (SignedVoucher) IsAbsent() bool

+ func (SignedVoucher) IsNull() bool

+ func (SignedVoucher) Kind() ipld.Kind

+ func (SignedVoucher) Length() int64

+ func (SignedVoucher) ListIterator() ipld.ListIterator

+ func (SignedVoucher) LookupByIndex(idx int64) (ipld.Node, error)

+ func (SignedVoucher) Prototype() ipld.NodePrototype

+ func (SignedVoucher) Type() schema.Type

+ func (n SignedVoucher) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n SignedVoucher) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n SignedVoucher) LookupByString(key string) (ipld.Node, error)

+ func (n SignedVoucher) MapIterator() ipld.MapIterator

+ func (n SignedVoucher) Representation() ipld.Node

+ type String = *_String

+ func (String) AsBool() (bool, error)

+ func (String) AsBytes() ([]byte, error)

+ func (String) AsFloat() (float64, error)

+ func (String) AsInt() (int64, error)

+ func (String) AsLink() (ipld.Link, error)

+ func (String) IsAbsent() bool

+ func (String) IsNull() bool

+ func (String) Kind() ipld.Kind

+ func (String) Length() int64

+ func (String) ListIterator() ipld.ListIterator

+ func (String) LookupByIndex(idx int64) (ipld.Node, error)

+ func (String) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (String) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (String) LookupByString(string) (ipld.Node, error)

+ func (String) MapIterator() ipld.MapIterator

+ func (String) Prototype() ipld.NodePrototype

+ func (String) Type() schema.Type

+ func (n String) AsString() (string, error)

+ func (n String) Representation() ipld.Node

+ func (n String) String() string

+ type UnpaddedPieceSize = *_UnpaddedPieceSize

+ func (UnpaddedPieceSize) AsBool() (bool, error)

+ func (UnpaddedPieceSize) AsBytes() ([]byte, error)

+ func (UnpaddedPieceSize) AsFloat() (float64, error)

+ func (UnpaddedPieceSize) AsLink() (ipld.Link, error)

+ func (UnpaddedPieceSize) AsString() (string, error)

+ func (UnpaddedPieceSize) IsAbsent() bool

+ func (UnpaddedPieceSize) IsNull() bool

+ func (UnpaddedPieceSize) Kind() ipld.Kind

+ func (UnpaddedPieceSize) Length() int64

+ func (UnpaddedPieceSize) ListIterator() ipld.ListIterator

+ func (UnpaddedPieceSize) LookupByIndex(idx int64) (ipld.Node, error)

+ func (UnpaddedPieceSize) LookupByNode(ipld.Node) (ipld.Node, error)

+ func (UnpaddedPieceSize) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (UnpaddedPieceSize) LookupByString(string) (ipld.Node, error)

+ func (UnpaddedPieceSize) MapIterator() ipld.MapIterator

+ func (UnpaddedPieceSize) Prototype() ipld.NodePrototype

+ func (UnpaddedPieceSize) Type() schema.Type

+ func (n UnpaddedPieceSize) AsInt() (int64, error)

+ func (n UnpaddedPieceSize) Int() int64

+ func (n UnpaddedPieceSize) Representation() ipld.Node

+ type V0FilterEstimate = *_V0FilterEstimate

+ func (V0FilterEstimate) AsBool() (bool, error)

+ func (V0FilterEstimate) AsBytes() ([]byte, error)

+ func (V0FilterEstimate) AsFloat() (float64, error)

+ func (V0FilterEstimate) AsInt() (int64, error)

+ func (V0FilterEstimate) AsLink() (ipld.Link, error)

+ func (V0FilterEstimate) AsString() (string, error)

+ func (V0FilterEstimate) IsAbsent() bool

+ func (V0FilterEstimate) IsNull() bool

+ func (V0FilterEstimate) Kind() ipld.Kind

+ func (V0FilterEstimate) Length() int64

+ func (V0FilterEstimate) ListIterator() ipld.ListIterator

+ func (V0FilterEstimate) LookupByIndex(idx int64) (ipld.Node, error)

+ func (V0FilterEstimate) Prototype() ipld.NodePrototype

+ func (V0FilterEstimate) Type() schema.Type

+ func (n V0FilterEstimate) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n V0FilterEstimate) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n V0FilterEstimate) LookupByString(key string) (ipld.Node, error)

+ func (n V0FilterEstimate) MapIterator() ipld.MapIterator

+ func (n V0FilterEstimate) Representation() ipld.Node

+ type VerifregV0State = *_VerifregV0State

+ func (VerifregV0State) AsBool() (bool, error)

+ func (VerifregV0State) AsBytes() ([]byte, error)

+ func (VerifregV0State) AsFloat() (float64, error)

+ func (VerifregV0State) AsInt() (int64, error)

+ func (VerifregV0State) AsLink() (ipld.Link, error)

+ func (VerifregV0State) AsString() (string, error)

+ func (VerifregV0State) IsAbsent() bool

+ func (VerifregV0State) IsNull() bool

+ func (VerifregV0State) Kind() ipld.Kind

+ func (VerifregV0State) Length() int64

+ func (VerifregV0State) ListIterator() ipld.ListIterator

+ func (VerifregV0State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (VerifregV0State) Prototype() ipld.NodePrototype

+ func (VerifregV0State) Type() schema.Type

+ func (n VerifregV0State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n VerifregV0State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n VerifregV0State) LookupByString(key string) (ipld.Node, error)

+ func (n VerifregV0State) MapIterator() ipld.MapIterator

+ func (n VerifregV0State) Representation() ipld.Node

+ type VerifregV3State = *_VerifregV3State

+ func (VerifregV3State) AsBool() (bool, error)

+ func (VerifregV3State) AsBytes() ([]byte, error)

+ func (VerifregV3State) AsFloat() (float64, error)

+ func (VerifregV3State) AsInt() (int64, error)

+ func (VerifregV3State) AsLink() (ipld.Link, error)

+ func (VerifregV3State) AsString() (string, error)

+ func (VerifregV3State) IsAbsent() bool

+ func (VerifregV3State) IsNull() bool

+ func (VerifregV3State) Kind() ipld.Kind

+ func (VerifregV3State) Length() int64

+ func (VerifregV3State) ListIterator() ipld.ListIterator

+ func (VerifregV3State) LookupByIndex(idx int64) (ipld.Node, error)

+ func (VerifregV3State) Prototype() ipld.NodePrototype

+ func (VerifregV3State) Type() schema.Type

+ func (n VerifregV3State) LookupByNode(key ipld.Node) (ipld.Node, error)

+ func (n VerifregV3State) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)

+ func (n VerifregV3State) LookupByString(key string) (ipld.Node, error)

+ func (n VerifregV3State) MapIterator() ipld.MapIterator

+ func (n VerifregV3State) Representation() ipld.Node