lib

var AccountV0State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "AccountV0State",
	Fields: graphql.Fields{
		"Address": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: AccountV0State__Address__resolve,
		},
	},
})

var ActorID__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "ActorID",
	Description:  "ActorID",
	Serialize:    ActorID__type__serialize,
	ParseValue:   ActorID__type__parse,
	ParseLiteral: ActorID__type__parseLiteral,
})

var Address__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "Address",
	Description:  "Address",
	Serialize:    Address__type__serialize,
	ParseValue:   Address__type__parse,
	ParseLiteral: Address__type__parseLiteral,
})

var Any__type = graphql.NewUnion(graphql.UnionConfig{
	Name: "Any",
	Types: []*graphql.Object{

		union__Any__Bool,

		union__Any__Int,

		union__Any__Float,

		union__Any__String,

		union__Any__Bytes,

		union__Any__Map,

		union__Any__List,

		union__Any__Link,
	},
	ResolveType: func(p graphql.ResolveTypeParams) *graphql.Object {
		if node, ok := p.Value.(ipld.Node); ok {
			switch node.Prototype() {

			case types.Type.Bool:
				fallthrough
			case types.Type.Bool__Repr:
				return union__Any__Bool

			case types.Type.Int:
				fallthrough
			case types.Type.Int__Repr:
				return union__Any__Int

			case types.Type.Float:
				fallthrough
			case types.Type.Float__Repr:
				return union__Any__Float

			case types.Type.String:
				fallthrough
			case types.Type.String__Repr:
				return union__Any__String

			case types.Type.Bytes:
				fallthrough
			case types.Type.Bytes__Repr:
				return union__Any__Bytes

			case types.Type.Map:
				fallthrough
			case types.Type.Map__Repr:
				return union__Any__Map

			case types.Type.List:
				fallthrough
			case types.Type.List__Repr:
				return union__Any__List

			case types.Type.Link:
				fallthrough
			case types.Type.Link__Repr:
				return union__Any__Link

			}
		}
		fmt.Printf("Actual type %T: %v not in union\n", p.Value, p.Value)
		return nil
	},
})

var ApplyRewardParams__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "ApplyRewardParams",
	Fields: graphql.Fields{
		"Reward": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: ApplyRewardParams__Reward__resolve,
		},
		"Penalty": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: ApplyRewardParams__Penalty__resolve,
		},
	},
})

var BigInt__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "BigInt",
	Description:  "BigInt",
	Serialize:    BigInt__type__serialize,
	ParseValue:   BigInt__type__parse,
	ParseLiteral: BigInt__type__parseLiteral,
})

var BitField__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "BitField",
	Description:  "BitField",
	Serialize:    BitField__type__serialize,
	ParseValue:   BitField__type__parse,
	ParseLiteral: BitField__type__parseLiteral,
})

var Bytes__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "Bytes",
	Description:  "Bytes",
	Serialize:    Bytes__type__serialize,
	ParseValue:   Bytes__type__parse,
	ParseLiteral: Bytes__type__parseLiteral,
})

var ChainEpoch__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "ChainEpoch",
	Description:  "ChainEpoch",
	Serialize:    ChainEpoch__type__serialize,
	ParseValue:   ChainEpoch__type__parse,
	ParseLiteral: ChainEpoch__type__parseLiteral,
})

var CidString__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "CidString",
	Description:  "CidString",
	Serialize:    CidString__type__serialize,
	ParseValue:   CidString__type__parse,
	ParseLiteral: CidString__type__parseLiteral,
})

var CronV0Entry__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "CronV0Entry",
	Fields: graphql.Fields{
		"Receiver": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: CronV0Entry__Receiver__resolve,
		},
		"MethodNum": &graphql.Field{

			Type: graphql.NewNonNull(MethodNum__type),

			Resolve: CronV0Entry__MethodNum__resolve,
		},
	},
})

var CronV0State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "CronV0State",
	Fields: graphql.Fields{
		"Entries": &graphql.Field{

			Type: graphql.NewNonNull(List__CronV0Entry__type),

			Resolve: CronV0State__Entries__resolve,
		},
	},
})

var DealID__type = graphql.NewScalar(graphql.ScalarConfig{
	Name:         "DealID",
	Description:  "DealID",
	Serialize:    DealID__type__serialize,
	ParseValue:   DealID__type__parse,
	ParseLiteral: DealID__type__parseLiteral,
})

var InitV0State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "InitV0State",
	Fields: graphql.Fields{
		"AddressMap": &graphql.Field{

			Type: graphql.NewNonNull(Map__ActorID__type),

			Resolve: InitV0State__AddressMap__resolve,
		},
		"NextID": &graphql.Field{

			Type: graphql.NewNonNull(ActorID__type),

			Resolve: InitV0State__NextID__resolve,
		},
		"NetworkName": &graphql.Field{

			Type: graphql.NewNonNull(graphql.String),

			Resolve: InitV0State__NetworkName__resolve,
		},
	},
})

var InitV3State__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "InitV3State",
	Fields: graphql.Fields{
		"AddressMap": &graphql.Field{

			Type: graphql.NewNonNull(Map__V3ActorID__type),

			Resolve: InitV3State__AddressMap__resolve,
		},
		"NextID": &graphql.Field{

			Type: graphql.NewNonNull(ActorID__type),

			Resolve: InitV3State__NextID__resolve,
		},
		"NetworkName": &graphql.Field{

			Type: graphql.NewNonNull(graphql.String),

			Resolve: InitV3State__NetworkName__resolve,
		},
	},
})

var List__Address__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__Address",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: Address__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Address)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Address__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Address)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(Address__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Address)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Address)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__ClientDealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__ClientDealProposal",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketClientDealProposal__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__ClientDealProposal)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MarketClientDealProposal__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__ClientDealProposal)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MarketClientDealProposal__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__ClientDealProposal)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__ClientDealProposal)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__CronV0Entry__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__CronV0Entry",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: CronV0Entry__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__CronV0Entry)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(CronV0Entry__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__CronV0Entry)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(CronV0Entry__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__CronV0Entry)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__CronV0Entry)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__DealID__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__DealID",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: DealID__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__DealID)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(DealID__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__DealID)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(DealID__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__DealID)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__DealID)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__LinkLotusMessage__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__LinkLotusMessage",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: LotusMessage__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LinkLotusMessage)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				if err != nil {
					return nil, err
				}
				targetCid, err := out.AsLink()
				if err != nil {
					return nil, err
				}

				var node ipld.Node

				if cl, ok := targetCid.(cidlink.Link); ok {
					v := p.Context.Value(nodeLoaderCtxKey)
					if v == nil {
						return cl.Cid, nil
					}
					loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) (ipld.Node, error))
					if !ok {
						return nil, errInvalidLoader
					}

					builder := types.Type.LotusMessage__Repr.NewBuilder()
					n, err := loader(p.Context, cl, builder)
					if err != nil {
						return nil, err
					}
					node = n
				} else {
					return nil, errInvalidLink
				}

				return node, nil

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(LotusMessage__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LinkLotusMessage)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					targetCid, err := node.AsLink()
					if err != nil {
						return nil, err
					}

					if cl, ok := targetCid.(cidlink.Link); ok {
						v := p.Context.Value(nodeLoaderCtxKey)
						if v == nil {
							return cl.Cid, nil
						}
						loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) (ipld.Node, error))
						if !ok {
							return nil, errInvalidLoader
						}

						builder := types.Type.LotusMessage__Repr.NewBuilder()
						n, err := loader(p.Context, cl, builder)
						if err != nil {
							return nil, err
						}
						node = n
					} else {
						return nil, errInvalidLink
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(LotusMessage__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LinkLotusMessage)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					targetCid, err := node.AsLink()
					if err != nil {
						return nil, err
					}

					if cl, ok := targetCid.(cidlink.Link); ok {
						v := p.Context.Value(nodeLoaderCtxKey)
						if v == nil {
							return cl.Cid, nil
						}
						loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) (ipld.Node, error))
						if !ok {
							return nil, errInvalidLoader
						}

						builder := types.Type.LotusMessage__Repr.NewBuilder()
						n, err := loader(p.Context, cl, builder)
						if err != nil {
							return nil, err
						}
						node = n
					} else {
						return nil, errInvalidLink
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LinkLotusMessage)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__Link__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__Link",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: graphql.ID,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Link)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(graphql.ID),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Link)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(graphql.ID),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Link)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Link)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__LotusBeaconEntry__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__LotusBeaconEntry",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: LotusBeaconEntry__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LotusBeaconEntry)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(LotusBeaconEntry__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LotusBeaconEntry)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(LotusBeaconEntry__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LotusBeaconEntry)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__LotusBeaconEntry)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__Merge__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__Merge",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: Merge__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Merge)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Merge__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Merge)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(Merge__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Merge)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Merge)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__MinerExpirationExtend__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerExpirationExtend",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerExpirationExtend__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerExpirationExtend)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerExpirationExtend__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerExpirationExtend)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerExpirationExtend__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerExpirationExtend)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerExpirationExtend)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__MinerPoStProof__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerPoStProof",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerPostProof__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPoStProof)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerPostProof__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPoStProof)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerPostProof__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPoStProof)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPoStProof)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__MinerPostPartition__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerPostPartition",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerPostPartition__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPostPartition)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerPostPartition__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPostPartition)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerPostPartition__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPostPartition)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerPostPartition)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__MinerTerminationDecl__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerTerminationDecl",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerTerminationDecl__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerTerminationDecl)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerTerminationDecl__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerTerminationDecl)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerTerminationDecl__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerTerminationDecl)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerTerminationDecl)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__MinerV0DeadlineLink__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerV0DeadlineLink",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV0Deadline__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0DeadlineLink)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				if err != nil {
					return nil, err
				}
				targetCid, err := out.AsLink()
				if err != nil {
					return nil, err
				}

				var node ipld.Node

				if cl, ok := targetCid.(cidlink.Link); ok {
					v := p.Context.Value(nodeLoaderCtxKey)
					if v == nil {
						return cl.Cid, nil
					}
					loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) (ipld.Node, error))
					if !ok {
						return nil, errInvalidLoader
					}

					builder := types.Type.MinerV0Deadline__Repr.NewBuilder()
					n, err := loader(p.Context, cl, builder)
					if err != nil {
						return nil, err
					}
					node = n
				} else {
					return nil, errInvalidLink
				}

				return node, nil

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerV0Deadline__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					targetCid, err := node.AsLink()
					if err != nil {
						return nil, err
					}

					if cl, ok := targetCid.(cidlink.Link); ok {
						v := p.Context.Value(nodeLoaderCtxKey)
						if v == nil {
							return cl.Cid, nil
						}
						loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) (ipld.Node, error))
						if !ok {
							return nil, errInvalidLoader
						}

						builder := types.Type.MinerV0Deadline__Repr.NewBuilder()
						n, err := loader(p.Context, cl, builder)
						if err != nil {
							return nil, err
						}
						node = n
					} else {
						return nil, errInvalidLink
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerV0Deadline__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					targetCid, err := node.AsLink()
					if err != nil {
						return nil, err
					}

					if cl, ok := targetCid.(cidlink.Link); ok {
						v := p.Context.Value(nodeLoaderCtxKey)
						if v == nil {
							return cl.Cid, nil
						}
						loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) (ipld.Node, error))
						if !ok {
							return nil, errInvalidLoader
						}

						builder := types.Type.MinerV0Deadline__Repr.NewBuilder()
						n, err := loader(p.Context, cl, builder)
						if err != nil {
							return nil, err
						}
						node = n
					} else {
						return nil, errInvalidLink
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__MinerV0SectorPreCommitInfo__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerV0SectorPreCommitInfo",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV0SectorPreCommitInfo__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0SectorPreCommitInfo)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerV0SectorPreCommitInfo__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0SectorPreCommitInfo)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerV0SectorPreCommitInfo__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0SectorPreCommitInfo)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0SectorPreCommitInfo)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__MinerV0VestingFund__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerV0VestingFund",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV0VestingFund__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0VestingFund)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerV0VestingFund__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0VestingFund)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerV0VestingFund__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0VestingFund)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV0VestingFund)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__MinerV2DeadlineLink__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerV2DeadlineLink",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV2Deadline__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV2DeadlineLink)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				if err != nil {
					return nil, err
				}
				targetCid, err := out.AsLink()
				if err != nil {
					return nil, err
				}

				var node ipld.Node

				if cl, ok := targetCid.(cidlink.Link); ok {
					v := p.Context.Value(nodeLoaderCtxKey)
					if v == nil {
						return cl.Cid, nil
					}
					loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) (ipld.Node, error))
					if !ok {
						return nil, errInvalidLoader
					}

					builder := types.Type.MinerV2Deadline__Repr.NewBuilder()
					n, err := loader(p.Context, cl, builder)
					if err != nil {
						return nil, err
					}
					node = n
				} else {
					return nil, errInvalidLink
				}

				return node, nil

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerV2Deadline__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV2DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					targetCid, err := node.AsLink()
					if err != nil {
						return nil, err
					}

					if cl, ok := targetCid.(cidlink.Link); ok {
						v := p.Context.Value(nodeLoaderCtxKey)
						if v == nil {
							return cl.Cid, nil
						}
						loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) (ipld.Node, error))
						if !ok {
							return nil, errInvalidLoader
						}

						builder := types.Type.MinerV2Deadline__Repr.NewBuilder()
						n, err := loader(p.Context, cl, builder)
						if err != nil {
							return nil, err
						}
						node = n
					} else {
						return nil, errInvalidLink
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerV2Deadline__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV2DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					targetCid, err := node.AsLink()
					if err != nil {
						return nil, err
					}

					if cl, ok := targetCid.(cidlink.Link); ok {
						v := p.Context.Value(nodeLoaderCtxKey)
						if v == nil {
							return cl.Cid, nil
						}
						loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) (ipld.Node, error))
						if !ok {
							return nil, errInvalidLoader
						}

						builder := types.Type.MinerV2Deadline__Repr.NewBuilder()
						n, err := loader(p.Context, cl, builder)
						if err != nil {
							return nil, err
						}
						node = n
					} else {
						return nil, errInvalidLink
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV2DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__MinerV3DeadlineLink__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__MinerV3DeadlineLink",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV3Deadline__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV3DeadlineLink)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				if err != nil {
					return nil, err
				}
				targetCid, err := out.AsLink()
				if err != nil {
					return nil, err
				}

				var node ipld.Node

				if cl, ok := targetCid.(cidlink.Link); ok {
					v := p.Context.Value(nodeLoaderCtxKey)
					if v == nil {
						return cl.Cid, nil
					}
					loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) (ipld.Node, error))
					if !ok {
						return nil, errInvalidLoader
					}

					builder := types.Type.MinerV3Deadline__Repr.NewBuilder()
					n, err := loader(p.Context, cl, builder)
					if err != nil {
						return nil, err
					}
					node = n
				} else {
					return nil, errInvalidLink
				}

				return node, nil

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MinerV3Deadline__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV3DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					targetCid, err := node.AsLink()
					if err != nil {
						return nil, err
					}

					if cl, ok := targetCid.(cidlink.Link); ok {
						v := p.Context.Value(nodeLoaderCtxKey)
						if v == nil {
							return cl.Cid, nil
						}
						loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) (ipld.Node, error))
						if !ok {
							return nil, errInvalidLoader
						}

						builder := types.Type.MinerV3Deadline__Repr.NewBuilder()
						n, err := loader(p.Context, cl, builder)
						if err != nil {
							return nil, err
						}
						node = n
					} else {
						return nil, errInvalidLink
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(MinerV3Deadline__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV3DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					targetCid, err := node.AsLink()
					if err != nil {
						return nil, err
					}

					if cl, ok := targetCid.(cidlink.Link); ok {
						v := p.Context.Value(nodeLoaderCtxKey)
						if v == nil {
							return cl.Cid, nil
						}
						loader, ok := v.(func(context.Context, cidlink.Link, ipld.NodeBuilder) (ipld.Node, error))
						if !ok {
							return nil, errInvalidLoader
						}

						builder := types.Type.MinerV3Deadline__Repr.NewBuilder()
						n, err := loader(p.Context, cl, builder)
						if err != nil {
							return nil, err
						}
						node = n
					} else {
						return nil, errInvalidLink
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__MinerV3DeadlineLink)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__Multiaddrs__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__Multiaddrs",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: Multiaddr__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Multiaddrs)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Multiaddr__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Multiaddrs)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(Multiaddr__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Multiaddrs)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__Multiaddrs)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__PoStProof__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__PoStProof",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: PoStProof__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__PoStProof)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(PoStProof__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__PoStProof)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(PoStProof__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__PoStProof)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__PoStProof)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__SectorDataSpec__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__SectorDataSpec",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: SectorDataSpec__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__SectorDataSpec)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(SectorDataSpec__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__SectorDataSpec)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(SectorDataSpec__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__SectorDataSpec)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__SectorDataSpec)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__SectorNumber__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List__SectorNumber",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: SectorNumber__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__SectorNumber)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(SectorNumber__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__SectorNumber)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(SectorNumber__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__SectorNumber)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List__SectorNumber)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var List__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "List",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: Any__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List)
				if !ok {
					return nil, errNotNode
				}

				arg := p.Args["key"]
				var out ipld.Node
				var err error
				switch ta := arg.(type) {
				case ipld.Node:
					out, err = ts.LookupByNode(ta)
				case int64:
					out, err = ts.LookupByIndex(ta)
				default:
					return nil, fmt.Errorf("unknown key type: %T", arg)
				}

				return out, err

			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Any__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)
				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Range": &graphql.Field{
			Type: graphql.NewList(Any__type),
			Args: graphql.FieldConfigArgument{
				"skip": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
				"take": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.Int),
				},
			},
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List)
				if !ok {
					return nil, errNotNode
				}
				it := ts.ListIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"Count": &graphql.Field{
			Type: graphql.NewNonNull(graphql.Int),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(types.List)
				if !ok {
					return nil, errNotNode
				}
				return ts.Length(), nil
			},
		},
	},
})

var LotusActorV2Head__type = graphql.NewUnion(graphql.UnionConfig{
	Name: "LotusActorV2Head",
	Types: []*graphql.Object{

		MarketV2State__type,

		MinerV2State__type,

		PowerV2State__type,

		RewardV2State__type,

		AccountV0State__type,

		CronV0State__type,

		InitV0State__type,

		MarketV0State__type,

		MinerV0State__type,

		MultisigV0State__type,

		PaychV0State__type,

		PowerV0State__type,

		RewardV0State__type,

		VerifregV0State__type,
	},
	ResolveType: func(p graphql.ResolveTypeParams) *graphql.Object {
		if node, ok := p.Value.(ipld.Node); ok {
			switch node.Prototype() {

			case types.Type.MarketV2State:
				fallthrough
			case types.Type.MarketV2State__Repr:
				return MarketV2State__type

			case types.Type.MinerV2State:
				fallthrough
			case types.Type.MinerV2State__Repr:
				return MinerV2State__type

			case types.Type.PowerV2State:
				fallthrough
			case types.Type.PowerV2State__Repr:
				return PowerV2State__type

			case types.Type.RewardV2State:
				fallthrough
			case types.Type.RewardV2State__Repr:
				return RewardV2State__type

			case types.Type.AccountV0State:
				fallthrough
			case types.Type.AccountV0State__Repr:
				return AccountV0State__type

			case types.Type.CronV0State:
				fallthrough
			case types.Type.CronV0State__Repr:
				return CronV0State__type

			case types.Type.InitV0State:
				fallthrough
			case types.Type.InitV0State__Repr:
				return InitV0State__type

			case types.Type.MarketV0State:
				fallthrough
			case types.Type.MarketV0State__Repr:
				return MarketV0State__type

			case types.Type.MinerV0State:
				fallthrough
			case types.Type.MinerV0State__Repr:
				return MinerV0State__type

			case types.Type.MultisigV0State:
				fallthrough
			case types.Type.MultisigV0State__Repr:
				return MultisigV0State__type

			case types.Type.PaychV0State:
				fallthrough
			case types.Type.PaychV0State__Repr:
				return PaychV0State__type

			case types.Type.PowerV0State:
				fallthrough
			case types.Type.PowerV0State__Repr:
				return PowerV0State__type

			case types.Type.RewardV0State:
				fallthrough
			case types.Type.RewardV0State__Repr:
				return RewardV0State__type

			case types.Type.VerifregV0State:
				fallthrough
			case types.Type.VerifregV0State__Repr:
				return VerifregV0State__type

			}
		}
		fmt.Printf("Actual type %T: %v not in union\n", p.Value, p.Value)
		return nil
	},
})

var LotusActorV3Head__type = graphql.NewUnion(graphql.UnionConfig{
	Name: "LotusActorV3Head",
	Types: []*graphql.Object{

		MarketV3State__type,

		MinerV3State__type,

		PowerV3State__type,

		InitV3State__type,

		VerifregV3State__type,

		PaychV3State__type,

		MultisigV3State__type,

		MarketV2State__type,

		MinerV2State__type,

		PowerV2State__type,

		RewardV2State__type,

		AccountV0State__type,

		CronV0State__type,

		InitV0State__type,

		MarketV0State__type,

		MinerV0State__type,

		MultisigV0State__type,

		PaychV0State__type,

		PowerV0State__type,

		RewardV0State__type,

		VerifregV0State__type,
	},
	ResolveType: func(p graphql.ResolveTypeParams) *graphql.Object {
		if node, ok := p.Value.(ipld.Node); ok {
			switch node.Prototype() {

			case types.Type.MarketV3State:
				fallthrough
			case types.Type.MarketV3State__Repr:
				return MarketV3State__type

			case types.Type.MinerV3State:
				fallthrough
			case types.Type.MinerV3State__Repr:
				return MinerV3State__type

			case types.Type.PowerV3State:
				fallthrough
			case types.Type.PowerV3State__Repr:
				return PowerV3State__type

			case types.Type.InitV3State:
				fallthrough
			case types.Type.InitV3State__Repr:
				return InitV3State__type

			case types.Type.VerifregV3State:
				fallthrough
			case types.Type.VerifregV3State__Repr:
				return VerifregV3State__type

			case types.Type.PaychV3State:
				fallthrough
			case types.Type.PaychV3State__Repr:
				return PaychV3State__type

			case types.Type.MultisigV3State:
				fallthrough
			case types.Type.MultisigV3State__Repr:
				return MultisigV3State__type

			case types.Type.MarketV2State:
				fallthrough
			case types.Type.MarketV2State__Repr:
				return MarketV2State__type

			case types.Type.MinerV2State:
				fallthrough
			case types.Type.MinerV2State__Repr:
				return MinerV2State__type

			case types.Type.PowerV2State:
				fallthrough
			case types.Type.PowerV2State__Repr:
				return PowerV2State__type

			case types.Type.RewardV2State:
				fallthrough
			case types.Type.RewardV2State__Repr:
				return RewardV2State__type

			case types.Type.AccountV0State:
				fallthrough
			case types.Type.AccountV0State__Repr:
				return AccountV0State__type

			case types.Type.CronV0State:
				fallthrough
			case types.Type.CronV0State__Repr:
				return CronV0State__type

			case types.Type.InitV0State:
				fallthrough
			case types.Type.InitV0State__Repr:
				return InitV0State__type

			case types.Type.MarketV0State:
				fallthrough
			case types.Type.MarketV0State__Repr:
				return MarketV0State__type

			case types.Type.MinerV0State:
				fallthrough
			case types.Type.MinerV0State__Repr:
				return MinerV0State__type

			case types.Type.MultisigV0State:
				fallthrough
			case types.Type.MultisigV0State__Repr:
				return MultisigV0State__type

			case types.Type.PaychV0State:
				fallthrough
			case types.Type.PaychV0State__Repr:
				return PaychV0State__type

			case types.Type.PowerV0State:
				fallthrough
			case types.Type.PowerV0State__Repr:
				return PowerV0State__type

			case types.Type.RewardV0State:
				fallthrough
			case types.Type.RewardV0State__Repr:
				return RewardV0State__type

			case types.Type.VerifregV0State:
				fallthrough
			case types.Type.VerifregV0State__Repr:
				return VerifregV0State__type

			}
		}
		fmt.Printf("Actual type %T: %v not in union\n", p.Value, p.Value)
		return nil
	},
})

var LotusActorV4Head__type = graphql.NewUnion(graphql.UnionConfig{
	Name: "LotusActorV4Head",
	Types: []*graphql.Object{

		MinerV4State__type,

		MarketV3State__type,

		MinerV3State__type,

		PowerV3State__type,

		InitV3State__type,

		VerifregV3State__type,

		PaychV3State__type,

		MultisigV3State__type,

		MarketV2State__type,

		MinerV2State__type,

		PowerV2State__type,

		RewardV2State__type,

		AccountV0State__type,

		CronV0State__type,

		InitV0State__type,

		MarketV0State__type,

		MinerV0State__type,

		MultisigV0State__type,

		PaychV0State__type,

		PowerV0State__type,

		RewardV0State__type,

		VerifregV0State__type,
	},
	ResolveType: func(p graphql.ResolveTypeParams) *graphql.Object {
		if node, ok := p.Value.(ipld.Node); ok {
			switch node.Prototype() {

			case types.Type.MinerV4State:
				fallthrough
			case types.Type.MinerV4State__Repr:
				return MinerV4State__type

			case types.Type.MarketV3State:
				fallthrough
			case types.Type.MarketV3State__Repr:
				return MarketV3State__type

			case types.Type.MinerV3State:
				fallthrough
			case types.Type.MinerV3State__Repr:
				return MinerV3State__type

			case types.Type.PowerV3State:
				fallthrough
			case types.Type.PowerV3State__Repr:
				return PowerV3State__type

			case types.Type.InitV3State:
				fallthrough
			case types.Type.InitV3State__Repr:
				return InitV3State__type

			case types.Type.VerifregV3State:
				fallthrough
			case types.Type.VerifregV3State__Repr:
				return VerifregV3State__type

			case types.Type.PaychV3State:
				fallthrough
			case types.Type.PaychV3State__Repr:
				return PaychV3State__type

			case types.Type.MultisigV3State:
				fallthrough
			case types.Type.MultisigV3State__Repr:
				return MultisigV3State__type

			case types.Type.MarketV2State:
				fallthrough
			case types.Type.MarketV2State__Repr:
				return MarketV2State__type

			case types.Type.MinerV2State:
				fallthrough
			case types.Type.MinerV2State__Repr:
				return MinerV2State__type

			case types.Type.PowerV2State:
				fallthrough
			case types.Type.PowerV2State__Repr:
				return PowerV2State__type

			case types.Type.RewardV2State:
				fallthrough
			case types.Type.RewardV2State__Repr:
				return RewardV2State__type

			case types.Type.AccountV0State:
				fallthrough
			case types.Type.AccountV0State__Repr:
				return AccountV0State__type

			case types.Type.CronV0State:
				fallthrough
			case types.Type.CronV0State__Repr:
				return CronV0State__type

			case types.Type.InitV0State:
				fallthrough
			case types.Type.InitV0State__Repr:
				return InitV0State__type

			case types.Type.MarketV0State:
				fallthrough
			case types.Type.MarketV0State__Repr:
				return MarketV0State__type

			case types.Type.MinerV0State:
				fallthrough
			case types.Type.MinerV0State__Repr:
				return MinerV0State__type

			case types.Type.MultisigV0State:
				fallthrough
			case types.Type.MultisigV0State__Repr:
				return MultisigV0State__type

			case types.Type.PaychV0State:
				fallthrough
			case types.Type.PaychV0State__Repr:
				return PaychV0State__type

			case types.Type.PowerV0State:
				fallthrough
			case types.Type.PowerV0State__Repr:
				return PowerV0State__type

			case types.Type.RewardV0State:
				fallthrough
			case types.Type.RewardV0State__Repr:
				return RewardV0State__type

			case types.Type.VerifregV0State:
				fallthrough
			case types.Type.VerifregV0State__Repr:
				return VerifregV0State__type

			}
		}
		fmt.Printf("Actual type %T: %v not in union\n", p.Value, p.Value)
		return nil
	},
})

var LotusActorV5Head__type = graphql.NewUnion(graphql.UnionConfig{
	Name: "LotusActorV5Head",
	Types: []*graphql.Object{

		MinerV5State__type,

		MarketV5State__type,

		MinerV4State__type,

		MarketV3State__type,

		MinerV3State__type,

		PowerV3State__type,

		InitV3State__type,

		VerifregV3State__type,

		PaychV3State__type,

		MultisigV3State__type,

		MarketV2State__type,

		MinerV2State__type,

		PowerV2State__type,

		RewardV2State__type,

		AccountV0State__type,

		CronV0State__type,

		InitV0State__type,

		MarketV0State__type,

		MinerV0State__type,

		MultisigV0State__type,

		PaychV0State__type,

		PowerV0State__type,

		RewardV0State__type,

		VerifregV0State__type,
	},
	ResolveType: func(p graphql.ResolveTypeParams) *graphql.Object {
		if node, ok := p.Value.(ipld.Node); ok {
			switch node.Prototype() {

			case types.Type.MinerV5State:
				fallthrough
			case types.Type.MinerV5State__Repr:
				return MinerV5State__type

			case types.Type.MarketV5State:
				fallthrough
			case types.Type.MarketV5State__Repr:
				return MarketV5State__type

			case types.Type.MinerV4State:
				fallthrough
			case types.Type.MinerV4State__Repr:
				return MinerV4State__type

			case types.Type.MarketV3State:
				fallthrough
			case types.Type.MarketV3State__Repr:
				return MarketV3State__type

			case types.Type.MinerV3State:
				fallthrough
			case types.Type.MinerV3State__Repr:
				return MinerV3State__type

			case types.Type.PowerV3State:
				fallthrough
			case types.Type.PowerV3State__Repr:
				return PowerV3State__type

			case types.Type.InitV3State:
				fallthrough
			case types.Type.InitV3State__Repr:
				return InitV3State__type

			case types.Type.VerifregV3State:
				fallthrough
			case types.Type.VerifregV3State__Repr:
				return VerifregV3State__type

			case types.Type.PaychV3State:
				fallthrough
			case types.Type.PaychV3State__Repr:
				return PaychV3State__type

			case types.Type.MultisigV3State:
				fallthrough
			case types.Type.MultisigV3State__Repr:
				return MultisigV3State__type

			case types.Type.MarketV2State:
				fallthrough
			case types.Type.MarketV2State__Repr:
				return MarketV2State__type

			case types.Type.MinerV2State:
				fallthrough
			case types.Type.MinerV2State__Repr:
				return MinerV2State__type

			case types.Type.PowerV2State:
				fallthrough
			case types.Type.PowerV2State__Repr:
				return PowerV2State__type

			case types.Type.RewardV2State:
				fallthrough
			case types.Type.RewardV2State__Repr:
				return RewardV2State__type

			case types.Type.AccountV0State:
				fallthrough
			case types.Type.AccountV0State__Repr:
				return AccountV0State__type

			case types.Type.CronV0State:
				fallthrough
			case types.Type.CronV0State__Repr:
				return CronV0State__type

			case types.Type.InitV0State:
				fallthrough
			case types.Type.InitV0State__Repr:
				return InitV0State__type

			case types.Type.MarketV0State:
				fallthrough
			case types.Type.MarketV0State__Repr:
				return MarketV0State__type

			case types.Type.MinerV0State:
				fallthrough
			case types.Type.MinerV0State__Repr:
				return MinerV0State__type

			case types.Type.MultisigV0State:
				fallthrough
			case types.Type.MultisigV0State__Repr:
				return MultisigV0State__type

			case types.Type.PaychV0State:
				fallthrough
			case types.Type.PaychV0State__Repr:
				return PaychV0State__type

			case types.Type.PowerV0State:
				fallthrough
			case types.Type.PowerV0State__Repr:
				return PowerV0State__type

			case types.Type.RewardV0State:
				fallthrough
			case types.Type.RewardV0State__Repr:
				return RewardV0State__type

			case types.Type.VerifregV0State:
				fallthrough
			case types.Type.VerifregV0State__Repr:
				return VerifregV0State__type

			}
		}
		fmt.Printf("Actual type %T: %v not in union\n", p.Value, p.Value)
		return nil
	},
})

var LotusActorV6Head__type = graphql.NewUnion(graphql.UnionConfig{
	Name: "LotusActorV6Head",
	Types: []*graphql.Object{

		MinerV5State__type,

		MarketV5State__type,

		MinerV4State__type,

		MarketV3State__type,

		MinerV3State__type,

		PowerV3State__type,

		InitV3State__type,

		VerifregV3State__type,

		PaychV3State__type,

		MultisigV3State__type,

		MarketV2State__type,

		MinerV2State__type,

		PowerV2State__type,

		RewardV2State__type,

		AccountV0State__type,

		CronV0State__type,

		InitV0State__type,

		MarketV0State__type,

		MinerV0State__type,

		MultisigV0State__type,

		PaychV0State__type,

		PowerV0State__type,

		RewardV0State__type,

		VerifregV0State__type,
	},
	ResolveType: func(p graphql.ResolveTypeParams) *graphql.Object {
		if node, ok := p.Value.(ipld.Node); ok {
			switch node.Prototype() {

			case types.Type.MinerV5State:
				fallthrough
			case types.Type.MinerV5State__Repr:
				return MinerV5State__type

			case types.Type.MarketV5State:
				fallthrough
			case types.Type.MarketV5State__Repr:
				return MarketV5State__type

			case types.Type.MinerV4State:
				fallthrough
			case types.Type.MinerV4State__Repr:
				return MinerV4State__type

			case types.Type.MarketV3State:
				fallthrough
			case types.Type.MarketV3State__Repr:
				return MarketV3State__type

			case types.Type.MinerV3State:
				fallthrough
			case types.Type.MinerV3State__Repr:
				return MinerV3State__type

			case types.Type.PowerV3State:
				fallthrough
			case types.Type.PowerV3State__Repr:
				return PowerV3State__type

			case types.Type.InitV3State:
				fallthrough
			case types.Type.InitV3State__Repr:
				return InitV3State__type

			case types.Type.VerifregV3State:
				fallthrough
			case types.Type.VerifregV3State__Repr:
				return VerifregV3State__type

			case types.Type.PaychV3State:
				fallthrough
			case types.Type.PaychV3State__Repr:
				return PaychV3State__type

			case types.Type.MultisigV3State:
				fallthrough
			case types.Type.MultisigV3State__Repr:
				return MultisigV3State__type

			case types.Type.MarketV2State:
				fallthrough
			case types.Type.MarketV2State__Repr:
				return MarketV2State__type

			case types.Type.MinerV2State:
				fallthrough
			case types.Type.MinerV2State__Repr:
				return MinerV2State__type

			case types.Type.PowerV2State:
				fallthrough
			case types.Type.PowerV2State__Repr:
				return PowerV2State__type

			case types.Type.RewardV2State:
				fallthrough
			case types.Type.RewardV2State__Repr:
				return RewardV2State__type

			case types.Type.AccountV0State:
				fallthrough
			case types.Type.AccountV0State__Repr:
				return AccountV0State__type

			case types.Type.CronV0State:
				fallthrough
			case types.Type.CronV0State__Repr:
				return CronV0State__type

			case types.Type.InitV0State:
				fallthrough
			case types.Type.InitV0State__Repr:
				return InitV0State__type

			case types.Type.MarketV0State:
				fallthrough
			case types.Type.MarketV0State__Repr:
				return MarketV0State__type

			case types.Type.MinerV0State:
				fallthrough
			case types.Type.MinerV0State__Repr:
				return MinerV0State__type

			case types.Type.MultisigV0State:
				fallthrough
			case types.Type.MultisigV0State__Repr:
				return MultisigV0State__type

			case types.Type.PaychV0State:
				fallthrough
			case types.Type.PaychV0State__Repr:
				return PaychV0State__type

			case types.Type.PowerV0State:
				fallthrough
			case types.Type.PowerV0State__Repr:
				return PowerV0State__type

			case types.Type.RewardV0State:
				fallthrough
			case types.Type.RewardV0State__Repr:
				return RewardV0State__type

			case types.Type.VerifregV0State:
				fallthrough
			case types.Type.VerifregV0State__Repr:
				return VerifregV0State__type

			}
		}
		fmt.Printf("Actual type %T: %v not in union\n", p.Value, p.Value)
		return nil
	},
})

var LotusActors__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusActors",
	Fields: graphql.Fields{
		"Code": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: LotusActors__Code__resolve,
		},
		"Head": &graphql.Field{

			Type: graphql.NewNonNull(LotusActorV6Head__type),

			Resolve: LotusActors__Head__resolve,
		},
		"Nonce": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusActors__Nonce__resolve,
		},
		"Balance": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: LotusActors__Balance__resolve,
		},
	},
})

var LotusBeaconEntry__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusBeaconEntry",
	Fields: graphql.Fields{
		"Round": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusBeaconEntry__Round__resolve,
		},
		"Data": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: LotusBeaconEntry__Data__resolve,
		},
	},
})

var LotusBlockHeader__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusBlockHeader",
	Fields: graphql.Fields{
		"Miner": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: LotusBlockHeader__Miner__resolve,
		},
		"Ticket": &graphql.Field{

			Type: LotusTicket__type,

			Resolve: LotusBlockHeader__Ticket__resolve,
		},
		"ElectionProof": &graphql.Field{

			Type: LotusElectionProof__type,

			Resolve: LotusBlockHeader__ElectionProof__resolve,
		},
		"BeaconEntries": &graphql.Field{

			Type: graphql.NewNonNull(List__LotusBeaconEntry__type),

			Resolve: LotusBlockHeader__BeaconEntries__resolve,
		},
		"WinPoStProof": &graphql.Field{

			Type: graphql.NewNonNull(List__PoStProof__type),

			Resolve: LotusBlockHeader__WinPoStProof__resolve,
		},
		"Parents": &graphql.Field{

			Type: graphql.NewNonNull(List__Link__type),

			Resolve: LotusBlockHeader__Parents__resolve,
		},
		"ParentWeight": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: LotusBlockHeader__ParentWeight__resolve,
		},
		"Height": &graphql.Field{

			Type: graphql.NewNonNull(ChainEpoch__type),

			Resolve: LotusBlockHeader__Height__resolve,
		},
		"ParentStateRoot": &graphql.Field{

			Type: graphql.NewNonNull(LotusStateRoot__type),

			Resolve: LotusBlockHeader__ParentStateRoot__resolve,
		},
		"ParentMessageReceipts": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: LotusBlockHeader__ParentMessageReceipts__resolve,
		},
		"Messages": &graphql.Field{

			Type: graphql.NewNonNull(LotusMsgMeta__type),

			Resolve: LotusBlockHeader__Messages__resolve,
		},
		"BLSAggregate": &graphql.Field{

			Type: Signature__type,

			Resolve: LotusBlockHeader__BLSAggregate__resolve,
		},
		"Timestamp": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusBlockHeader__Timestamp__resolve,
		},
		"BlockSig": &graphql.Field{

			Type: Signature__type,

			Resolve: LotusBlockHeader__BlockSig__resolve,
		},
		"ForkSignaling": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusBlockHeader__ForkSignaling__resolve,
		},
		"ParentBaseFee": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: LotusBlockHeader__ParentBaseFee__resolve,
		},
	},
})

var LotusElectionProof__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusElectionProof",
	Fields: graphql.Fields{
		"WinCount": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusElectionProof__WinCount__resolve,
		},
		"VRFProof": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: LotusElectionProof__VRFProof__resolve,
		},
	},
})

var LotusMessageV2Params__type = graphql.NewUnion(graphql.UnionConfig{
	Name: "LotusMessageV2Params",
	Types: []*graphql.Object{

		MessageParamsInitExecParams__type,

		MinerV0SectorPreCommitInfo__type,

		MessageParamsMarketWithdrawBalance__type,

		MessageParamsMarketPublishDeals__type,

		MessageParamsMarketVerifyDeals__type,

		MessageParamsMarketActivateDeals__type,

		MessageParamsMarketTerminateDeals__type,

		MessageParamsMarketComputeCommitment__type,

		MessageParamsMinerConstructor__type,

		MessageParamsMinerChangeAddress__type,

		MessageParamsMinerChangeMultiaddrs__type,

		MessageParamsMinerChangePeerID__type,

		MessageParamsMinerSubmitWindowedPoSt__type,

		MessageParamsMinerProveCommitSector__type,

		MessageParamsMinerCheckSectorProven__type,

		MessageParamsMinerConfirmSectorProofs__type,

		MessageParamsMinerExtendSectorExpiration__type,

		MessageParamsMinerTerminateSectors__type,

		MessageParamsMinerDeclareFaults__type,

		MessageParamsMinerDeclareFaultsRecovered__type,

		MessageParamsMinerCompactPartitions__type,

		MessageParamsMinerCompactSectorNumbers__type,

		ApplyRewardParams__type,

		MessageParamsMinerReportFault__type,

		MessageParamsMinerWithdrawBalance__type,

		MessageParamsMinerDeferredCron__type,

		MessageParamsMultisigConstructor__type,

		MessageParamsMultisigPropose__type,

		MessageParamsMultisigTxnID__type,

		MessageParamsMultisigAddSigner__type,

		MessageParamsMultisigRemoveSigner__type,

		MessageParamsMultisigSwapSigner__type,

		MessageParamsMultisigChangeThreshold__type,

		MessageParamsMultisigLockBalance__type,

		MessageParamsPaychConstructor__type,

		MessageParamsPaychUpdateChannelState__type,

		MessageParamsPowerCreateMiner__type,

		MessageParamsPowerUpdateClaimed__type,

		MessageParamsPowerEnrollCron__type,

		MessageParamsPowerCurrentTotal__type,

		MessageParamsRewardAwardBlock__type,

		MessageParamsVerifregAddVerifier__type,

		MessageParamsVerifregUseBytes__type,
	},
	ResolveType: func(p graphql.ResolveTypeParams) *graphql.Object {
		if node, ok := p.Value.(ipld.Node); ok {
			switch node.Prototype() {

			case types.Type.MessageParamsInitExecParams:
				fallthrough
			case types.Type.MessageParamsInitExecParams__Repr:
				return MessageParamsInitExecParams__type

			case types.Type.MinerV0SectorPreCommitInfo:
				fallthrough
			case types.Type.MinerV0SectorPreCommitInfo__Repr:
				return MinerV0SectorPreCommitInfo__type

			case types.Type.MessageParamsMarketWithdrawBalance:
				fallthrough
			case types.Type.MessageParamsMarketWithdrawBalance__Repr:
				return MessageParamsMarketWithdrawBalance__type

			case types.Type.MessageParamsMarketPublishDeals:
				fallthrough
			case types.Type.MessageParamsMarketPublishDeals__Repr:
				return MessageParamsMarketPublishDeals__type

			case types.Type.MessageParamsMarketVerifyDeals:
				fallthrough
			case types.Type.MessageParamsMarketVerifyDeals__Repr:
				return MessageParamsMarketVerifyDeals__type

			case types.Type.MessageParamsMarketActivateDeals:
				fallthrough
			case types.Type.MessageParamsMarketActivateDeals__Repr:
				return MessageParamsMarketActivateDeals__type

			case types.Type.MessageParamsMarketTerminateDeals:
				fallthrough
			case types.Type.MessageParamsMarketTerminateDeals__Repr:
				return MessageParamsMarketTerminateDeals__type

			case types.Type.MessageParamsMarketComputeCommitment:
				fallthrough
			case types.Type.MessageParamsMarketComputeCommitment__Repr:
				return MessageParamsMarketComputeCommitment__type

			case types.Type.MessageParamsMinerConstructor:
				fallthrough
			case types.Type.MessageParamsMinerConstructor__Repr:
				return MessageParamsMinerConstructor__type

			case types.Type.MessageParamsMinerChangeAddress:
				fallthrough
			case types.Type.MessageParamsMinerChangeAddress__Repr:
				return MessageParamsMinerChangeAddress__type

			case types.Type.MessageParamsMinerChangeMultiaddrs:
				fallthrough
			case types.Type.MessageParamsMinerChangeMultiaddrs__Repr:
				return MessageParamsMinerChangeMultiaddrs__type

			case types.Type.MessageParamsMinerChangePeerID:
				fallthrough
			case types.Type.MessageParamsMinerChangePeerID__Repr:
				return MessageParamsMinerChangePeerID__type

			case types.Type.MessageParamsMinerSubmitWindowedPoSt:
				fallthrough
			case types.Type.MessageParamsMinerSubmitWindowedPoSt__Repr:
				return MessageParamsMinerSubmitWindowedPoSt__type

			case types.Type.MessageParamsMinerProveCommitSector:
				fallthrough
			case types.Type.MessageParamsMinerProveCommitSector__Repr:
				return MessageParamsMinerProveCommitSector__type

			case types.Type.MessageParamsMinerCheckSectorProven:
				fallthrough
			case types.Type.MessageParamsMinerCheckSectorProven__Repr:
				return MessageParamsMinerCheckSectorProven__type

			case types.Type.MessageParamsMinerConfirmSectorProofs:
				fallthrough
			case types.Type.MessageParamsMinerConfirmSectorProofs__Repr:
				return MessageParamsMinerConfirmSectorProofs__type

			case types.Type.MessageParamsMinerExtendSectorExpiration:
				fallthrough
			case types.Type.MessageParamsMinerExtendSectorExpiration__Repr:
				return MessageParamsMinerExtendSectorExpiration__type

			case types.Type.MessageParamsMinerTerminateSectors:
				fallthrough
			case types.Type.MessageParamsMinerTerminateSectors__Repr:
				return MessageParamsMinerTerminateSectors__type

			case types.Type.MessageParamsMinerDeclareFaults:
				fallthrough
			case types.Type.MessageParamsMinerDeclareFaults__Repr:
				return MessageParamsMinerDeclareFaults__type

			case types.Type.MessageParamsMinerDeclareFaultsRecovered:
				fallthrough
			case types.Type.MessageParamsMinerDeclareFaultsRecovered__Repr:
				return MessageParamsMinerDeclareFaultsRecovered__type

			case types.Type.MessageParamsMinerCompactPartitions:
				fallthrough
			case types.Type.MessageParamsMinerCompactPartitions__Repr:
				return MessageParamsMinerCompactPartitions__type

			case types.Type.MessageParamsMinerCompactSectorNumbers:
				fallthrough
			case types.Type.MessageParamsMinerCompactSectorNumbers__Repr:
				return MessageParamsMinerCompactSectorNumbers__type

			case types.Type.ApplyRewardParams:
				fallthrough
			case types.Type.ApplyRewardParams__Repr:
				return ApplyRewardParams__type

			case types.Type.MessageParamsMinerReportFault:
				fallthrough
			case types.Type.MessageParamsMinerReportFault__Repr:
				return MessageParamsMinerReportFault__type

			case types.Type.MessageParamsMinerWithdrawBalance:
				fallthrough
			case types.Type.MessageParamsMinerWithdrawBalance__Repr:
				return MessageParamsMinerWithdrawBalance__type

			case types.Type.MessageParamsMinerDeferredCron:
				fallthrough
			case types.Type.MessageParamsMinerDeferredCron__Repr:
				return MessageParamsMinerDeferredCron__type

			case types.Type.MessageParamsMultisigConstructor:
				fallthrough
			case types.Type.MessageParamsMultisigConstructor__Repr:
				return MessageParamsMultisigConstructor__type

			case types.Type.MessageParamsMultisigPropose:
				fallthrough
			case types.Type.MessageParamsMultisigPropose__Repr:
				return MessageParamsMultisigPropose__type

			case types.Type.MessageParamsMultisigTxnID:
				fallthrough
			case types.Type.MessageParamsMultisigTxnID__Repr:
				return MessageParamsMultisigTxnID__type

			case types.Type.MessageParamsMultisigAddSigner:
				fallthrough
			case types.Type.MessageParamsMultisigAddSigner__Repr:
				return MessageParamsMultisigAddSigner__type

			case types.Type.MessageParamsMultisigRemoveSigner:
				fallthrough
			case types.Type.MessageParamsMultisigRemoveSigner__Repr:
				return MessageParamsMultisigRemoveSigner__type

			case types.Type.MessageParamsMultisigSwapSigner:
				fallthrough
			case types.Type.MessageParamsMultisigSwapSigner__Repr:
				return MessageParamsMultisigSwapSigner__type

			case types.Type.MessageParamsMultisigChangeThreshold:
				fallthrough
			case types.Type.MessageParamsMultisigChangeThreshold__Repr:
				return MessageParamsMultisigChangeThreshold__type

			case types.Type.MessageParamsMultisigLockBalance:
				fallthrough
			case types.Type.MessageParamsMultisigLockBalance__Repr:
				return MessageParamsMultisigLockBalance__type

			case types.Type.MessageParamsPaychConstructor:
				fallthrough
			case types.Type.MessageParamsPaychConstructor__Repr:
				return MessageParamsPaychConstructor__type

			case types.Type.MessageParamsPaychUpdateChannelState:
				fallthrough
			case types.Type.MessageParamsPaychUpdateChannelState__Repr:
				return MessageParamsPaychUpdateChannelState__type

			case types.Type.MessageParamsPowerCreateMiner:
				fallthrough
			case types.Type.MessageParamsPowerCreateMiner__Repr:
				return MessageParamsPowerCreateMiner__type

			case types.Type.MessageParamsPowerUpdateClaimed:
				fallthrough
			case types.Type.MessageParamsPowerUpdateClaimed__Repr:
				return MessageParamsPowerUpdateClaimed__type

			case types.Type.MessageParamsPowerEnrollCron:
				fallthrough
			case types.Type.MessageParamsPowerEnrollCron__Repr:
				return MessageParamsPowerEnrollCron__type

			case types.Type.MessageParamsPowerCurrentTotal:
				fallthrough
			case types.Type.MessageParamsPowerCurrentTotal__Repr:
				return MessageParamsPowerCurrentTotal__type

			case types.Type.MessageParamsRewardAwardBlock:
				fallthrough
			case types.Type.MessageParamsRewardAwardBlock__Repr:
				return MessageParamsRewardAwardBlock__type

			case types.Type.MessageParamsVerifregAddVerifier:
				fallthrough
			case types.Type.MessageParamsVerifregAddVerifier__Repr:
				return MessageParamsVerifregAddVerifier__type

			case types.Type.MessageParamsVerifregUseBytes:
				fallthrough
			case types.Type.MessageParamsVerifregUseBytes__Repr:
				return MessageParamsVerifregUseBytes__type

			}
		}
		fmt.Printf("Actual type %T: %v not in union\n", p.Value, p.Value)
		return nil
	},
})

var LotusMessage__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusMessage",
	Fields: graphql.Fields{
		"Version": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusMessage__Version__resolve,
		},
		"To": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: LotusMessage__To__resolve,
		},
		"From": &graphql.Field{

			Type: graphql.NewNonNull(Address__type),

			Resolve: LotusMessage__From__resolve,
		},
		"Nonce": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusMessage__Nonce__resolve,
		},
		"Value": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: LotusMessage__Value__resolve,
		},
		"GasLimit": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusMessage__GasLimit__resolve,
		},
		"GasFeeCap": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: LotusMessage__GasFeeCap__resolve,
		},
		"GasPremium": &graphql.Field{

			Type: graphql.NewNonNull(BigInt__type),

			Resolve: LotusMessage__GasPremium__resolve,
		},
		"Method": &graphql.Field{

			Type: graphql.NewNonNull(MethodNum__type),

			Resolve: LotusMessage__Method__resolve,
		},
		"Params": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: LotusMessage__Params__resolve,
		},
	},
})

var LotusMsgMeta__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusMsgMeta",
	Fields: graphql.Fields{
		"BlsMessages": &graphql.Field{

			Type: graphql.NewNonNull(List__LinkLotusMessage__type),

			Resolve: LotusMsgMeta__BlsMessages__resolve,
		},
		"SecpkMessages": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: LotusMsgMeta__SecpkMessages__resolve,
		},
	},
})

var LotusSignedMessage__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusSignedMessage",
	Fields: graphql.Fields{
		"Message": &graphql.Field{

			Type: graphql.NewNonNull(LotusMessage__type),

			Resolve: LotusSignedMessage__Message__resolve,
		},
		"Signature": &graphql.Field{

			Type: graphql.NewNonNull(Signature__type),

			Resolve: LotusSignedMessage__Signature__resolve,
		},
	},
})

var LotusStateRoot__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusStateRoot",
	Fields: graphql.Fields{
		"Version": &graphql.Field{

			Type: graphql.NewNonNull(graphql.Int),

			Resolve: LotusStateRoot__Version__resolve,
		},
		"Actors": &graphql.Field{

			Type: graphql.NewNonNull(Map__LotusActors__type),

			Resolve: LotusStateRoot__Actors__resolve,
		},
		"Info": &graphql.Field{

			Type: graphql.NewNonNull(graphql.ID),

			Resolve: LotusStateRoot__Info__resolve,
		},
	},
})

var LotusTicket__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "LotusTicket",
	Fields: graphql.Fields{
		"VRFProof": &graphql.Field{

			Type: graphql.NewNonNull(Bytes__type),

			Resolve: LotusTicket__VRFProof__resolve,
		},
	},
})

var MapV3__BitField__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MapV3__BitField",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: BitField__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(BitField__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MapV3__BitField__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var MapV3__BitField__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "MapV3__BitField_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: BitField__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var MapV3__List__DealID__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "MapV3__List__DealID",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: List__DealID__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(List__DealID__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(MapV3__List__DealID__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var MapV3__List__DealID__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "MapV3__List__DealID_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: List__DealID__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__ActorID__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__ActorID",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: ActorID__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(RawAddress__type),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(RawAddress__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(ActorID__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__ActorID__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__ActorID__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__ActorID_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: RawAddress__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: ActorID__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__BalanceTable__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__BalanceTable",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: BigInt__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(RawAddress__type),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(RawAddress__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(BigInt__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__BalanceTable__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__BalanceTable__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__BalanceTable_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: RawAddress__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: BigInt__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__BitField__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__BitField",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: BitField__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(BitField__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__BitField__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__BitField__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__BitField_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: BitField__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__DataCap__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__DataCap",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: BigInt__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(RawAddress__type),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(RawAddress__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(BigInt__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__DataCap__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__DataCap__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__DataCap_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: RawAddress__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: BigInt__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__List__DealID__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__List__DealID",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: List__DealID__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(List__DealID__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__List__DealID__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__List__DealID__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__List__DealID_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: List__DealID__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__LotusActors__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__LotusActors",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: LotusActors__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(RawAddress__type),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(RawAddress__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(LotusActors__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__LotusActors__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__LotusActors__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__LotusActors_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: RawAddress__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: LotusActors__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MarketV0DealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV0DealProposal",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketV0DealProposal__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(CidString__type),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(CidString__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MarketV0DealProposal__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MarketV0DealProposal__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MarketV0DealProposal__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV0DealProposal_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: CidString__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MarketV0DealProposal__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MarketV0DealState__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV0DealState",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketV0DealState__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MarketV0DealState__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MarketV0DealState__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MarketV0DealState__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV0DealState_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MarketV0DealState__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MarketV0RawDealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV0RawDealProposal",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketV0DealProposal__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MarketV0DealProposal__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MarketV0RawDealProposal__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MarketV0RawDealProposal__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV0RawDealProposal_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MarketV0DealProposal__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MarketV2DealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV2DealProposal",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketV2DealProposal__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(CidString__type),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(CidString__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MarketV2DealProposal__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MarketV2DealProposal__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MarketV2DealProposal__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV2DealProposal_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: CidString__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MarketV2DealProposal__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MarketV2RawDealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV2RawDealProposal",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketV2DealProposal__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MarketV2DealProposal__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MarketV2RawDealProposal__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MarketV2RawDealProposal__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV2RawDealProposal_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MarketV2DealProposal__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MarketV3DealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV3DealProposal",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketV2DealProposal__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(CidString__type),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(CidString__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MarketV2DealProposal__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MarketV3DealProposal__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MarketV3DealProposal__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV3DealProposal_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: CidString__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MarketV2DealProposal__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MarketV3DealState__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV3DealState",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketV0DealState__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MarketV0DealState__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MarketV3DealState__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MarketV3DealState__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV3DealState_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MarketV0DealState__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MarketV3RawDealProposal__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV3RawDealProposal",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MarketV2DealProposal__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MarketV2DealProposal__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MarketV3RawDealProposal__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MarketV3RawDealProposal__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MarketV3RawDealProposal_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MarketV2DealProposal__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MinerV0ExpirationSet__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MinerV0ExpirationSet",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV0ExpirationSet__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MinerV0ExpirationSet__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MinerV0ExpirationSet__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MinerV0ExpirationSet__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MinerV0ExpirationSet_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MinerV0ExpirationSet__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MinerV0Partition__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MinerV0Partition",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV0Partition__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MinerV0Partition__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MinerV0Partition__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MinerV0Partition__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MinerV0Partition_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MinerV0Partition__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MinerV2Partition__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MinerV2Partition",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV2Partition__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MinerV2Partition__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MinerV2Partition__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MinerV2Partition__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MinerV2Partition_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MinerV2Partition__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MinerV3ExpirationSet__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MinerV3ExpirationSet",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV0ExpirationSet__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MinerV0ExpirationSet__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MinerV3ExpirationSet__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MinerV3ExpirationSet__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MinerV3ExpirationSet_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MinerV0ExpirationSet__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MinerV3Partition__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MinerV3Partition",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MinerV3Partition__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MinerV3Partition__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MinerV3Partition__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MinerV3Partition__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MinerV3Partition_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MinerV3Partition__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MultisigV0Transaction__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MultisigV0Transaction",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MultisigV0Transaction__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MultisigV0Transaction__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MultisigV0Transaction__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MultisigV0Transaction__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MultisigV0Transaction_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MultisigV0Transaction__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__MultisigV3Transaction__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MultisigV3Transaction",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: MultisigV0Transaction__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(MultisigV0Transaction__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__MultisigV3Transaction__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})

var Map__MultisigV3Transaction__type__entry = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__MultisigV3Transaction_Entry",
	Fields: graphql.Fields{
		"Key": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[0], nil
			},
		},
		"Value": &graphql.Field{
			Type: MultisigV0Transaction__type,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				kv, ok := p.Source.([]ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				return kv[1], nil
			},
		},
	},
})

var Map__PaychV0LaneState__type = graphql.NewObject(graphql.ObjectConfig{
	Name: "Map__PaychV0LaneState",
	Fields: graphql.Fields{
		"At": &graphql.Field{
			Type: PaychV0LaneState__type,
			Args: graphql.FieldConfigArgument{
				"key": &graphql.ArgumentConfig{
					Type: graphql.NewNonNull(graphql.String),
				},
			},
			Resolve: resolve_map_at,
		},
		"Keys": &graphql.Field{
			Type: graphql.NewList(graphql.String),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					node, _, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, node)
				}
				return children, nil
			},
		},
		"Values": &graphql.Field{
			Type: graphql.NewList(PaychV0LaneState__type),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([]ipld.Node, 0)

				for !it.Done() {
					_, node, err := it.Next()
					if err != nil {
						return nil, err
					}

					children = append(children, node)
				}
				return children, nil
			},
		},
		"All": &graphql.Field{
			Type: graphql.NewList(Map__PaychV0LaneState__type__entry),
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				ts, ok := p.Source.(ipld.Node)
				if !ok {
					return nil, errNotNode
				}
				it := ts.MapIterator()
				children := make([][]ipld.Node, 0)

				for !it.Done() {
					k, v, err := it.Next()
					if err != nil {
						return nil, err
					}
					children = append(children, []ipld.Node{k, v})
				}
				return children, nil
			},
		},
	},
})