diff --git a/_rsrch/nodestyle/nodeStyle.go b/_rsrch/nodestyle/nodeStyle.go
index 8aa6e86d..ae29a21b 100644
--- a/_rsrch/nodestyle/nodeStyle.go
+++ b/_rsrch/nodestyle/nodeStyle.go
@@ -5,10 +5,10 @@ import (
 	"io"
 )
 
-type ReprKind uint8
+type Kind uint8
 
 type Node interface {
-	ReprKind() ReprKind
+	Kind() Kind
 	LookupByString(key string) (Node, error)
 	LookupByNode(key Node) (Node, error)
 	LookupByIndex(idx int) (Node, error)
diff --git a/adl/rot13adl/example_test.go b/adl/rot13adl/example_test.go
index 4f040411..599eeffb 100644
--- a/adl/rot13adl/example_test.go
+++ b/adl/rot13adl/example_test.go
@@ -29,7 +29,7 @@ func ExampleUnmarshallingToADL() {
 	fmt.Printf("reify error: %v\n", err)
 
 	// We can inspect the synthetic ADL node like any other node!
-	fmt.Printf("adl node kind: %v\n", syntheticView.ReprKind())
+	fmt.Printf("adl node kind: %v\n", syntheticView.Kind())
 	fmt.Printf("adl view value: %q\n", must.String(syntheticView))
 
 	// Output:
@@ -48,13 +48,13 @@ func ExampleCreatingViaADL() {
 	n := nb.Build()
 
 	// We can inspect the synthetic ADL node like any other node!
-	fmt.Printf("adl node kind: %v\n", n.ReprKind())
+	fmt.Printf("adl node kind: %v\n", n.Kind())
 	fmt.Printf("adl view value: %q\n", must.String(n))
 
 	// We can get the substrate view and examine that as a node too.
 	// (This requires a cast to see that we have an ADL, though.  Not all IPLD nodes have a 'Substrate' property.)
 	substrateNode := n.(rot13adl.R13String).Substrate()
-	fmt.Printf("substrate node kind: %v\n", substrateNode.ReprKind())
+	fmt.Printf("substrate node kind: %v\n", substrateNode.Kind())
 	fmt.Printf("substrate value: %q\n", must.String(substrateNode))
 
 	// To marshal the ADL, just use marshal methods on its substrate as normal:
diff --git a/adl/rot13adl/rot13node.go b/adl/rot13adl/rot13node.go
index a709d8c1..a117049a 100644
--- a/adl/rot13adl/rot13node.go
+++ b/adl/rot13adl/rot13node.go
@@ -37,8 +37,8 @@ type _R13String struct {
 	synthesized string // the content that the ADL presents.  calculated proactively from the original, in this implementation (though you could imagine implementing it lazily, in either direction, too).
 }
 
-func (*_R13String) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_String
+func (*_R13String) Kind() ipld.Kind {
+	return ipld.Kind_String
 }
 func (*_R13String) LookupByString(string) (ipld.Node, error) {
 	return mixins.String{TypeName: "rot13adl.R13String"}.LookupByString("")
diff --git a/adl/rot13adl/rot13node_test.go b/adl/rot13adl/rot13node_test.go
index d72583e4..f0be475d 100644
--- a/adl/rot13adl/rot13node_test.go
+++ b/adl/rot13adl/rot13node_test.go
@@ -40,7 +40,7 @@ func TestReify(t *testing.T) {
 		synth, err := Reify(sn)
 		// Inspect the resulting high level node.
 		Require(t, err, ShouldEqual, nil)
-		Wish(t, synth.ReprKind(), ShouldEqual, ipld.ReprKind_String)
+		Wish(t, synth.Kind(), ShouldEqual, ipld.Kind_String)
 		s, err := synth.AsString()
 		Wish(t, err, ShouldEqual, nil)
 		Wish(t, s, ShouldEqual, "abcd")
@@ -54,7 +54,7 @@ func TestReify(t *testing.T) {
 		synth, err := Reify(sn)
 		// Inspect the resulting high level node.
 		Require(t, err, ShouldEqual, nil)
-		Wish(t, synth.ReprKind(), ShouldEqual, ipld.ReprKind_String)
+		Wish(t, synth.Kind(), ShouldEqual, ipld.Kind_String)
 		s, err := synth.AsString()
 		Wish(t, err, ShouldEqual, nil)
 		Wish(t, s, ShouldEqual, "abcd")
diff --git a/adl/rot13adl/rot13substrate.go b/adl/rot13adl/rot13substrate.go
index 2c18f968..a28605ee 100644
--- a/adl/rot13adl/rot13substrate.go
+++ b/adl/rot13adl/rot13substrate.go
@@ -30,8 +30,8 @@ type _Substrate _R13String
 //  and I'm not sure what, if any, suffix actually makes meaningful sense to a user either.
 //  I added the segment ".internal." to the middle of the name mangle; does this seem helpful?
 
-func (*_Substrate) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_String
+func (*_Substrate) Kind() ipld.Kind {
+	return ipld.Kind_String
 }
 func (*_Substrate) LookupByString(string) (ipld.Node, error) {
 	return mixins.String{TypeName: "rot13adl.internal.Substrate"}.LookupByString("")
diff --git a/codec/codectools/token_producers.go b/codec/codectools/token_producers.go
index 158da063..0fe1ab31 100644
--- a/codec/codectools/token_producers.go
+++ b/codec/codectools/token_producers.go
@@ -40,8 +40,8 @@ func TokenWalk(n ipld.Node, visitFn func(tk *Token) error) error {
 }
 
 func tokenWalk(tk *Token, n ipld.Node, visitFn func(*Token) error) error {
-	switch n.ReprKind() {
-	case ipld.ReprKind_Map:
+	switch n.Kind() {
+	case ipld.Kind_Map:
 		tk.Kind = TokenKind_MapOpen
 		tk.Length = n.Length()
 		tk.Node = n
@@ -64,7 +64,7 @@ func tokenWalk(tk *Token, n ipld.Node, visitFn func(*Token) error) error {
 		tk.Kind = TokenKind_MapClose
 		tk.Node = n
 		return visitFn(tk)
-	case ipld.ReprKind_List:
+	case ipld.Kind_List:
 		tk.Kind = TokenKind_ListOpen
 		tk.Length = n.Length()
 		tk.Node = n
@@ -84,36 +84,36 @@ func tokenWalk(tk *Token, n ipld.Node, visitFn func(*Token) error) error {
 		tk.Kind = TokenKind_ListClose
 		tk.Node = n
 		return visitFn(tk)
-	case ipld.ReprKind_Null:
+	case ipld.Kind_Null:
 		tk.Kind = TokenKind_Null
 		return visitFn(tk)
-	case ipld.ReprKind_Bool:
+	case ipld.Kind_Bool:
 		tk.Kind = TokenKind_Bool
 		tk.Bool, _ = n.AsBool()
 		return visitFn(tk)
-	case ipld.ReprKind_Int:
+	case ipld.Kind_Int:
 		tk.Kind = TokenKind_Int
 		i, _ := n.AsInt()
 		tk.Int = int64(i) // TODO: upgrade all of ipld to use high precision int consistently
 		return visitFn(tk)
-	case ipld.ReprKind_Float:
+	case ipld.Kind_Float:
 		tk.Kind = TokenKind_Float
 		tk.Float, _ = n.AsFloat()
 		return visitFn(tk)
-	case ipld.ReprKind_String:
+	case ipld.Kind_String:
 		tk.Kind = TokenKind_String
 		tk.Str, _ = n.AsString()
 		return visitFn(tk)
-	case ipld.ReprKind_Bytes:
+	case ipld.Kind_Bytes:
 		tk.Kind = TokenKind_Bytes
 		tk.Bytes, _ = n.AsBytes()
 		return visitFn(tk)
-	case ipld.ReprKind_Link:
+	case ipld.Kind_Link:
 		tk.Kind = TokenKind_Link
 		tk.Link, _ = n.AsLink()
 		return visitFn(tk)
 	default:
-		panic(fmt.Errorf("unrecognized node kind (%q?)", n.ReprKind()))
+		panic(fmt.Errorf("unrecognized node kind (%q?)", n.Kind()))
 	}
 	return nil
 }
@@ -195,58 +195,58 @@ func (nt *NodeTokenizer) ReadToken() (next *Token, err error) {
 	tip := nt.stk.Tip()
 	switch tip.state {
 	case 0:
-		switch tip.n.ReprKind() {
-		case ipld.ReprKind_Map:
+		switch tip.n.Kind() {
+		case ipld.Kind_Map:
 			nt.tk.Kind = TokenKind_MapOpen
 			nt.tk.Length = tip.n.Length()
 			nt.tk.Node = tip.n
 			tip.state = 2
 			tip.mitr = tip.n.MapIterator()
 			return &nt.tk, nil
-		case ipld.ReprKind_List:
+		case ipld.Kind_List:
 			nt.tk.Kind = TokenKind_ListOpen
 			nt.tk.Length = tip.n.Length()
 			nt.tk.Node = tip.n
 			tip.state = 1
 			tip.litr = tip.n.ListIterator()
 			return &nt.tk, nil
-		case ipld.ReprKind_Null:
+		case ipld.Kind_Null:
 			nt.tk.Kind = TokenKind_Null
 			nt.stk.Pop()
 			return &nt.tk, nil
-		case ipld.ReprKind_Bool:
+		case ipld.Kind_Bool:
 			nt.tk.Kind = TokenKind_Bool
 			nt.tk.Bool, _ = tip.n.AsBool()
 			nt.stk.Pop()
 			return &nt.tk, nil
-		case ipld.ReprKind_Int:
+		case ipld.Kind_Int:
 			nt.tk.Kind = TokenKind_Int
 			i, _ := tip.n.AsInt()
 			nt.tk.Int = int64(i) // TODO: upgrade all of ipld to use high precision int consistently
 			nt.stk.Pop()
 			return &nt.tk, nil
-		case ipld.ReprKind_Float:
+		case ipld.Kind_Float:
 			nt.tk.Kind = TokenKind_Float
 			nt.tk.Float, _ = tip.n.AsFloat()
 			nt.stk.Pop()
 			return &nt.tk, nil
-		case ipld.ReprKind_String:
+		case ipld.Kind_String:
 			nt.tk.Kind = TokenKind_String
 			nt.tk.Str, _ = tip.n.AsString()
 			nt.stk.Pop()
 			return &nt.tk, nil
-		case ipld.ReprKind_Bytes:
+		case ipld.Kind_Bytes:
 			nt.tk.Kind = TokenKind_Bytes
 			nt.tk.Bytes, _ = tip.n.AsBytes()
 			nt.stk.Pop()
 			return &nt.tk, nil
-		case ipld.ReprKind_Link:
+		case ipld.Kind_Link:
 			nt.tk.Kind = TokenKind_Link
 			nt.tk.Link, _ = tip.n.AsLink()
 			nt.stk.Pop()
 			return &nt.tk, nil
 		default:
-			panic(fmt.Errorf("unrecognized node kind (%q?)", tip.n.ReprKind()))
+			panic(fmt.Errorf("unrecognized node kind (%q?)", tip.n.Kind()))
 		}
 	case 1:
 		if tip.litr.Done() {
diff --git a/codec/dagcbor/marshal.go b/codec/dagcbor/marshal.go
index 8b6675e1..a4db0605 100644
--- a/codec/dagcbor/marshal.go
+++ b/codec/dagcbor/marshal.go
@@ -11,7 +11,7 @@ import (
 )
 
 // This should be identical to the general feature in the parent package,
-// except for the `case ipld.ReprKind_Link` block,
+// except for the `case ipld.Kind_Link` block,
 // which is dag-cbor's special sauce for schemafree links.
 func Marshal(n ipld.Node, sink shared.TokenSink) error {
 	var tk tok.Token
@@ -19,14 +19,14 @@ func Marshal(n ipld.Node, sink shared.TokenSink) error {
 }
 
 func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
-	switch n.ReprKind() {
-	case ipld.ReprKind_Invalid:
+	switch n.Kind() {
+	case ipld.Kind_Invalid:
 		return fmt.Errorf("cannot traverse a node that is absent")
-	case ipld.ReprKind_Null:
+	case ipld.Kind_Null:
 		tk.Type = tok.TNull
 		_, err := sink.Step(tk)
 		return err
-	case ipld.ReprKind_Map:
+	case ipld.Kind_Map:
 		// Emit start of map.
 		tk.Type = tok.TMapOpen
 		tk.Length = int(n.Length()) // TODO: overflow check
@@ -55,7 +55,7 @@ func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
 		tk.Type = tok.TMapClose
 		_, err := sink.Step(tk)
 		return err
-	case ipld.ReprKind_List:
+	case ipld.Kind_List:
 		// Emit start of list.
 		tk.Type = tok.TArrOpen
 		l := n.Length()
@@ -77,7 +77,7 @@ func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
 		tk.Type = tok.TArrClose
 		_, err := sink.Step(tk)
 		return err
-	case ipld.ReprKind_Bool:
+	case ipld.Kind_Bool:
 		v, err := n.AsBool()
 		if err != nil {
 			return err
@@ -86,7 +86,7 @@ func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
 		tk.Bool = v
 		_, err = sink.Step(tk)
 		return err
-	case ipld.ReprKind_Int:
+	case ipld.Kind_Int:
 		v, err := n.AsInt()
 		if err != nil {
 			return err
@@ -95,7 +95,7 @@ func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
 		tk.Int = int64(v)
 		_, err = sink.Step(tk)
 		return err
-	case ipld.ReprKind_Float:
+	case ipld.Kind_Float:
 		v, err := n.AsFloat()
 		if err != nil {
 			return err
@@ -104,7 +104,7 @@ func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
 		tk.Float64 = v
 		_, err = sink.Step(tk)
 		return err
-	case ipld.ReprKind_String:
+	case ipld.Kind_String:
 		v, err := n.AsString()
 		if err != nil {
 			return err
@@ -113,7 +113,7 @@ func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
 		tk.Str = v
 		_, err = sink.Step(tk)
 		return err
-	case ipld.ReprKind_Bytes:
+	case ipld.Kind_Bytes:
 		v, err := n.AsBytes()
 		if err != nil {
 			return err
@@ -122,7 +122,7 @@ func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
 		tk.Bytes = v
 		_, err = sink.Step(tk)
 		return err
-	case ipld.ReprKind_Link:
+	case ipld.Kind_Link:
 		v, err := n.AsLink()
 		if err != nil {
 			return err
diff --git a/codec/dagjson/marshal.go b/codec/dagjson/marshal.go
index f9ab3e10..a17bd3c9 100644
--- a/codec/dagjson/marshal.go
+++ b/codec/dagjson/marshal.go
@@ -11,19 +11,19 @@ import (
 )
 
 // This should be identical to the general feature in the parent package,
-// except for the `case ipld.ReprKind_Link` block,
+// except for the `case ipld.Kind_Link` block,
 // which is dag-json's special sauce for schemafree links.
 
 func Marshal(n ipld.Node, sink shared.TokenSink) error {
 	var tk tok.Token
-	switch n.ReprKind() {
-	case ipld.ReprKind_Invalid:
+	switch n.Kind() {
+	case ipld.Kind_Invalid:
 		return fmt.Errorf("cannot traverse a node that is absent")
-	case ipld.ReprKind_Null:
+	case ipld.Kind_Null:
 		tk.Type = tok.TNull
 		_, err := sink.Step(&tk)
 		return err
-	case ipld.ReprKind_Map:
+	case ipld.Kind_Map:
 		// Emit start of map.
 		tk.Type = tok.TMapOpen
 		tk.Length = int(n.Length()) // TODO: overflow check
@@ -52,7 +52,7 @@ func Marshal(n ipld.Node, sink shared.TokenSink) error {
 		tk.Type = tok.TMapClose
 		_, err := sink.Step(&tk)
 		return err
-	case ipld.ReprKind_List:
+	case ipld.Kind_List:
 		// Emit start of list.
 		tk.Type = tok.TArrOpen
 		l := n.Length()
@@ -74,7 +74,7 @@ func Marshal(n ipld.Node, sink shared.TokenSink) error {
 		tk.Type = tok.TArrClose
 		_, err := sink.Step(&tk)
 		return err
-	case ipld.ReprKind_Bool:
+	case ipld.Kind_Bool:
 		v, err := n.AsBool()
 		if err != nil {
 			return err
@@ -83,7 +83,7 @@ func Marshal(n ipld.Node, sink shared.TokenSink) error {
 		tk.Bool = v
 		_, err = sink.Step(&tk)
 		return err
-	case ipld.ReprKind_Int:
+	case ipld.Kind_Int:
 		v, err := n.AsInt()
 		if err != nil {
 			return err
@@ -92,7 +92,7 @@ func Marshal(n ipld.Node, sink shared.TokenSink) error {
 		tk.Int = int64(v)
 		_, err = sink.Step(&tk)
 		return err
-	case ipld.ReprKind_Float:
+	case ipld.Kind_Float:
 		v, err := n.AsFloat()
 		if err != nil {
 			return err
@@ -101,7 +101,7 @@ func Marshal(n ipld.Node, sink shared.TokenSink) error {
 		tk.Float64 = v
 		_, err = sink.Step(&tk)
 		return err
-	case ipld.ReprKind_String:
+	case ipld.Kind_String:
 		v, err := n.AsString()
 		if err != nil {
 			return err
@@ -110,7 +110,7 @@ func Marshal(n ipld.Node, sink shared.TokenSink) error {
 		tk.Str = v
 		_, err = sink.Step(&tk)
 		return err
-	case ipld.ReprKind_Bytes:
+	case ipld.Kind_Bytes:
 		v, err := n.AsBytes()
 		if err != nil {
 			return err
@@ -119,7 +119,7 @@ func Marshal(n ipld.Node, sink shared.TokenSink) error {
 		tk.Bytes = v
 		_, err = sink.Step(&tk)
 		return err
-	case ipld.ReprKind_Link:
+	case ipld.Kind_Link:
 		v, err := n.AsLink()
 		if err != nil {
 			return err
diff --git a/codec/dagjson/roundtripCidlink_test.go b/codec/dagjson/roundtripCidlink_test.go
index eb16294f..58b894a8 100644
--- a/codec/dagjson/roundtripCidlink_test.go
+++ b/codec/dagjson/roundtripCidlink_test.go
@@ -68,8 +68,8 @@ func TestUnmarshalTrickyMapContainingLink(t *testing.T) {
 	err = Decoder(nb, strings.NewReader(tricky))
 	Require(t, err, ShouldEqual, nil)
 	n := nb.Build()
-	Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+	Wish(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 	n2, err := n.LookupByString("/")
 	Require(t, err, ShouldEqual, nil)
-	Wish(t, n2.ReprKind(), ShouldEqual, ipld.ReprKind_Link)
+	Wish(t, n2.Kind(), ShouldEqual, ipld.Kind_Link)
 }
diff --git a/codec/jst/jst.go b/codec/jst/jst.go
index fc4694b8..ea5c09b7 100644
--- a/codec/jst/jst.go
+++ b/codec/jst/jst.go
@@ -177,8 +177,8 @@ func (tab *table) IsRow(n ipld.Node) bool {
 	// FUTURE: this entire function's behavior might be *heavily* redirected by config.
 	//  Having it attached to the table struct might not even be sensible by the end of the day.
 	//  Alternately: unclear if we need this function at all, if the "trailing" and "ownLine" entryStyle can simply carry the day for all userstories like comments and etc.
-	switch n.ReprKind() {
-	case ipld.ReprKind_Map:
+	switch n.Kind() {
+	case ipld.Kind_Map:
 		if n.Length() < 1 {
 			return false
 		}
@@ -188,7 +188,7 @@ func (tab *table) IsRow(n ipld.Node) bool {
 			return true
 		}
 		return columnName(ks) == tab.cols[0]
-	case ipld.ReprKind_List:
+	case ipld.Kind_List:
 		// FUTURE: maybe this could be 'true', but it requires very different logic.  And it's not in my first-draft pareto priority choices.
 		return false
 	default:
@@ -202,16 +202,16 @@ func (tab *table) IsRow(n ipld.Node) bool {
 func peekMightBeTable(ctx *state, n ipld.Node) (bool, tableGroupID) {
 	// FUTURE: might need to apply a selector or other rules from ctx.cfg to say additonal "no"s.
 	// FUTURE: the ctx.cfg can also override what the tableGroupID is.
-	switch n.ReprKind() {
-	case ipld.ReprKind_Map:
+	switch n.Kind() {
+	case ipld.Kind_Map:
 		// TODO: maps can definitely be tables!  but gonna come back to this.  and by default, they're not.
 		return false, ""
-	case ipld.ReprKind_List:
+	case ipld.Kind_List:
 		if n.Length() < 1 {
 			return false, ""
 		}
 		n0, _ := n.LookupByIndex(0)
-		if n0.ReprKind() != ipld.ReprKind_Map {
+		if n0.Kind() != ipld.Kind_Map {
 			return false, ""
 		}
 		if n0.Length() < 1 {
@@ -228,10 +228,10 @@ func peekMightBeTable(ctx *state, n ipld.Node) (bool, tableGroupID) {
 //  some row values might themselves be tables,
 //   which removes them from the column flow and changes our size counting).
 func stride(ctx *state, n ipld.Node) error {
-	switch n.ReprKind() {
-	case ipld.ReprKind_Map:
+	switch n.Kind() {
+	case ipld.Kind_Map:
 		panic("todo")
-	case ipld.ReprKind_List:
+	case ipld.Kind_List:
 		return strideList(ctx, n)
 	default:
 		// There's never anything we need to record for scalars that their parents don't already note.
@@ -283,10 +283,10 @@ func strideList(ctx *state, listNode ipld.Node) error {
 }
 
 func marshal(ctx *state, n ipld.Node, w io.Writer) error {
-	switch n.ReprKind() {
-	case ipld.ReprKind_Map:
+	switch n.Kind() {
+	case ipld.Kind_Map:
 		panic("todo")
-	case ipld.ReprKind_List:
+	case ipld.Kind_List:
 		return marshalList(ctx, n, w)
 	default:
 		return marshalPlain(ctx, n, w)
@@ -335,7 +335,7 @@ func marshalList(ctx *state, listNode ipld.Node, w io.Writer) error {
 	return nil
 }
 func marshalListValue(ctx *state, tab *table, row ipld.Node, w io.Writer) error {
-	if row.ReprKind() != ipld.ReprKind_Map {
+	if row.Kind() != ipld.Kind_Map {
 		// TODO make this a lot more open... scalars aren't exactly "rows" for example but we can surely print them just fine.
 		panic("table rows can only be maps at present")
 	}
diff --git a/codec/marshal.go b/codec/marshal.go
index 08ddaf41..2b2eb5c6 100644
--- a/codec/marshal.go
+++ b/codec/marshal.go
@@ -23,14 +23,14 @@ func Marshal(n ipld.Node, sink shared.TokenSink) error {
 }
 
 func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
-	switch n.ReprKind() {
-	case ipld.ReprKind_Invalid:
+	switch n.Kind() {
+	case ipld.Kind_Invalid:
 		return fmt.Errorf("cannot traverse a node that is absent")
-	case ipld.ReprKind_Null:
+	case ipld.Kind_Null:
 		tk.Type = tok.TNull
 		_, err := sink.Step(tk)
 		return err
-	case ipld.ReprKind_Map:
+	case ipld.Kind_Map:
 		// Emit start of map.
 		tk.Type = tok.TMapOpen
 		tk.Length = int(n.Length()) // TODO: overflow check
@@ -59,7 +59,7 @@ func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
 		tk.Type = tok.TMapClose
 		_, err := sink.Step(tk)
 		return err
-	case ipld.ReprKind_List:
+	case ipld.Kind_List:
 		// Emit start of list.
 		tk.Type = tok.TArrOpen
 		l := n.Length()
@@ -81,7 +81,7 @@ func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
 		tk.Type = tok.TArrClose
 		_, err := sink.Step(tk)
 		return err
-	case ipld.ReprKind_Bool:
+	case ipld.Kind_Bool:
 		v, err := n.AsBool()
 		if err != nil {
 			return err
@@ -90,7 +90,7 @@ func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
 		tk.Bool = v
 		_, err = sink.Step(tk)
 		return err
-	case ipld.ReprKind_Int:
+	case ipld.Kind_Int:
 		v, err := n.AsInt()
 		if err != nil {
 			return err
@@ -99,7 +99,7 @@ func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
 		tk.Int = int64(v)
 		_, err = sink.Step(tk)
 		return err
-	case ipld.ReprKind_Float:
+	case ipld.Kind_Float:
 		v, err := n.AsFloat()
 		if err != nil {
 			return err
@@ -108,7 +108,7 @@ func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
 		tk.Float64 = v
 		_, err = sink.Step(tk)
 		return err
-	case ipld.ReprKind_String:
+	case ipld.Kind_String:
 		v, err := n.AsString()
 		if err != nil {
 			return err
@@ -117,7 +117,7 @@ func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
 		tk.Str = v
 		_, err = sink.Step(tk)
 		return err
-	case ipld.ReprKind_Bytes:
+	case ipld.Kind_Bytes:
 		v, err := n.AsBytes()
 		if err != nil {
 			return err
@@ -126,7 +126,7 @@ func marshal(n ipld.Node, tk *tok.Token, sink shared.TokenSink) error {
 		tk.Bytes = v
 		_, err = sink.Step(tk)
 		return err
-	case ipld.ReprKind_Link:
+	case ipld.Kind_Link:
 		return fmt.Errorf("link emission not supported by this codec without a schema!  (maybe you want dag-cbor or dag-json)")
 	default:
 		panic("unreachable")
diff --git a/errors.go b/errors.go
index 6afda959..bb839aca 100644
--- a/errors.go
+++ b/errors.go
@@ -6,8 +6,8 @@ import (
 )
 
 // ErrWrongKind may be returned from functions on the Node interface when
-// a method is invoked which doesn't make sense for the Kind and/or ReprKind
-// that node concretely contains.
+// a method is invoked which doesn't make sense for the Kind that node
+// concretely contains.
 //
 // For example, calling AsString on a map will return ErrWrongKind.
 // Calling Lookup on an int will similarly return ErrWrongKind.
@@ -22,15 +22,15 @@ type ErrWrongKind struct {
 	// For methods on nodebuilders, we say e.g. "NodeBuilder.CreateMap".
 	MethodName string
 
-	// ApprorpriateKind describes which ReprKinds the erroring method would
+	// ApprorpriateKind describes which Kinds the erroring method would
 	// make sense for.
-	AppropriateKind ReprKindSet
+	AppropriateKind KindSet
 
-	// ActualKind describes the ReprKind of the node the method was called on.
+	// ActualKind describes the Kind of the node the method was called on.
 	//
 	// In the case of typed nodes, this will typically refer to the 'natural'
 	// data-model kind for such a type (e.g., structs will say 'map' here).
-	ActualKind ReprKind
+	ActualKind Kind
 }
 
 func (e ErrWrongKind) Error() string {
diff --git a/exampleLinking_test.go b/exampleLinking_test.go
index 1eb24124..db75799e 100644
--- a/exampleLinking_test.go
+++ b/exampleLinking_test.go
@@ -110,7 +110,7 @@ func ExampleLoadingLink() {
 	n := nb.Build()
 
 	// Tada!  We have the data as node that we can traverse and use as desired.
-	fmt.Printf("we loaded a %s with %d entries\n", n.ReprKind(), n.Length())
+	fmt.Printf("we loaded a %s with %d entries\n", n.Kind(), n.Length())
 
 	// Output:
 	// we loaded a map with 1 entries
diff --git a/examples_test.go b/examples_test.go
index 2de15937..54a43662 100644
--- a/examples_test.go
+++ b/examples_test.go
@@ -38,7 +38,7 @@ func ExampleUnmarshalData() {
 	dagjson.Decoder(nb, serial)   // Hand the builder to decoding -- decoding will fill it in!
 	n := nb.Build()               // Call 'Build' to get the resulting Node.  (It's immutable!)
 
-	fmt.Printf("the data decoded was a %s kind\n", n.ReprKind())
+	fmt.Printf("the data decoded was a %s kind\n", n.Kind())
 	fmt.Printf("the length of the node is %d\n", n.Length())
 
 	// Output:
diff --git a/fluent/fluentBuilder_test.go b/fluent/fluentBuilder_test.go
index 3628c959..1306a30b 100644
--- a/fluent/fluentBuilder_test.go
+++ b/fluent/fluentBuilder_test.go
@@ -16,7 +16,7 @@ func TestBuild(t *testing.T) {
 		n := fluent.MustBuild(basicnode.Prototype__String{}, func(fna fluent.NodeAssembler) {
 			fna.AssignString("fine")
 		})
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_String)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_String)
 		v2, err := n.AsString()
 		Wish(t, err, ShouldEqual, nil)
 		Wish(t, v2, ShouldEqual, "fine")
@@ -33,7 +33,7 @@ func TestBuild(t *testing.T) {
 				})
 			})
 		})
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 		Wish(t, n.Length(), ShouldEqual, int64(3))
 		Wish(t, must.String(must.Node(n.LookupByString("k1"))), ShouldEqual, "fine")
 		Wish(t, must.String(must.Node(n.LookupByString("k2"))), ShouldEqual, "super")
@@ -55,19 +55,19 @@ func TestBuild(t *testing.T) {
 				})
 			})
 		})
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_List)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_List)
 		Wish(t, n.Length(), ShouldEqual, int64(1))
 		n = must.Node(n.LookupByIndex(0))
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_List)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_List)
 		Wish(t, n.Length(), ShouldEqual, int64(1))
 		n = must.Node(n.LookupByIndex(0))
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_List)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_List)
 		Wish(t, n.Length(), ShouldEqual, int64(1))
 		n = must.Node(n.LookupByIndex(0))
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_List)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_List)
 		Wish(t, n.Length(), ShouldEqual, int64(1))
 		n = must.Node(n.LookupByIndex(0))
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Int)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_Int)
 		Wish(t, must.Int(n), ShouldEqual, int64(2))
 	})
 }
diff --git a/fluent/fluentRecover_test.go b/fluent/fluentRecover_test.go
index b8f5f1bb..975f6d92 100644
--- a/fluent/fluentRecover_test.go
+++ b/fluent/fluentRecover_test.go
@@ -20,7 +20,7 @@ func TestRecover(t *testing.T) {
 				t.Fatal("should not be reached")
 			}),
 			ShouldEqual,
-			fluent.Error{ipld.ErrWrongKind{TypeName: "string", MethodName: "AssignInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_String}},
+			fluent.Error{ipld.ErrWrongKind{TypeName: "string", MethodName: "AssignInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_String}},
 		)
 	})
 	t.Run("correct build should return nil", func(t *testing.T) {
diff --git a/fluent/reflect_test.go b/fluent/reflect_test.go
index 6096a059..1f7f75c6 100644
--- a/fluent/reflect_test.go
+++ b/fluent/reflect_test.go
@@ -23,7 +23,7 @@ func TestReflect(t *testing.T) {
 			},
 		})
 		Wish(t, err, ShouldEqual, nil)
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 		t.Run("CorrectContents", func(t *testing.T) {
 			Wish(t, n.Length(), ShouldEqual, int64(3))
 			Wish(t, must.String(must.Node(n.LookupByString("k1"))), ShouldEqual, "fine")
@@ -67,7 +67,7 @@ func TestReflect(t *testing.T) {
 			M: Woo{"thanks", "really"},
 		})
 		Wish(t, err, ShouldEqual, nil)
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 		t.Run("CorrectContents", func(t *testing.T) {
 			Wish(t, n.Length(), ShouldEqual, int64(3))
 			Wish(t, must.String(must.Node(n.LookupByString("X"))), ShouldEqual, "fine")
@@ -99,7 +99,7 @@ func TestReflect(t *testing.T) {
 		}
 		n, err := fluent.Reflect(basicnode.Prototype.Any, Bar{"foo"})
 		Wish(t, err, ShouldEqual, nil)
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 		Wish(t, must.String(must.Node(n.LookupByString("Z"))), ShouldEqual, "foo")
 	})
 	t.Run("Interface", func(t *testing.T) {
@@ -108,16 +108,16 @@ func TestReflect(t *testing.T) {
 		}
 		n, err := fluent.Reflect(basicnode.Prototype.Any, Zaz{map[string]interface{}{"wow": "wee"}})
 		Wish(t, err, ShouldEqual, nil)
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 		n, err = n.LookupByString("Z")
 		Wish(t, err, ShouldEqual, nil)
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 		Wish(t, must.String(must.Node(n.LookupByString("wow"))), ShouldEqual, "wee")
 	})
 	t.Run("Bytes", func(t *testing.T) {
 		n, err := fluent.Reflect(basicnode.Prototype.Any, []byte{0x1, 0x2, 0x3})
 		Wish(t, err, ShouldEqual, nil)
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Bytes)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_Bytes)
 		b, err := n.AsBytes()
 		Wish(t, err, ShouldEqual, nil)
 		Wish(t, b, ShouldEqual, []byte{0x1, 0x2, 0x3})
@@ -129,10 +129,10 @@ func TestReflect(t *testing.T) {
 		}
 		n, err := fluent.Reflect(basicnode.Prototype.Any, Bar{[]byte{0x1, 0x2, 0x3}})
 		Wish(t, err, ShouldEqual, nil)
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 		n, err = n.LookupByString("Z")
 		Wish(t, err, ShouldEqual, nil)
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Bytes)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_Bytes)
 		b, err := n.AsBytes()
 		Wish(t, err, ShouldEqual, nil)
 		Wish(t, b, ShouldEqual, []byte{0x1, 0x2, 0x3})
@@ -143,10 +143,10 @@ func TestReflect(t *testing.T) {
 		}
 		n, err := fluent.Reflect(basicnode.Prototype.Any, Zaz{[]byte{0x1, 0x2, 0x3}})
 		Wish(t, err, ShouldEqual, nil)
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 		n, err = n.LookupByString("Z")
 		Wish(t, err, ShouldEqual, nil)
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Bytes)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_Bytes)
 		b, err := n.AsBytes()
 		Wish(t, err, ShouldEqual, nil)
 		Wish(t, b, ShouldEqual, []byte{0x1, 0x2, 0x3})
diff --git a/kind.go b/kind.go
index 9f53ae47..3e5e1af3 100644
--- a/kind.go
+++ b/kind.go
@@ -1,74 +1,74 @@
 package ipld
 
-// ReprKind represents the primitive kind in the IPLD data model.
+// Kind represents the primitive kind in the IPLD data model.
 // All of these kinds map directly onto serializable data.
 //
-// Note that ReprKind contains the concept of "map", but not "struct"
+// Note that Kind contains the concept of "map", but not "struct"
 // or "object" -- those are a concepts that could be introduced in a
 // type system layers, but are *not* present in the data model layer,
-// and therefore they aren't included in the ReprKind enum.
-type ReprKind uint8
+// and therefore they aren't included in the Kind enum.
+type Kind uint8
 
 const (
-	ReprKind_Invalid ReprKind = 0
-	ReprKind_Map     ReprKind = '{'
-	ReprKind_List    ReprKind = '['
-	ReprKind_Null    ReprKind = '0'
-	ReprKind_Bool    ReprKind = 'b'
-	ReprKind_Int     ReprKind = 'i'
-	ReprKind_Float   ReprKind = 'f'
-	ReprKind_String  ReprKind = 's'
-	ReprKind_Bytes   ReprKind = 'x'
-	ReprKind_Link    ReprKind = '/'
+	Kind_Invalid Kind = 0
+	Kind_Map     Kind = '{'
+	Kind_List    Kind = '['
+	Kind_Null    Kind = '0'
+	Kind_Bool    Kind = 'b'
+	Kind_Int     Kind = 'i'
+	Kind_Float   Kind = 'f'
+	Kind_String  Kind = 's'
+	Kind_Bytes   Kind = 'x'
+	Kind_Link    Kind = '/'
 )
 
-func (k ReprKind) String() string {
+func (k Kind) String() string {
 	switch k {
-	case ReprKind_Invalid:
+	case Kind_Invalid:
 		return "INVALID"
-	case ReprKind_Map:
+	case Kind_Map:
 		return "map"
-	case ReprKind_List:
+	case Kind_List:
 		return "list"
-	case ReprKind_Null:
+	case Kind_Null:
 		return "null"
-	case ReprKind_Bool:
+	case Kind_Bool:
 		return "bool"
-	case ReprKind_Int:
+	case Kind_Int:
 		return "int"
-	case ReprKind_Float:
+	case Kind_Float:
 		return "float"
-	case ReprKind_String:
+	case Kind_String:
 		return "string"
-	case ReprKind_Bytes:
+	case Kind_Bytes:
 		return "bytes"
-	case ReprKind_Link:
+	case Kind_Link:
 		return "link"
 	default:
 		panic("invalid enumeration value!")
 	}
 }
 
-// ReprKindSet is a type with a few enumerated consts that are commonly used
+// KindSet is a type with a few enumerated consts that are commonly used
 // (mostly, in error messages).
-type ReprKindSet []ReprKind
+type KindSet []Kind
 
 var (
-	ReprKindSet_Recursive = ReprKindSet{ReprKind_Map, ReprKind_List}
-	ReprKindSet_Scalar    = ReprKindSet{ReprKind_Null, ReprKind_Bool, ReprKind_Int, ReprKind_Float, ReprKind_String, ReprKind_Bytes, ReprKind_Link}
+	KindSet_Recursive = KindSet{Kind_Map, Kind_List}
+	KindSet_Scalar    = KindSet{Kind_Null, Kind_Bool, Kind_Int, Kind_Float, Kind_String, Kind_Bytes, Kind_Link}
 
-	ReprKindSet_JustMap    = ReprKindSet{ReprKind_Map}
-	ReprKindSet_JustList   = ReprKindSet{ReprKind_List}
-	ReprKindSet_JustNull   = ReprKindSet{ReprKind_Null}
-	ReprKindSet_JustBool   = ReprKindSet{ReprKind_Bool}
-	ReprKindSet_JustInt    = ReprKindSet{ReprKind_Int}
-	ReprKindSet_JustFloat  = ReprKindSet{ReprKind_Float}
-	ReprKindSet_JustString = ReprKindSet{ReprKind_String}
-	ReprKindSet_JustBytes  = ReprKindSet{ReprKind_Bytes}
-	ReprKindSet_JustLink   = ReprKindSet{ReprKind_Link}
+	KindSet_JustMap    = KindSet{Kind_Map}
+	KindSet_JustList   = KindSet{Kind_List}
+	KindSet_JustNull   = KindSet{Kind_Null}
+	KindSet_JustBool   = KindSet{Kind_Bool}
+	KindSet_JustInt    = KindSet{Kind_Int}
+	KindSet_JustFloat  = KindSet{Kind_Float}
+	KindSet_JustString = KindSet{Kind_String}
+	KindSet_JustBytes  = KindSet{Kind_Bytes}
+	KindSet_JustLink   = KindSet{Kind_Link}
 )
 
-func (x ReprKindSet) String() string {
+func (x KindSet) String() string {
 	s := ""
 	for i := 0; i < len(x)-1; i++ {
 		s += x[i].String() + " or "
@@ -77,7 +77,7 @@ func (x ReprKindSet) String() string {
 	return s
 }
 
-func (x ReprKindSet) Contains(e ReprKind) bool {
+func (x KindSet) Contains(e Kind) bool {
 	for _, v := range x {
 		if v == e {
 			return true
diff --git a/node.go b/node.go
index 7f7b3962..e7b051c2 100644
--- a/node.go
+++ b/node.go
@@ -12,7 +12,7 @@ package ipld
 // and thus will only make sense to call on values of the appropriate kind.
 // (For example, 'Length' on an integer doesn't make sense,
 // and 'AsInt' on a map certainly doesn't work either!)
-// Use the ReprKind method to find out the kind of value before
+// Use the Kind method to find out the kind of value before
 // calling kind-specific methods.
 // Individual method documentation state which kinds the method is valid for.
 // (If you're familiar with the stdlib reflect package, you'll find
@@ -56,16 +56,16 @@ package ipld
 // in all ways this interface specifies (so you can traverse typed nodes, etc,
 // without any additional special effort).
 type Node interface {
-	// ReprKind returns a value from the ReprKind enum describing what the
+	// Kind returns a value from the Kind enum describing what the
 	// essential serializable kind of this node is (map, list, integer, etc).
 	// Most other handling of a node requires first switching upon the kind.
-	ReprKind() ReprKind
+	Kind() Kind
 
 	// LookupByString looks up a child object in this node and returns it.
-	// The returned Node may be any of the ReprKind:
+	// The returned Node may be any of the Kind:
 	// a primitive (string, int64, etc), a map, a list, or a link.
 	//
-	// If the Kind of this Node is not ReprKind_Map, a nil node and an error
+	// If the Kind of this Node is not Kind_Map, a nil node and an error
 	// will be returned.
 	//
 	// If the key does not exist, a nil node and an error will be returned.
@@ -85,10 +85,10 @@ type Node interface {
 	LookupByNode(key Node) (Node, error)
 
 	// LookupByIndex is the equivalent of LookupByString but for indexing into a list.
-	// As with LookupByString, the returned Node may be any of the ReprKind:
+	// As with LookupByString, the returned Node may be any of the Kind:
 	// a primitive (string, int64, etc), a map, a list, or a link.
 	//
-	// If the Kind of this Node is not ReprKind_List, a nil node and an error
+	// If the Kind of this Node is not Kind_List, a nil node and an error
 	// will be returned.
 	//
 	// If idx is out of range, a nil node and an error will be returned.
@@ -134,7 +134,7 @@ type Node interface {
 	// unambiguously make the distinction between values that are
 	// present-and-null versus values that are absent.
 	//
-	// Absent nodes respond to `ReprKind()` as `ipld.ReprKind_Null`,
+	// Absent nodes respond to `Kind()` as `ipld.Kind_Null`,
 	// for lack of any better descriptive value; you should therefore
 	// always check IsAbsent rather than just a switch on kind
 	// when it may be important to handle absent values distinctly.
diff --git a/node/basic/any.go b/node/basic/any.go
index f97c0373..ce64152c 100644
--- a/node/basic/any.go
+++ b/node/basic/any.go
@@ -17,7 +17,7 @@ var (
 // REVIEW: if there's any point in keeping this around.  It's here for completeness,
 // but not currently used anywhere in package, and also not currently exported.
 // type anyNode struct {
-// 	kind ipld.ReprKind
+// 	kind ipld.Kind
 //
 // 	plainMap
 // 	plainList
@@ -57,7 +57,7 @@ type anyBuilder struct {
 	// kind is set on first interaction, and used to select which builder to delegate 'Build' to!
 	// As soon as it's been set to a value other than zero (being "Invalid"), all other Assign/Begin calls will fail since something is already in progress.
 	// May also be set to the magic value '99', which means "i dunno, I'm just carrying another node of unknown prototype".
-	kind ipld.ReprKind
+	kind ipld.Kind
 
 	// Only one of the following ends up being used...
 	//  but we don't know in advance which one, so all are embeded here.
@@ -78,78 +78,78 @@ func (nb *anyBuilder) Reset() {
 }
 
 func (nb *anyBuilder) BeginMap(sizeHint int64) (ipld.MapAssembler, error) {
-	if nb.kind != ipld.ReprKind_Invalid {
+	if nb.kind != ipld.Kind_Invalid {
 		panic("misuse")
 	}
-	nb.kind = ipld.ReprKind_Map
+	nb.kind = ipld.Kind_Map
 	nb.mapBuilder.w = &plainMap{}
 	return nb.mapBuilder.BeginMap(sizeHint)
 }
 func (nb *anyBuilder) BeginList(sizeHint int64) (ipld.ListAssembler, error) {
-	if nb.kind != ipld.ReprKind_Invalid {
+	if nb.kind != ipld.Kind_Invalid {
 		panic("misuse")
 	}
-	nb.kind = ipld.ReprKind_List
+	nb.kind = ipld.Kind_List
 	nb.listBuilder.w = &plainList{}
 	return nb.listBuilder.BeginList(sizeHint)
 }
 func (nb *anyBuilder) AssignNull() error {
-	if nb.kind != ipld.ReprKind_Invalid {
+	if nb.kind != ipld.Kind_Invalid {
 		panic("misuse")
 	}
-	nb.kind = ipld.ReprKind_Null
+	nb.kind = ipld.Kind_Null
 	return nil
 }
 func (nb *anyBuilder) AssignBool(v bool) error {
-	if nb.kind != ipld.ReprKind_Invalid {
+	if nb.kind != ipld.Kind_Invalid {
 		panic("misuse")
 	}
-	nb.kind = ipld.ReprKind_Bool
+	nb.kind = ipld.Kind_Bool
 	nb.scalarNode = NewBool(v)
 	return nil
 }
 func (nb *anyBuilder) AssignInt(v int64) error {
-	if nb.kind != ipld.ReprKind_Invalid {
+	if nb.kind != ipld.Kind_Invalid {
 		panic("misuse")
 	}
-	nb.kind = ipld.ReprKind_Int
+	nb.kind = ipld.Kind_Int
 	nb.scalarNode = NewInt(v)
 	return nil
 }
 func (nb *anyBuilder) AssignFloat(v float64) error {
-	if nb.kind != ipld.ReprKind_Invalid {
+	if nb.kind != ipld.Kind_Invalid {
 		panic("misuse")
 	}
-	nb.kind = ipld.ReprKind_Float
+	nb.kind = ipld.Kind_Float
 	nb.scalarNode = NewFloat(v)
 	return nil
 }
 func (nb *anyBuilder) AssignString(v string) error {
-	if nb.kind != ipld.ReprKind_Invalid {
+	if nb.kind != ipld.Kind_Invalid {
 		panic("misuse")
 	}
-	nb.kind = ipld.ReprKind_String
+	nb.kind = ipld.Kind_String
 	nb.scalarNode = NewString(v)
 	return nil
 }
 func (nb *anyBuilder) AssignBytes(v []byte) error {
-	if nb.kind != ipld.ReprKind_Invalid {
+	if nb.kind != ipld.Kind_Invalid {
 		panic("misuse")
 	}
-	nb.kind = ipld.ReprKind_Bytes
+	nb.kind = ipld.Kind_Bytes
 	nb.scalarNode = NewBytes(v)
 	return nil
 }
 func (nb *anyBuilder) AssignLink(v ipld.Link) error {
-	if nb.kind != ipld.ReprKind_Invalid {
+	if nb.kind != ipld.Kind_Invalid {
 		panic("misuse")
 	}
-	nb.kind = ipld.ReprKind_Link
+	nb.kind = ipld.Kind_Link
 	nb.scalarNode = NewLink(v)
 	return nil
 }
 func (nb *anyBuilder) ConvertFrom(v ipld.Node) error {
-	if nb.kind != ipld.ReprKind_Invalid {
+	if nb.kind != ipld.Kind_Invalid {
 		panic("misuse")
 	}
 	nb.kind = 99
@@ -162,25 +162,25 @@ func (anyBuilder) Prototype() ipld.NodePrototype {
 
 func (nb *anyBuilder) Build() ipld.Node {
 	switch nb.kind {
-	case ipld.ReprKind_Invalid:
+	case ipld.Kind_Invalid:
 		panic("misuse")
-	case ipld.ReprKind_Map:
+	case ipld.Kind_Map:
 		return nb.mapBuilder.Build()
-	case ipld.ReprKind_List:
+	case ipld.Kind_List:
 		return nb.listBuilder.Build()
-	case ipld.ReprKind_Null:
+	case ipld.Kind_Null:
 		return ipld.Null
-	case ipld.ReprKind_Bool:
+	case ipld.Kind_Bool:
 		return nb.scalarNode
-	case ipld.ReprKind_Int:
+	case ipld.Kind_Int:
 		return nb.scalarNode
-	case ipld.ReprKind_Float:
+	case ipld.Kind_Float:
 		return nb.scalarNode
-	case ipld.ReprKind_String:
+	case ipld.Kind_String:
 		return nb.scalarNode
-	case ipld.ReprKind_Bytes:
+	case ipld.Kind_Bytes:
 		return nb.scalarNode
-	case ipld.ReprKind_Link:
+	case ipld.Kind_Link:
 		return nb.scalarNode
 	case 99:
 		return nb.scalarNode
diff --git a/node/basic/bool.go b/node/basic/bool.go
index 070f59b4..29d99ebe 100644
--- a/node/basic/bool.go
+++ b/node/basic/bool.go
@@ -22,8 +22,8 @@ type plainBool bool
 
 // -- Node interface methods -->
 
-func (plainBool) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Bool
+func (plainBool) Kind() ipld.Kind {
+	return ipld.Kind_Bool
 }
 func (plainBool) LookupByString(string) (ipld.Node, error) {
 	return mixins.Bool{TypeName: "bool"}.LookupByString("")
diff --git a/node/basic/bytes.go b/node/basic/bytes.go
index 8586aaf5..c51c80f6 100644
--- a/node/basic/bytes.go
+++ b/node/basic/bytes.go
@@ -22,8 +22,8 @@ type plainBytes []byte
 
 // -- Node interface methods -->
 
-func (plainBytes) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Bytes
+func (plainBytes) Kind() ipld.Kind {
+	return ipld.Kind_Bytes
 }
 func (plainBytes) LookupByString(string) (ipld.Node, error) {
 	return mixins.Bytes{TypeName: "bytes"}.LookupByString("")
diff --git a/node/basic/float.go b/node/basic/float.go
index b3008d43..5f102f33 100644
--- a/node/basic/float.go
+++ b/node/basic/float.go
@@ -22,8 +22,8 @@ type plainFloat float64
 
 // -- Node interface methods -->
 
-func (plainFloat) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Float
+func (plainFloat) Kind() ipld.Kind {
+	return ipld.Kind_Float
 }
 func (plainFloat) LookupByString(string) (ipld.Node, error) {
 	return mixins.Float{TypeName: "float"}.LookupByString("")
diff --git a/node/basic/int.go b/node/basic/int.go
index 4a3f53b3..ea411801 100644
--- a/node/basic/int.go
+++ b/node/basic/int.go
@@ -22,8 +22,8 @@ type plainInt int64
 
 // -- Node interface methods -->
 
-func (plainInt) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Int
+func (plainInt) Kind() ipld.Kind {
+	return ipld.Kind_Int
 }
 func (plainInt) LookupByString(string) (ipld.Node, error) {
 	return mixins.Int{TypeName: "int"}.LookupByString("")
diff --git a/node/basic/link.go b/node/basic/link.go
index 41fd4808..8d507523 100644
--- a/node/basic/link.go
+++ b/node/basic/link.go
@@ -23,8 +23,8 @@ type plainLink struct {
 
 // -- Node interface methods -->
 
-func (plainLink) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Link
+func (plainLink) Kind() ipld.Kind {
+	return ipld.Kind_Link
 }
 func (plainLink) LookupByString(string) (ipld.Node, error) {
 	return mixins.Link{TypeName: "link"}.LookupByString("")
diff --git a/node/basic/list.go b/node/basic/list.go
index f4f01f21..2e36b747 100644
--- a/node/basic/list.go
+++ b/node/basic/list.go
@@ -21,8 +21,8 @@ type plainList struct {
 
 // -- Node interface methods -->
 
-func (plainList) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_List
+func (plainList) Kind() ipld.Kind {
+	return ipld.Kind_List
 }
 func (plainList) LookupByString(string) (ipld.Node, error) {
 	return mixins.List{TypeName: "list"}.LookupByString("")
@@ -198,8 +198,8 @@ func (na *plainList__Assembler) ConvertFrom(v ipld.Node) error {
 	}
 	// If the above shortcut didn't work, resort to a generic copy.
 	//  We call ConvertFrom for all the child values, giving them a chance to hit shortcuts even if we didn't.
-	if v.ReprKind() != ipld.ReprKind_List {
-		return ipld.ErrWrongKind{TypeName: "list", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_List {
+		return ipld.ErrWrongKind{TypeName: "list", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()}
 	}
 	itr := v.ListIterator()
 	for !itr.Done() {
diff --git a/node/basic/map.go b/node/basic/map.go
index b60e6009..09db9a2a 100644
--- a/node/basic/map.go
+++ b/node/basic/map.go
@@ -30,8 +30,8 @@ type plainMap__Entry struct {
 
 // -- Node interface methods -->
 
-func (plainMap) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (plainMap) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *plainMap) LookupByString(key string) (ipld.Node, error) {
 	v, exists := n.m[key]
@@ -214,8 +214,8 @@ func (na *plainMap__Assembler) ConvertFrom(v ipld.Node) error {
 	}
 	// If the above shortcut didn't work, resort to a generic copy.
 	//  We call ConvertFrom for all the child values, giving them a chance to hit shortcuts even if we didn't.
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "map", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "map", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
diff --git a/node/basic/string.go b/node/basic/string.go
index 6a0c2b44..2a51c3fe 100644
--- a/node/basic/string.go
+++ b/node/basic/string.go
@@ -27,8 +27,8 @@ type plainString string
 
 // -- Node interface methods -->
 
-func (plainString) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_String
+func (plainString) Kind() ipld.Kind {
+	return ipld.Kind_String
 }
 func (plainString) LookupByString(string) (ipld.Node, error) {
 	return mixins.String{TypeName: "string"}.LookupByString("")
diff --git a/node/gendemo/ipldsch_minima.go b/node/gendemo/ipldsch_minima.go
index 42d541ac..c3bdaa64 100644
--- a/node/gendemo/ipldsch_minima.go
+++ b/node/gendemo/ipldsch_minima.go
@@ -45,7 +45,7 @@ func (ea _ErrorThunkAssembler) AssignFloat(float64) error                     {
 func (ea _ErrorThunkAssembler) AssignString(string) error                     { return ea.e }
 func (ea _ErrorThunkAssembler) AssignBytes([]byte) error                      { return ea.e }
 func (ea _ErrorThunkAssembler) AssignLink(ipld.Link) error                    { return ea.e }
-func (ea _ErrorThunkAssembler) ConvertFrom(ipld.Node) error                    { return ea.e }
+func (ea _ErrorThunkAssembler) ConvertFrom(ipld.Node) error                   { return ea.e }
 func (ea _ErrorThunkAssembler) Prototype() ipld.NodePrototype {
 	panic(fmt.Errorf("cannot get prototype from error-carrying assembler: already derailed with error: %w", ea.e))
 }
diff --git a/node/gendemo/ipldsch_satisfaction.go b/node/gendemo/ipldsch_satisfaction.go
index 09ed34c9..44ec7669 100644
--- a/node/gendemo/ipldsch_satisfaction.go
+++ b/node/gendemo/ipldsch_satisfaction.go
@@ -53,8 +53,8 @@ func (m MaybeInt) Must() Int {
 var _ ipld.Node = (Int)(&_Int{})
 var _ schema.TypedNode = (Int)(&_Int{})
 
-func (Int) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Int
+func (Int) Kind() ipld.Kind {
+	return ipld.Kind_Int
 }
 func (Int) LookupByString(string) (ipld.Node, error) {
 	return mixins.Int{"gendemo.Int"}.LookupByString("")
@@ -301,8 +301,8 @@ func (m MaybeMap__String__Msg3) Must() Map__String__Msg3 {
 var _ ipld.Node = (Map__String__Msg3)(&_Map__String__Msg3{})
 var _ schema.TypedNode = (Map__String__Msg3)(&_Map__String__Msg3{})
 
-func (Map__String__Msg3) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (Map__String__Msg3) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n Map__String__Msg3) LookupByString(k string) (ipld.Node, error) {
 	var k2 _String
@@ -502,8 +502,8 @@ func (na *_Map__String__Msg3__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "gendemo.Map__String__Msg3", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "gendemo.Map__String__Msg3", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -658,8 +658,8 @@ type _Map__String__Msg3__Repr _Map__String__Msg3
 
 var _ ipld.Node = &_Map__String__Msg3__Repr{}
 
-func (_Map__String__Msg3__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_Map__String__Msg3__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (nr *_Map__String__Msg3__Repr) LookupByString(k string) (ipld.Node, error) {
 	v, err := (Map__String__Msg3)(nr).LookupByString(k)
@@ -844,8 +844,8 @@ func (na *_Map__String__Msg3__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "gendemo.Map__String__Msg3.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "gendemo.Map__String__Msg3.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -1042,8 +1042,8 @@ var (
 var _ ipld.Node = (Msg3)(&_Msg3{})
 var _ schema.TypedNode = (Msg3)(&_Msg3{})
 
-func (Msg3) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (Msg3) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n Msg3) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -1257,8 +1257,8 @@ func (na *_Msg3__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "gendemo.Msg3", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "gendemo.Msg3", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -1535,8 +1535,8 @@ var (
 )
 var _ ipld.Node = &_Msg3__Repr{}
 
-func (_Msg3__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_Msg3__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_Msg3__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -1742,8 +1742,8 @@ func (na *_Msg3__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "gendemo.Msg3.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "gendemo.Msg3.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -2051,8 +2051,8 @@ func (m MaybeString) Must() String {
 var _ ipld.Node = (String)(&_String{})
 var _ schema.TypedNode = (String)(&_String{})
 
-func (String) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_String
+func (String) Kind() ipld.Kind {
+	return ipld.Kind_String
 }
 func (String) LookupByString(string) (ipld.Node, error) {
 	return mixins.String{"gendemo.String"}.LookupByString("")
diff --git a/node/mixins/bool.go b/node/mixins/bool.go
index 36ad78d9..decfa23c 100644
--- a/node/mixins/bool.go
+++ b/node/mixins/bool.go
@@ -19,20 +19,20 @@ type Bool struct {
 	TypeName string
 }
 
-func (Bool) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Bool
+func (Bool) Kind() ipld.Kind {
+	return ipld.Kind_Bool
 }
 func (x Bool) LookupByString(string) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByString", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Bool}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByString", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Bool}
 }
 func (x Bool) LookupByNode(key ipld.Node) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByNode", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Bool}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Bool}
 }
 func (x Bool) LookupByIndex(idx int64) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByIndex", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Bool}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByIndex", AppropriateKind: ipld.KindSet_JustList, ActualKind: ipld.Kind_Bool}
 }
 func (x Bool) LookupBySegment(ipld.PathSegment) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupBySegment", AppropriateKind: ipld.ReprKindSet_Recursive, ActualKind: ipld.ReprKind_Bool}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupBySegment", AppropriateKind: ipld.KindSet_Recursive, ActualKind: ipld.Kind_Bool}
 }
 func (Bool) MapIterator() ipld.MapIterator {
 	return nil
@@ -50,19 +50,19 @@ func (Bool) IsNull() bool {
 	return false
 }
 func (x Bool) AsInt() (int64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Bool}
+	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_Bool}
 }
 func (x Bool) AsFloat() (float64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Bool}
+	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: ipld.Kind_Bool}
 }
 func (x Bool) AsString() (string, error) {
-	return "", ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Bool}
+	return "", ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsString", AppropriateKind: ipld.KindSet_JustString, ActualKind: ipld.Kind_Bool}
 }
 func (x Bool) AsBytes() ([]byte, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Bool}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: ipld.Kind_Bool}
 }
 func (x Bool) AsLink() (ipld.Link, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Bool}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: ipld.Kind_Bool}
 }
 
 // BoolAssembler has similar purpose as Bool, but for (you guessed it)
@@ -72,26 +72,26 @@ type BoolAssembler struct {
 }
 
 func (x BoolAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Bool}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginMap", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Bool}
 }
 func (x BoolAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Bool}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginList", AppropriateKind: ipld.KindSet_JustList, ActualKind: ipld.Kind_Bool}
 }
 func (x BoolAssembler) AssignNull() error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_Bool}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.KindSet_JustNull, ActualKind: ipld.Kind_Bool}
 }
 func (x BoolAssembler) AssignInt(int64) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Bool}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_Bool}
 }
 func (x BoolAssembler) AssignFloat(float64) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Bool}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: ipld.Kind_Bool}
 }
 func (x BoolAssembler) AssignString(string) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Bool}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignString", AppropriateKind: ipld.KindSet_JustString, ActualKind: ipld.Kind_Bool}
 }
 func (x BoolAssembler) AssignBytes([]byte) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Bool}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: ipld.Kind_Bool}
 }
 func (x BoolAssembler) AssignLink(ipld.Link) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Bool}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: ipld.Kind_Bool}
 }
diff --git a/node/mixins/bytes.go b/node/mixins/bytes.go
index e1741863..05a4e3bf 100644
--- a/node/mixins/bytes.go
+++ b/node/mixins/bytes.go
@@ -19,20 +19,20 @@ type Bytes struct {
 	TypeName string
 }
 
-func (Bytes) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Bytes
+func (Bytes) Kind() ipld.Kind {
+	return ipld.Kind_Bytes
 }
 func (x Bytes) LookupByString(string) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByString", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Bytes}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByString", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Bytes}
 }
 func (x Bytes) LookupByNode(key ipld.Node) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByNode", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Bytes}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Bytes}
 }
 func (x Bytes) LookupByIndex(idx int64) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByIndex", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Bytes}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByIndex", AppropriateKind: ipld.KindSet_JustList, ActualKind: ipld.Kind_Bytes}
 }
 func (x Bytes) LookupBySegment(ipld.PathSegment) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupBySegment", AppropriateKind: ipld.ReprKindSet_Recursive, ActualKind: ipld.ReprKind_Bytes}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupBySegment", AppropriateKind: ipld.KindSet_Recursive, ActualKind: ipld.Kind_Bytes}
 }
 func (Bytes) MapIterator() ipld.MapIterator {
 	return nil
@@ -50,19 +50,19 @@ func (Bytes) IsNull() bool {
 	return false
 }
 func (x Bytes) AsBool() (bool, error) {
-	return false, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Bytes}
+	return false, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: ipld.Kind_Bytes}
 }
 func (x Bytes) AsInt() (int64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Bytes}
+	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_Bytes}
 }
 func (x Bytes) AsFloat() (float64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Bytes}
+	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: ipld.Kind_Bytes}
 }
 func (x Bytes) AsString() (string, error) {
-	return "", ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Bytes}
+	return "", ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsString", AppropriateKind: ipld.KindSet_JustString, ActualKind: ipld.Kind_Bytes}
 }
 func (x Bytes) AsLink() (ipld.Link, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Bytes}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: ipld.Kind_Bytes}
 }
 
 // BytesAssembler has similar purpose as Bytes, but for (you guessed it)
@@ -72,26 +72,26 @@ type BytesAssembler struct {
 }
 
 func (x BytesAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Bytes}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginMap", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Bytes}
 }
 func (x BytesAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Bytes}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginList", AppropriateKind: ipld.KindSet_JustList, ActualKind: ipld.Kind_Bytes}
 }
 func (x BytesAssembler) AssignNull() error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_Bytes}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.KindSet_JustNull, ActualKind: ipld.Kind_Bytes}
 }
 func (x BytesAssembler) AssignBool(bool) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Bytes}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: ipld.Kind_Bytes}
 }
 func (x BytesAssembler) AssignInt(int64) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Bytes}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_Bytes}
 }
 func (x BytesAssembler) AssignFloat(float64) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Bytes}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: ipld.Kind_Bytes}
 }
 func (x BytesAssembler) AssignString(string) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Bytes}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignString", AppropriateKind: ipld.KindSet_JustString, ActualKind: ipld.Kind_Bytes}
 }
 func (x BytesAssembler) AssignLink(ipld.Link) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Bytes}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: ipld.Kind_Bytes}
 }
diff --git a/node/mixins/float.go b/node/mixins/float.go
index 51fe9146..c42d6678 100644
--- a/node/mixins/float.go
+++ b/node/mixins/float.go
@@ -19,20 +19,20 @@ type Float struct {
 	TypeName string
 }
 
-func (Float) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Float
+func (Float) Kind() ipld.Kind {
+	return ipld.Kind_Float
 }
 func (x Float) LookupByString(string) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByString", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Float}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByString", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Float}
 }
 func (x Float) LookupByNode(key ipld.Node) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByNode", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Float}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Float}
 }
 func (x Float) LookupByIndex(idx int64) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByIndex", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Float}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByIndex", AppropriateKind: ipld.KindSet_JustList, ActualKind: ipld.Kind_Float}
 }
 func (x Float) LookupBySegment(ipld.PathSegment) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupBySegment", AppropriateKind: ipld.ReprKindSet_Recursive, ActualKind: ipld.ReprKind_Float}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupBySegment", AppropriateKind: ipld.KindSet_Recursive, ActualKind: ipld.Kind_Float}
 }
 func (Float) MapIterator() ipld.MapIterator {
 	return nil
@@ -50,19 +50,19 @@ func (Float) IsNull() bool {
 	return false
 }
 func (x Float) AsBool() (bool, error) {
-	return false, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Float}
+	return false, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: ipld.Kind_Float}
 }
 func (x Float) AsInt() (int64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Float}
+	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_Float}
 }
 func (x Float) AsString() (string, error) {
-	return "", ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Float}
+	return "", ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsString", AppropriateKind: ipld.KindSet_JustString, ActualKind: ipld.Kind_Float}
 }
 func (x Float) AsBytes() ([]byte, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Float}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: ipld.Kind_Float}
 }
 func (x Float) AsLink() (ipld.Link, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Float}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: ipld.Kind_Float}
 }
 
 // FloatAssembler has similar purpose as Float, but for (you guessed it)
@@ -72,26 +72,26 @@ type FloatAssembler struct {
 }
 
 func (x FloatAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Float}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginMap", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Float}
 }
 func (x FloatAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Float}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginList", AppropriateKind: ipld.KindSet_JustList, ActualKind: ipld.Kind_Float}
 }
 func (x FloatAssembler) AssignNull() error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_Float}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.KindSet_JustNull, ActualKind: ipld.Kind_Float}
 }
 func (x FloatAssembler) AssignBool(bool) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Float}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: ipld.Kind_Float}
 }
 func (x FloatAssembler) AssignInt(int64) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Float}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_Float}
 }
 func (x FloatAssembler) AssignString(string) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Float}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignString", AppropriateKind: ipld.KindSet_JustString, ActualKind: ipld.Kind_Float}
 }
 func (x FloatAssembler) AssignBytes([]byte) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Float}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: ipld.Kind_Float}
 }
 func (x FloatAssembler) AssignLink(ipld.Link) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Float}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: ipld.Kind_Float}
 }
diff --git a/node/mixins/int.go b/node/mixins/int.go
index 09717c54..724b8150 100644
--- a/node/mixins/int.go
+++ b/node/mixins/int.go
@@ -19,20 +19,20 @@ type Int struct {
 	TypeName string
 }
 
-func (Int) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Int
+func (Int) Kind() ipld.Kind {
+	return ipld.Kind_Int
 }
 func (x Int) LookupByString(string) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByString", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Int}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByString", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Int}
 }
 func (x Int) LookupByNode(key ipld.Node) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByNode", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Int}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Int}
 }
 func (x Int) LookupByIndex(idx int64) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByIndex", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Int}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByIndex", AppropriateKind: ipld.KindSet_JustList, ActualKind: ipld.Kind_Int}
 }
 func (x Int) LookupBySegment(ipld.PathSegment) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupBySegment", AppropriateKind: ipld.ReprKindSet_Recursive, ActualKind: ipld.ReprKind_Int}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupBySegment", AppropriateKind: ipld.KindSet_Recursive, ActualKind: ipld.Kind_Int}
 }
 func (Int) MapIterator() ipld.MapIterator {
 	return nil
@@ -50,19 +50,19 @@ func (Int) IsNull() bool {
 	return false
 }
 func (x Int) AsBool() (bool, error) {
-	return false, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Int}
+	return false, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: ipld.Kind_Int}
 }
 func (x Int) AsFloat() (float64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Int}
+	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: ipld.Kind_Int}
 }
 func (x Int) AsString() (string, error) {
-	return "", ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Int}
+	return "", ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsString", AppropriateKind: ipld.KindSet_JustString, ActualKind: ipld.Kind_Int}
 }
 func (x Int) AsBytes() ([]byte, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Int}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: ipld.Kind_Int}
 }
 func (x Int) AsLink() (ipld.Link, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Int}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: ipld.Kind_Int}
 }
 
 // IntAssembler has similar purpose as Int, but for (you guessed it)
@@ -72,26 +72,26 @@ type IntAssembler struct {
 }
 
 func (x IntAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Int}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginMap", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Int}
 }
 func (x IntAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Int}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginList", AppropriateKind: ipld.KindSet_JustList, ActualKind: ipld.Kind_Int}
 }
 func (x IntAssembler) AssignNull() error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_Int}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.KindSet_JustNull, ActualKind: ipld.Kind_Int}
 }
 func (x IntAssembler) AssignBool(bool) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Int}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: ipld.Kind_Int}
 }
 func (x IntAssembler) AssignFloat(float64) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Int}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: ipld.Kind_Int}
 }
 func (x IntAssembler) AssignString(string) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Int}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignString", AppropriateKind: ipld.KindSet_JustString, ActualKind: ipld.Kind_Int}
 }
 func (x IntAssembler) AssignBytes([]byte) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Int}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: ipld.Kind_Int}
 }
 func (x IntAssembler) AssignLink(ipld.Link) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Int}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: ipld.Kind_Int}
 }
diff --git a/node/mixins/link.go b/node/mixins/link.go
index 6cc25a7e..a13836ae 100644
--- a/node/mixins/link.go
+++ b/node/mixins/link.go
@@ -19,20 +19,20 @@ type Link struct {
 	TypeName string
 }
 
-func (Link) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Link
+func (Link) Kind() ipld.Kind {
+	return ipld.Kind_Link
 }
 func (x Link) LookupByString(string) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByString", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Link}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByString", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Link}
 }
 func (x Link) LookupByNode(key ipld.Node) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByNode", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Link}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Link}
 }
 func (x Link) LookupByIndex(idx int64) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByIndex", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Link}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByIndex", AppropriateKind: ipld.KindSet_JustList, ActualKind: ipld.Kind_Link}
 }
 func (x Link) LookupBySegment(ipld.PathSegment) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupBySegment", AppropriateKind: ipld.ReprKindSet_Recursive, ActualKind: ipld.ReprKind_Link}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupBySegment", AppropriateKind: ipld.KindSet_Recursive, ActualKind: ipld.Kind_Link}
 }
 func (Link) MapIterator() ipld.MapIterator {
 	return nil
@@ -50,19 +50,19 @@ func (Link) IsNull() bool {
 	return false
 }
 func (x Link) AsBool() (bool, error) {
-	return false, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Link}
+	return false, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: ipld.Kind_Link}
 }
 func (x Link) AsInt() (int64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Link}
+	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_Link}
 }
 func (x Link) AsFloat() (float64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Link}
+	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: ipld.Kind_Link}
 }
 func (x Link) AsString() (string, error) {
-	return "", ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Link}
+	return "", ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsString", AppropriateKind: ipld.KindSet_JustString, ActualKind: ipld.Kind_Link}
 }
 func (x Link) AsBytes() ([]byte, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Link}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: ipld.Kind_Link}
 }
 
 // LinkAssembler has similar purpose as Link, but for (you guessed it)
@@ -72,26 +72,26 @@ type LinkAssembler struct {
 }
 
 func (x LinkAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_Link}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginMap", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_Link}
 }
 func (x LinkAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Link}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginList", AppropriateKind: ipld.KindSet_JustList, ActualKind: ipld.Kind_Link}
 }
 func (x LinkAssembler) AssignNull() error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_Link}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.KindSet_JustNull, ActualKind: ipld.Kind_Link}
 }
 func (x LinkAssembler) AssignBool(bool) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Link}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: ipld.Kind_Link}
 }
 func (x LinkAssembler) AssignInt(int64) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Link}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_Link}
 }
 func (x LinkAssembler) AssignFloat(float64) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Link}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: ipld.Kind_Link}
 }
 func (x LinkAssembler) AssignString(string) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Link}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignString", AppropriateKind: ipld.KindSet_JustString, ActualKind: ipld.Kind_Link}
 }
 func (x LinkAssembler) AssignBytes([]byte) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Link}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: ipld.Kind_Link}
 }
diff --git a/node/mixins/list.go b/node/mixins/list.go
index f43091ea..250830dd 100644
--- a/node/mixins/list.go
+++ b/node/mixins/list.go
@@ -19,14 +19,14 @@ type List struct {
 	TypeName string
 }
 
-func (List) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_List
+func (List) Kind() ipld.Kind {
+	return ipld.Kind_List
 }
 func (x List) LookupByString(string) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByString", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_List}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByString", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_List}
 }
 func (x List) LookupByNode(key ipld.Node) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByNode", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_List}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_List}
 }
 func (List) MapIterator() ipld.MapIterator {
 	return nil
@@ -38,22 +38,22 @@ func (List) IsNull() bool {
 	return false
 }
 func (x List) AsBool() (bool, error) {
-	return false, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_List}
+	return false, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: ipld.Kind_List}
 }
 func (x List) AsInt() (int64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_List}
+	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_List}
 }
 func (x List) AsFloat() (float64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_List}
+	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: ipld.Kind_List}
 }
 func (x List) AsString() (string, error) {
-	return "", ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_List}
+	return "", ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsString", AppropriateKind: ipld.KindSet_JustString, ActualKind: ipld.Kind_List}
 }
 func (x List) AsBytes() ([]byte, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_List}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: ipld.Kind_List}
 }
 func (x List) AsLink() (ipld.Link, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_List}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: ipld.Kind_List}
 }
 
 // ListAssembler has similar purpose as List, but for (you guessed it)
@@ -63,26 +63,26 @@ type ListAssembler struct {
 }
 
 func (x ListAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_List}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginMap", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_List}
 }
 func (x ListAssembler) AssignNull() error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_List}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.KindSet_JustNull, ActualKind: ipld.Kind_List}
 }
 func (x ListAssembler) AssignBool(bool) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_List}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: ipld.Kind_List}
 }
 func (x ListAssembler) AssignInt(int64) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_List}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_List}
 }
 func (x ListAssembler) AssignFloat(float64) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_List}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: ipld.Kind_List}
 }
 func (x ListAssembler) AssignString(string) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_List}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignString", AppropriateKind: ipld.KindSet_JustString, ActualKind: ipld.Kind_List}
 }
 func (x ListAssembler) AssignBytes([]byte) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_List}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: ipld.Kind_List}
 }
 func (x ListAssembler) AssignLink(ipld.Link) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_List}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: ipld.Kind_List}
 }
diff --git a/node/mixins/map.go b/node/mixins/map.go
index f769c18a..b9958768 100644
--- a/node/mixins/map.go
+++ b/node/mixins/map.go
@@ -19,11 +19,11 @@ type Map struct {
 	TypeName string
 }
 
-func (Map) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (Map) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (x Map) LookupByIndex(idx int64) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByIndex", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Map}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByIndex", AppropriateKind: ipld.KindSet_JustList, ActualKind: ipld.Kind_Map}
 }
 func (Map) ListIterator() ipld.ListIterator {
 	return nil
@@ -35,22 +35,22 @@ func (Map) IsNull() bool {
 	return false
 }
 func (x Map) AsBool() (bool, error) {
-	return false, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Map}
+	return false, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: ipld.Kind_Map}
 }
 func (x Map) AsInt() (int64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Map}
+	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_Map}
 }
 func (x Map) AsFloat() (float64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Map}
+	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: ipld.Kind_Map}
 }
 func (x Map) AsString() (string, error) {
-	return "", ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Map}
+	return "", ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsString", AppropriateKind: ipld.KindSet_JustString, ActualKind: ipld.Kind_Map}
 }
 func (x Map) AsBytes() ([]byte, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Map}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: ipld.Kind_Map}
 }
 func (x Map) AsLink() (ipld.Link, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Map}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: ipld.Kind_Map}
 }
 
 // MapAssembler has similar purpose as Map, but for (you guessed it)
@@ -60,26 +60,26 @@ type MapAssembler struct {
 }
 
 func (x MapAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_Map}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginList", AppropriateKind: ipld.KindSet_JustList, ActualKind: ipld.Kind_Map}
 }
 func (x MapAssembler) AssignNull() error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_Map}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.KindSet_JustNull, ActualKind: ipld.Kind_Map}
 }
 func (x MapAssembler) AssignBool(bool) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_Map}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: ipld.Kind_Map}
 }
 func (x MapAssembler) AssignInt(int64) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_Map}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_Map}
 }
 func (x MapAssembler) AssignFloat(float64) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_Map}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: ipld.Kind_Map}
 }
 func (x MapAssembler) AssignString(string) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: ipld.ReprKind_Map}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignString", AppropriateKind: ipld.KindSet_JustString, ActualKind: ipld.Kind_Map}
 }
 func (x MapAssembler) AssignBytes([]byte) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_Map}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: ipld.Kind_Map}
 }
 func (x MapAssembler) AssignLink(ipld.Link) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_Map}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: ipld.Kind_Map}
 }
diff --git a/node/mixins/string.go b/node/mixins/string.go
index 12f64961..a8d9e8fd 100644
--- a/node/mixins/string.go
+++ b/node/mixins/string.go
@@ -19,20 +19,20 @@ type String struct {
 	TypeName string
 }
 
-func (String) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_String
+func (String) Kind() ipld.Kind {
+	return ipld.Kind_String
 }
 func (x String) LookupByString(string) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByString", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_String}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByString", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_String}
 }
 func (x String) LookupByNode(key ipld.Node) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByNode", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_String}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByNode", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_String}
 }
 func (x String) LookupByIndex(idx int64) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByIndex", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_String}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupByIndex", AppropriateKind: ipld.KindSet_JustList, ActualKind: ipld.Kind_String}
 }
 func (x String) LookupBySegment(ipld.PathSegment) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupBySegment", AppropriateKind: ipld.ReprKindSet_Recursive, ActualKind: ipld.ReprKind_String}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "LookupBySegment", AppropriateKind: ipld.KindSet_Recursive, ActualKind: ipld.Kind_String}
 }
 func (String) MapIterator() ipld.MapIterator {
 	return nil
@@ -50,19 +50,19 @@ func (String) IsNull() bool {
 	return false
 }
 func (x String) AsBool() (bool, error) {
-	return false, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_String}
+	return false, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: ipld.Kind_String}
 }
 func (x String) AsInt() (int64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_String}
+	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_String}
 }
 func (x String) AsFloat() (float64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_String}
+	return 0, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: ipld.Kind_String}
 }
 func (x String) AsBytes() ([]byte, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_String}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: ipld.Kind_String}
 }
 func (x String) AsLink() (ipld.Link, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_String}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AsLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: ipld.Kind_String}
 }
 
 // StringAssembler has similar purpose as String, but for (you guessed it)
@@ -72,26 +72,26 @@ type StringAssembler struct {
 }
 
 func (x StringAssembler) BeginMap(sizeHint int64) (ipld.MapAssembler, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginMap", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: ipld.ReprKind_String}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginMap", AppropriateKind: ipld.KindSet_JustMap, ActualKind: ipld.Kind_String}
 }
 func (x StringAssembler) BeginList(sizeHint int64) (ipld.ListAssembler, error) {
-	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginList", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: ipld.ReprKind_String}
+	return nil, ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "BeginList", AppropriateKind: ipld.KindSet_JustList, ActualKind: ipld.Kind_String}
 }
 func (x StringAssembler) AssignNull() error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.ReprKindSet_JustNull, ActualKind: ipld.ReprKind_String}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignNull", AppropriateKind: ipld.KindSet_JustNull, ActualKind: ipld.Kind_String}
 }
 func (x StringAssembler) AssignBool(bool) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: ipld.ReprKind_String}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: ipld.Kind_String}
 }
 func (x StringAssembler) AssignInt(int64) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: ipld.ReprKind_String}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: ipld.Kind_String}
 }
 func (x StringAssembler) AssignFloat(float64) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: ipld.ReprKind_String}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: ipld.Kind_String}
 }
 func (x StringAssembler) AssignBytes([]byte) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: ipld.ReprKind_String}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: ipld.Kind_String}
 }
 func (x StringAssembler) AssignLink(ipld.Link) error {
-	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: ipld.ReprKind_String}
+	return ipld.ErrWrongKind{TypeName: x.TypeName, MethodName: "AssignLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: ipld.Kind_String}
 }
diff --git a/node/tests/stringSpecs.go b/node/tests/stringSpecs.go
index e87562ae..9b822c6a 100644
--- a/node/tests/stringSpecs.go
+++ b/node/tests/stringSpecs.go
@@ -15,7 +15,7 @@ func SpecTestString(t *testing.T, np ipld.NodePrototype) {
 		Wish(t, err, ShouldEqual, nil)
 		n := nb.Build()
 
-		Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_String)
+		Wish(t, n.Kind(), ShouldEqual, ipld.Kind_String)
 		Wish(t, n.IsNull(), ShouldEqual, false)
 		x, err := n.AsString()
 		Wish(t, err, ShouldEqual, nil)
diff --git a/schema/dmt/gen.go b/schema/dmt/gen.go
index aae51086..613675ea 100644
--- a/schema/dmt/gen.go
+++ b/schema/dmt/gen.go
@@ -80,9 +80,9 @@ func main() {
 			"TypeName",
 			"TypeDefnInline",
 		},
-		schema.SpawnUnionRepresentationKinded(map[ipld.ReprKind]schema.TypeName{
-			ipld.ReprKind_String: "TypeName",
-			ipld.ReprKind_Map:    "TypeDefnInline",
+		schema.SpawnUnionRepresentationKinded(map[ipld.Kind]schema.TypeName{
+			ipld.Kind_String: "TypeName",
+			ipld.Kind_Map:    "TypeDefnInline",
 		}),
 	))
 	ts.Accumulate(schema.SpawnUnion("TypeDefnInline", // n.b. previously called "TypeTerm".
@@ -370,12 +370,12 @@ func main() {
 			"Int",
 			"Float",
 		},
-		schema.SpawnUnionRepresentationKinded(map[ipld.ReprKind]schema.TypeName{
-			ipld.ReprKind_Bool:   "Bool",
-			ipld.ReprKind_String: "String",
-			ipld.ReprKind_Bytes:  "Bytes",
-			ipld.ReprKind_Int:    "Int",
-			ipld.ReprKind_Float:  "Float",
+		schema.SpawnUnionRepresentationKinded(map[ipld.Kind]schema.TypeName{
+			ipld.Kind_Bool:   "Bool",
+			ipld.Kind_String: "String",
+			ipld.Kind_Bytes:  "Bytes",
+			ipld.Kind_Int:    "Int",
+			ipld.Kind_Float:  "Float",
 		}),
 	))
 
diff --git a/schema/dmt/ipldsch_minima.go b/schema/dmt/ipldsch_minima.go
index 13185881..8ccc9d1a 100644
--- a/schema/dmt/ipldsch_minima.go
+++ b/schema/dmt/ipldsch_minima.go
@@ -45,7 +45,7 @@ func (ea _ErrorThunkAssembler) AssignFloat(float64) error                     {
 func (ea _ErrorThunkAssembler) AssignString(string) error                     { return ea.e }
 func (ea _ErrorThunkAssembler) AssignBytes([]byte) error                      { return ea.e }
 func (ea _ErrorThunkAssembler) AssignLink(ipld.Link) error                    { return ea.e }
-func (ea _ErrorThunkAssembler) ConvertFrom(ipld.Node) error                    { return ea.e }
+func (ea _ErrorThunkAssembler) ConvertFrom(ipld.Node) error                   { return ea.e }
 func (ea _ErrorThunkAssembler) Prototype() ipld.NodePrototype {
 	panic(fmt.Errorf("cannot get prototype from error-carrying assembler: already derailed with error: %w", ea.e))
 }
diff --git a/schema/dmt/ipldsch_satisfaction.go b/schema/dmt/ipldsch_satisfaction.go
index 82fadac8..c883c89c 100644
--- a/schema/dmt/ipldsch_satisfaction.go
+++ b/schema/dmt/ipldsch_satisfaction.go
@@ -69,8 +69,8 @@ var (
 var _ ipld.Node = (AnyScalar)(&_AnyScalar{})
 var _ schema.TypedNode = (AnyScalar)(&_AnyScalar{})
 
-func (AnyScalar) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (AnyScalar) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n AnyScalar) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -319,8 +319,8 @@ func (na *_AnyScalar__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -591,33 +591,33 @@ type _AnyScalar__Repr _AnyScalar
 
 var _ ipld.Node = &_AnyScalar__Repr{}
 
-func (n *_AnyScalar__Repr) ReprKind() ipld.ReprKind {
+func (n *_AnyScalar__Repr) Kind() ipld.Kind {
 	switch n.tag {
 	case 1:
-		return ipld.ReprKind_Bool
+		return ipld.Kind_Bool
 	case 2:
-		return ipld.ReprKind_String
+		return ipld.Kind_String
 	case 3:
-		return ipld.ReprKind_Bytes
+		return ipld.Kind_Bytes
 	case 4:
-		return ipld.ReprKind_Int
+		return ipld.Kind_Int
 	case 5:
-		return ipld.ReprKind_Float
+		return ipld.Kind_Float
 	default:
 		panic("unreachable")
 	}
 }
 func (n *_AnyScalar__Repr) LookupByString(key string) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "LookupByString", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: n.ReprKind()}
+	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "LookupByString", AppropriateKind: ipld.KindSet_JustMap, ActualKind: n.Kind()}
 }
 func (n *_AnyScalar__Repr) LookupByNode(key ipld.Node) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "LookupByNode", AppropriateKind: ipld.ReprKindSet_Recursive, ActualKind: n.ReprKind()}
+	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "LookupByNode", AppropriateKind: ipld.KindSet_Recursive, ActualKind: n.Kind()}
 }
 func (n *_AnyScalar__Repr) LookupByIndex(idx int64) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "LookupByIndex", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: n.ReprKind()}
+	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "LookupByIndex", AppropriateKind: ipld.KindSet_JustList, ActualKind: n.Kind()}
 }
 func (n *_AnyScalar__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "LookupBySegment", AppropriateKind: ipld.ReprKindSet_Recursive, ActualKind: n.ReprKind()}
+	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "LookupBySegment", AppropriateKind: ipld.KindSet_Recursive, ActualKind: n.Kind()}
 }
 func (n *_AnyScalar__Repr) MapIterator() ipld.MapIterator {
 	return nil
@@ -639,7 +639,7 @@ func (n *_AnyScalar__Repr) AsBool() (bool, error) {
 	case 1:
 		return n.x1.Representation().AsBool()
 	default:
-		return false, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "AsBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: n.ReprKind()}
+		return false, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "AsBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: n.Kind()}
 	}
 }
 func (n *_AnyScalar__Repr) AsInt() (int64, error) {
@@ -647,7 +647,7 @@ func (n *_AnyScalar__Repr) AsInt() (int64, error) {
 	case 4:
 		return n.x4.Representation().AsInt()
 	default:
-		return 0, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "AsInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: n.ReprKind()}
+		return 0, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "AsInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: n.Kind()}
 	}
 }
 func (n *_AnyScalar__Repr) AsFloat() (float64, error) {
@@ -655,7 +655,7 @@ func (n *_AnyScalar__Repr) AsFloat() (float64, error) {
 	case 5:
 		return n.x5.Representation().AsFloat()
 	default:
-		return 0, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "AsFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: n.ReprKind()}
+		return 0, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "AsFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: n.Kind()}
 	}
 }
 func (n *_AnyScalar__Repr) AsString() (string, error) {
@@ -663,7 +663,7 @@ func (n *_AnyScalar__Repr) AsString() (string, error) {
 	case 2:
 		return n.x2.Representation().AsString()
 	default:
-		return "", ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "AsString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: n.ReprKind()}
+		return "", ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "AsString", AppropriateKind: ipld.KindSet_JustString, ActualKind: n.Kind()}
 	}
 }
 func (n *_AnyScalar__Repr) AsBytes() ([]byte, error) {
@@ -671,11 +671,11 @@ func (n *_AnyScalar__Repr) AsBytes() ([]byte, error) {
 	case 3:
 		return n.x3.Representation().AsBytes()
 	default:
-		return nil, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "AsBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: n.ReprKind()}
+		return nil, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "AsBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: n.Kind()}
 	}
 }
 func (n *_AnyScalar__Repr) AsLink() (ipld.Link, error) {
-	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: n.ReprKind()}
+	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.AnyScalar.Repr", MethodName: "AsLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: n.Kind()}
 }
 func (_AnyScalar__Repr) Prototype() ipld.NodePrototype {
 	return _AnyScalar__ReprPrototype{}
@@ -876,23 +876,23 @@ func (na *_AnyScalar__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	switch v.ReprKind() {
-	case ipld.ReprKind_Bool:
+	switch v.Kind() {
+	case ipld.Kind_Bool:
 		v2, _ := v.AsBool()
 		return na.AssignBool(v2)
-	case ipld.ReprKind_Int:
+	case ipld.Kind_Int:
 		v2, _ := v.AsInt()
 		return na.AssignInt(v2)
-	case ipld.ReprKind_Float:
+	case ipld.Kind_Float:
 		v2, _ := v.AsFloat()
 		return na.AssignFloat(v2)
-	case ipld.ReprKind_String:
+	case ipld.Kind_String:
 		v2, _ := v.AsString()
 		return na.AssignString(v2)
-	case ipld.ReprKind_Bytes:
+	case ipld.Kind_Bytes:
 		v2, _ := v.AsBytes()
 		return na.AssignBytes(v2)
-	case ipld.ReprKind_Map:
+	case ipld.Kind_Map:
 		na, err := na.BeginMap(v.Length())
 		if err != nil {
 			return err
@@ -911,7 +911,7 @@ func (na *_AnyScalar__ReprAssembler) ConvertFrom(v ipld.Node) error {
 			}
 		}
 		return na.Finish()
-	case ipld.ReprKind_List:
+	case ipld.Kind_List:
 		na, err := na.BeginList(v.Length())
 		if err != nil {
 			return err
@@ -927,7 +927,7 @@ func (na *_AnyScalar__ReprAssembler) ConvertFrom(v ipld.Node) error {
 			}
 		}
 		return na.Finish()
-	case ipld.ReprKind_Link:
+	case ipld.Kind_Link:
 		v2, _ := v.AsLink()
 		return na.AssignLink(v2)
 	default:
@@ -983,8 +983,8 @@ func (m MaybeBool) Must() Bool {
 var _ ipld.Node = (Bool)(&_Bool{})
 var _ schema.TypedNode = (Bool)(&_Bool{})
 
-func (Bool) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Bool
+func (Bool) Kind() ipld.Kind {
+	return ipld.Kind_Bool
 }
 func (Bool) LookupByString(string) (ipld.Node, error) {
 	return mixins.Bool{"schemadmt.Bool"}.LookupByString("")
@@ -1196,8 +1196,8 @@ func (m MaybeBytes) Must() Bytes {
 var _ ipld.Node = (Bytes)(&_Bytes{})
 var _ schema.TypedNode = (Bytes)(&_Bytes{})
 
-func (Bytes) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Bytes
+func (Bytes) Kind() ipld.Kind {
+	return ipld.Kind_Bytes
 }
 func (Bytes) LookupByString(string) (ipld.Node, error) {
 	return mixins.Bytes{"schemadmt.Bytes"}.LookupByString("")
@@ -1416,8 +1416,8 @@ var (
 var _ ipld.Node = (EnumRepresentation)(&_EnumRepresentation{})
 var _ schema.TypedNode = (EnumRepresentation)(&_EnumRepresentation{})
 
-func (EnumRepresentation) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (EnumRepresentation) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n EnumRepresentation) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -1630,8 +1630,8 @@ func (na *_EnumRepresentation__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.EnumRepresentation", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.EnumRepresentation", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -1852,8 +1852,8 @@ var (
 )
 var _ ipld.Node = &_EnumRepresentation__Repr{}
 
-func (_EnumRepresentation__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_EnumRepresentation__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_EnumRepresentation__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -2066,8 +2066,8 @@ func (na *_EnumRepresentation__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.EnumRepresentation.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.EnumRepresentation.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -2354,8 +2354,8 @@ func (m MaybeEnumRepresentation_Int) Must() EnumRepresentation_Int {
 var _ ipld.Node = (EnumRepresentation_Int)(&_EnumRepresentation_Int{})
 var _ schema.TypedNode = (EnumRepresentation_Int)(&_EnumRepresentation_Int{})
 
-func (EnumRepresentation_Int) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (EnumRepresentation_Int) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n EnumRepresentation_Int) LookupByString(k string) (ipld.Node, error) {
 	var k2 _EnumValue
@@ -2555,8 +2555,8 @@ func (na *_EnumRepresentation_Int__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.EnumRepresentation_Int", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.EnumRepresentation_Int", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -2711,8 +2711,8 @@ type _EnumRepresentation_Int__Repr _EnumRepresentation_Int
 
 var _ ipld.Node = &_EnumRepresentation_Int__Repr{}
 
-func (_EnumRepresentation_Int__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_EnumRepresentation_Int__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (nr *_EnumRepresentation_Int__Repr) LookupByString(k string) (ipld.Node, error) {
 	v, err := (EnumRepresentation_Int)(nr).LookupByString(k)
@@ -2897,8 +2897,8 @@ func (na *_EnumRepresentation_Int__ReprAssembler) ConvertFrom(v ipld.Node) error
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.EnumRepresentation_Int.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.EnumRepresentation_Int.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -3123,8 +3123,8 @@ func (m MaybeEnumRepresentation_String) Must() EnumRepresentation_String {
 var _ ipld.Node = (EnumRepresentation_String)(&_EnumRepresentation_String{})
 var _ schema.TypedNode = (EnumRepresentation_String)(&_EnumRepresentation_String{})
 
-func (EnumRepresentation_String) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (EnumRepresentation_String) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n EnumRepresentation_String) LookupByString(k string) (ipld.Node, error) {
 	var k2 _EnumValue
@@ -3324,8 +3324,8 @@ func (na *_EnumRepresentation_String__Assembler) ConvertFrom(v ipld.Node) error
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.EnumRepresentation_String", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.EnumRepresentation_String", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -3480,8 +3480,8 @@ type _EnumRepresentation_String__Repr _EnumRepresentation_String
 
 var _ ipld.Node = &_EnumRepresentation_String__Repr{}
 
-func (_EnumRepresentation_String__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_EnumRepresentation_String__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (nr *_EnumRepresentation_String__Repr) LookupByString(k string) (ipld.Node, error) {
 	v, err := (EnumRepresentation_String)(nr).LookupByString(k)
@@ -3666,8 +3666,8 @@ func (na *_EnumRepresentation_String__ReprAssembler) ConvertFrom(v ipld.Node) er
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.EnumRepresentation_String.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.EnumRepresentation_String.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -3861,8 +3861,8 @@ func (m MaybeEnumValue) Must() EnumValue {
 var _ ipld.Node = (EnumValue)(&_EnumValue{})
 var _ schema.TypedNode = (EnumValue)(&_EnumValue{})
 
-func (EnumValue) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_String
+func (EnumValue) Kind() ipld.Kind {
+	return ipld.Kind_String
 }
 func (EnumValue) LookupByString(string) (ipld.Node, error) {
 	return mixins.String{"schemadmt.EnumValue"}.LookupByString("")
@@ -4078,8 +4078,8 @@ func (m MaybeFieldName) Must() FieldName {
 var _ ipld.Node = (FieldName)(&_FieldName{})
 var _ schema.TypedNode = (FieldName)(&_FieldName{})
 
-func (FieldName) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_String
+func (FieldName) Kind() ipld.Kind {
+	return ipld.Kind_String
 }
 func (FieldName) LookupByString(string) (ipld.Node, error) {
 	return mixins.String{"schemadmt.FieldName"}.LookupByString("")
@@ -4291,8 +4291,8 @@ func (m MaybeFloat) Must() Float {
 var _ ipld.Node = (Float)(&_Float{})
 var _ schema.TypedNode = (Float)(&_Float{})
 
-func (Float) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Float
+func (Float) Kind() ipld.Kind {
+	return ipld.Kind_Float
 }
 func (Float) LookupByString(string) (ipld.Node, error) {
 	return mixins.Float{"schemadmt.Float"}.LookupByString("")
@@ -4504,8 +4504,8 @@ func (m MaybeInt) Must() Int {
 var _ ipld.Node = (Int)(&_Int{})
 var _ schema.TypedNode = (Int)(&_Int{})
 
-func (Int) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Int
+func (Int) Kind() ipld.Kind {
+	return ipld.Kind_Int
 }
 func (Int) LookupByString(string) (ipld.Node, error) {
 	return mixins.Int{"schemadmt.Int"}.LookupByString("")
@@ -4721,8 +4721,8 @@ var (
 var _ ipld.Node = (ListRepresentation)(&_ListRepresentation{})
 var _ schema.TypedNode = (ListRepresentation)(&_ListRepresentation{})
 
-func (ListRepresentation) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (ListRepresentation) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n ListRepresentation) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -4923,8 +4923,8 @@ func (na *_ListRepresentation__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.ListRepresentation", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.ListRepresentation", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -5126,8 +5126,8 @@ var (
 )
 var _ ipld.Node = &_ListRepresentation__Repr{}
 
-func (_ListRepresentation__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_ListRepresentation__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_ListRepresentation__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -5328,8 +5328,8 @@ func (na *_ListRepresentation__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.ListRepresentation.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.ListRepresentation.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -5556,8 +5556,8 @@ var ()
 var _ ipld.Node = (ListRepresentation_List)(&_ListRepresentation_List{})
 var _ schema.TypedNode = (ListRepresentation_List)(&_ListRepresentation_List{})
 
-func (ListRepresentation_List) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (ListRepresentation_List) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n ListRepresentation_List) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -5747,8 +5747,8 @@ func (na *_ListRepresentation_List__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.ListRepresentation_List", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.ListRepresentation_List", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -5919,8 +5919,8 @@ type _ListRepresentation_List__Repr _ListRepresentation_List
 var ()
 var _ ipld.Node = &_ListRepresentation_List__Repr{}
 
-func (_ListRepresentation_List__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_ListRepresentation_List__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_ListRepresentation_List__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -6105,8 +6105,8 @@ func (na *_ListRepresentation_List__ReprAssembler) ConvertFrom(v ipld.Node) erro
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.ListRepresentation_List.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.ListRepresentation_List.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -6345,8 +6345,8 @@ func (m MaybeList__FieldName) Must() List__FieldName {
 var _ ipld.Node = (List__FieldName)(&_List__FieldName{})
 var _ schema.TypedNode = (List__FieldName)(&_List__FieldName{})
 
-func (List__FieldName) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_List
+func (List__FieldName) Kind() ipld.Kind {
+	return ipld.Kind_List
 }
 func (List__FieldName) LookupByString(string) (ipld.Node, error) {
 	return mixins.List{"schemadmt.List__FieldName"}.LookupByString("")
@@ -6540,8 +6540,8 @@ func (na *_List__FieldName__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_List {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.List__FieldName", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_List {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.List__FieldName", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()}
 	}
 	itr := v.ListIterator()
 	for !itr.Done() {
@@ -6617,8 +6617,8 @@ type _List__FieldName__Repr _List__FieldName
 
 var _ ipld.Node = &_List__FieldName__Repr{}
 
-func (_List__FieldName__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_List
+func (_List__FieldName__Repr) Kind() ipld.Kind {
+	return ipld.Kind_List
 }
 func (_List__FieldName__Repr) LookupByString(string) (ipld.Node, error) {
 	return mixins.List{"schemadmt.List__FieldName.Repr"}.LookupByString("")
@@ -6806,8 +6806,8 @@ func (na *_List__FieldName__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_List {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.List__FieldName.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_List {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.List__FieldName.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()}
 	}
 	itr := v.ListIterator()
 	for !itr.Done() {
@@ -6952,8 +6952,8 @@ func (m MaybeList__TypeName) Must() List__TypeName {
 var _ ipld.Node = (List__TypeName)(&_List__TypeName{})
 var _ schema.TypedNode = (List__TypeName)(&_List__TypeName{})
 
-func (List__TypeName) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_List
+func (List__TypeName) Kind() ipld.Kind {
+	return ipld.Kind_List
 }
 func (List__TypeName) LookupByString(string) (ipld.Node, error) {
 	return mixins.List{"schemadmt.List__TypeName"}.LookupByString("")
@@ -7147,8 +7147,8 @@ func (na *_List__TypeName__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_List {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.List__TypeName", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_List {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.List__TypeName", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()}
 	}
 	itr := v.ListIterator()
 	for !itr.Done() {
@@ -7224,8 +7224,8 @@ type _List__TypeName__Repr _List__TypeName
 
 var _ ipld.Node = &_List__TypeName__Repr{}
 
-func (_List__TypeName__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_List
+func (_List__TypeName__Repr) Kind() ipld.Kind {
+	return ipld.Kind_List
 }
 func (_List__TypeName__Repr) LookupByString(string) (ipld.Node, error) {
 	return mixins.List{"schemadmt.List__TypeName.Repr"}.LookupByString("")
@@ -7413,8 +7413,8 @@ func (na *_List__TypeName__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_List {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.List__TypeName.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_List {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.List__TypeName.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()}
 	}
 	itr := v.ListIterator()
 	for !itr.Done() {
@@ -7535,8 +7535,8 @@ var (
 var _ ipld.Node = (MapRepresentation)(&_MapRepresentation{})
 var _ schema.TypedNode = (MapRepresentation)(&_MapRepresentation{})
 
-func (MapRepresentation) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (MapRepresentation) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n MapRepresentation) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -7761,8 +7761,8 @@ func (na *_MapRepresentation__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -8002,8 +8002,8 @@ var (
 )
 var _ ipld.Node = &_MapRepresentation__Repr{}
 
-func (_MapRepresentation__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_MapRepresentation__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_MapRepresentation__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -8228,8 +8228,8 @@ func (na *_MapRepresentation__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -8492,8 +8492,8 @@ var ()
 var _ ipld.Node = (MapRepresentation_Listpairs)(&_MapRepresentation_Listpairs{})
 var _ schema.TypedNode = (MapRepresentation_Listpairs)(&_MapRepresentation_Listpairs{})
 
-func (MapRepresentation_Listpairs) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (MapRepresentation_Listpairs) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n MapRepresentation_Listpairs) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -8683,8 +8683,8 @@ func (na *_MapRepresentation_Listpairs__Assembler) ConvertFrom(v ipld.Node) erro
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation_Listpairs", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation_Listpairs", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -8855,8 +8855,8 @@ type _MapRepresentation_Listpairs__Repr _MapRepresentation_Listpairs
 var ()
 var _ ipld.Node = &_MapRepresentation_Listpairs__Repr{}
 
-func (_MapRepresentation_Listpairs__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_MapRepresentation_Listpairs__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_MapRepresentation_Listpairs__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -9041,8 +9041,8 @@ func (na *_MapRepresentation_Listpairs__ReprAssembler) ConvertFrom(v ipld.Node)
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation_Listpairs.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation_Listpairs.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -9240,8 +9240,8 @@ var ()
 var _ ipld.Node = (MapRepresentation_Map)(&_MapRepresentation_Map{})
 var _ schema.TypedNode = (MapRepresentation_Map)(&_MapRepresentation_Map{})
 
-func (MapRepresentation_Map) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (MapRepresentation_Map) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n MapRepresentation_Map) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -9431,8 +9431,8 @@ func (na *_MapRepresentation_Map__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation_Map", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation_Map", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -9603,8 +9603,8 @@ type _MapRepresentation_Map__Repr _MapRepresentation_Map
 var ()
 var _ ipld.Node = &_MapRepresentation_Map__Repr{}
 
-func (_MapRepresentation_Map__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_MapRepresentation_Map__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_MapRepresentation_Map__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -9789,8 +9789,8 @@ func (na *_MapRepresentation_Map__ReprAssembler) ConvertFrom(v ipld.Node) error
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation_Map.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation_Map.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -9998,8 +9998,8 @@ var (
 var _ ipld.Node = (MapRepresentation_Stringpairs)(&_MapRepresentation_Stringpairs{})
 var _ schema.TypedNode = (MapRepresentation_Stringpairs)(&_MapRepresentation_Stringpairs{})
 
-func (MapRepresentation_Stringpairs) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (MapRepresentation_Stringpairs) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n MapRepresentation_Stringpairs) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -10205,8 +10205,8 @@ func (na *_MapRepresentation_Stringpairs__Assembler) ConvertFrom(v ipld.Node) er
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation_Stringpairs", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation_Stringpairs", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -10448,8 +10448,8 @@ var (
 )
 var _ ipld.Node = &_MapRepresentation_Stringpairs__Repr{}
 
-func (_MapRepresentation_Stringpairs__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_MapRepresentation_Stringpairs__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_MapRepresentation_Stringpairs__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -10648,8 +10648,8 @@ func (na *_MapRepresentation_Stringpairs__ReprAssembler) ConvertFrom(v ipld.Node
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation_Stringpairs.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.MapRepresentation_Stringpairs.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -10955,8 +10955,8 @@ func (m MaybeMap__EnumValue__Unit) Must() Map__EnumValue__Unit {
 var _ ipld.Node = (Map__EnumValue__Unit)(&_Map__EnumValue__Unit{})
 var _ schema.TypedNode = (Map__EnumValue__Unit)(&_Map__EnumValue__Unit{})
 
-func (Map__EnumValue__Unit) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (Map__EnumValue__Unit) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n Map__EnumValue__Unit) LookupByString(k string) (ipld.Node, error) {
 	var k2 _EnumValue
@@ -11156,8 +11156,8 @@ func (na *_Map__EnumValue__Unit__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__EnumValue__Unit", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__EnumValue__Unit", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -11312,8 +11312,8 @@ type _Map__EnumValue__Unit__Repr _Map__EnumValue__Unit
 
 var _ ipld.Node = &_Map__EnumValue__Unit__Repr{}
 
-func (_Map__EnumValue__Unit__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_Map__EnumValue__Unit__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (nr *_Map__EnumValue__Unit__Repr) LookupByString(k string) (ipld.Node, error) {
 	v, err := (Map__EnumValue__Unit)(nr).LookupByString(k)
@@ -11498,8 +11498,8 @@ func (na *_Map__EnumValue__Unit__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__EnumValue__Unit.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__EnumValue__Unit.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -11724,8 +11724,8 @@ func (m MaybeMap__FieldName__StructField) Must() Map__FieldName__StructField {
 var _ ipld.Node = (Map__FieldName__StructField)(&_Map__FieldName__StructField{})
 var _ schema.TypedNode = (Map__FieldName__StructField)(&_Map__FieldName__StructField{})
 
-func (Map__FieldName__StructField) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (Map__FieldName__StructField) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n Map__FieldName__StructField) LookupByString(k string) (ipld.Node, error) {
 	var k2 _FieldName
@@ -11925,8 +11925,8 @@ func (na *_Map__FieldName__StructField__Assembler) ConvertFrom(v ipld.Node) erro
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__FieldName__StructField", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__FieldName__StructField", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -12081,8 +12081,8 @@ type _Map__FieldName__StructField__Repr _Map__FieldName__StructField
 
 var _ ipld.Node = &_Map__FieldName__StructField__Repr{}
 
-func (_Map__FieldName__StructField__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_Map__FieldName__StructField__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (nr *_Map__FieldName__StructField__Repr) LookupByString(k string) (ipld.Node, error) {
 	v, err := (Map__FieldName__StructField)(nr).LookupByString(k)
@@ -12267,8 +12267,8 @@ func (na *_Map__FieldName__StructField__ReprAssembler) ConvertFrom(v ipld.Node)
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__FieldName__StructField.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__FieldName__StructField.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -12493,8 +12493,8 @@ func (m MaybeMap__FieldName__StructRepresentation_Map_FieldDetails) Must() Map__
 var _ ipld.Node = (Map__FieldName__StructRepresentation_Map_FieldDetails)(&_Map__FieldName__StructRepresentation_Map_FieldDetails{})
 var _ schema.TypedNode = (Map__FieldName__StructRepresentation_Map_FieldDetails)(&_Map__FieldName__StructRepresentation_Map_FieldDetails{})
 
-func (Map__FieldName__StructRepresentation_Map_FieldDetails) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (Map__FieldName__StructRepresentation_Map_FieldDetails) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n Map__FieldName__StructRepresentation_Map_FieldDetails) LookupByString(k string) (ipld.Node, error) {
 	var k2 _FieldName
@@ -12694,8 +12694,8 @@ func (na *_Map__FieldName__StructRepresentation_Map_FieldDetails__Assembler) Con
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__FieldName__StructRepresentation_Map_FieldDetails", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__FieldName__StructRepresentation_Map_FieldDetails", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -12850,8 +12850,8 @@ type _Map__FieldName__StructRepresentation_Map_FieldDetails__Repr _Map__FieldNam
 
 var _ ipld.Node = &_Map__FieldName__StructRepresentation_Map_FieldDetails__Repr{}
 
-func (_Map__FieldName__StructRepresentation_Map_FieldDetails__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_Map__FieldName__StructRepresentation_Map_FieldDetails__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (nr *_Map__FieldName__StructRepresentation_Map_FieldDetails__Repr) LookupByString(k string) (ipld.Node, error) {
 	v, err := (Map__FieldName__StructRepresentation_Map_FieldDetails)(nr).LookupByString(k)
@@ -13036,8 +13036,8 @@ func (na *_Map__FieldName__StructRepresentation_Map_FieldDetails__ReprAssembler)
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__FieldName__StructRepresentation_Map_FieldDetails.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__FieldName__StructRepresentation_Map_FieldDetails.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -13262,8 +13262,8 @@ func (m MaybeMap__String__TypeName) Must() Map__String__TypeName {
 var _ ipld.Node = (Map__String__TypeName)(&_Map__String__TypeName{})
 var _ schema.TypedNode = (Map__String__TypeName)(&_Map__String__TypeName{})
 
-func (Map__String__TypeName) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (Map__String__TypeName) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n Map__String__TypeName) LookupByString(k string) (ipld.Node, error) {
 	var k2 _String
@@ -13463,8 +13463,8 @@ func (na *_Map__String__TypeName__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__String__TypeName", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__String__TypeName", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -13619,8 +13619,8 @@ type _Map__String__TypeName__Repr _Map__String__TypeName
 
 var _ ipld.Node = &_Map__String__TypeName__Repr{}
 
-func (_Map__String__TypeName__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_Map__String__TypeName__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (nr *_Map__String__TypeName__Repr) LookupByString(k string) (ipld.Node, error) {
 	v, err := (Map__String__TypeName)(nr).LookupByString(k)
@@ -13805,8 +13805,8 @@ func (na *_Map__String__TypeName__ReprAssembler) ConvertFrom(v ipld.Node) error
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__String__TypeName.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__String__TypeName.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -14031,8 +14031,8 @@ func (m MaybeMap__TypeName__Int) Must() Map__TypeName__Int {
 var _ ipld.Node = (Map__TypeName__Int)(&_Map__TypeName__Int{})
 var _ schema.TypedNode = (Map__TypeName__Int)(&_Map__TypeName__Int{})
 
-func (Map__TypeName__Int) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (Map__TypeName__Int) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n Map__TypeName__Int) LookupByString(k string) (ipld.Node, error) {
 	var k2 _String
@@ -14232,8 +14232,8 @@ func (na *_Map__TypeName__Int__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__TypeName__Int", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__TypeName__Int", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -14388,8 +14388,8 @@ type _Map__TypeName__Int__Repr _Map__TypeName__Int
 
 var _ ipld.Node = &_Map__TypeName__Int__Repr{}
 
-func (_Map__TypeName__Int__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_Map__TypeName__Int__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (nr *_Map__TypeName__Int__Repr) LookupByString(k string) (ipld.Node, error) {
 	v, err := (Map__TypeName__Int)(nr).LookupByString(k)
@@ -14574,8 +14574,8 @@ func (na *_Map__TypeName__Int__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__TypeName__Int.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.Map__TypeName__Int.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -14769,8 +14769,8 @@ func (m MaybeRepresentationKind) Must() RepresentationKind {
 var _ ipld.Node = (RepresentationKind)(&_RepresentationKind{})
 var _ schema.TypedNode = (RepresentationKind)(&_RepresentationKind{})
 
-func (RepresentationKind) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_String
+func (RepresentationKind) Kind() ipld.Kind {
+	return ipld.Kind_String
 }
 func (RepresentationKind) LookupByString(string) (ipld.Node, error) {
 	return mixins.String{"schemadmt.RepresentationKind"}.LookupByString("")
@@ -14981,8 +14981,8 @@ var (
 var _ ipld.Node = (Schema)(&_Schema{})
 var _ schema.TypedNode = (Schema)(&_Schema{})
 
-func (Schema) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (Schema) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n Schema) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -15180,8 +15180,8 @@ func (na *_Schema__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.Schema", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.Schema", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -15388,8 +15388,8 @@ var (
 )
 var _ ipld.Node = &_Schema__Repr{}
 
-func (_Schema__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_Schema__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_Schema__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -15581,8 +15581,8 @@ func (na *_Schema__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.Schema.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.Schema.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -15855,8 +15855,8 @@ func (m MaybeSchemaMap) Must() SchemaMap {
 var _ ipld.Node = (SchemaMap)(&_SchemaMap{})
 var _ schema.TypedNode = (SchemaMap)(&_SchemaMap{})
 
-func (SchemaMap) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (SchemaMap) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n SchemaMap) LookupByString(k string) (ipld.Node, error) {
 	var k2 _TypeName
@@ -16056,8 +16056,8 @@ func (na *_SchemaMap__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.SchemaMap", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.SchemaMap", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -16212,8 +16212,8 @@ type _SchemaMap__Repr _SchemaMap
 
 var _ ipld.Node = &_SchemaMap__Repr{}
 
-func (_SchemaMap__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_SchemaMap__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (nr *_SchemaMap__Repr) LookupByString(k string) (ipld.Node, error) {
 	v, err := (SchemaMap)(nr).LookupByString(k)
@@ -16398,8 +16398,8 @@ func (na *_SchemaMap__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.SchemaMap.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.SchemaMap.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -16593,8 +16593,8 @@ func (m MaybeString) Must() String {
 var _ ipld.Node = (String)(&_String{})
 var _ schema.TypedNode = (String)(&_String{})
 
-func (String) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_String
+func (String) Kind() ipld.Kind {
+	return ipld.Kind_String
 }
 func (String) LookupByString(string) (ipld.Node, error) {
 	return mixins.String{"schemadmt.String"}.LookupByString("")
@@ -16813,8 +16813,8 @@ var (
 var _ ipld.Node = (StructField)(&_StructField{})
 var _ schema.TypedNode = (StructField)(&_StructField{})
 
-func (StructField) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (StructField) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n StructField) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -17028,8 +17028,8 @@ func (na *_StructField__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructField", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructField", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -17306,8 +17306,8 @@ var (
 )
 var _ ipld.Node = &_StructField__Repr{}
 
-func (_StructField__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_StructField__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_StructField__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -17513,8 +17513,8 @@ func (na *_StructField__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructField.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructField.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -17834,8 +17834,8 @@ var (
 var _ ipld.Node = (StructRepresentation)(&_StructRepresentation{})
 var _ schema.TypedNode = (StructRepresentation)(&_StructRepresentation{})
 
-func (StructRepresentation) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (StructRepresentation) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n StructRepresentation) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -18084,8 +18084,8 @@ func (na *_StructRepresentation__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -18363,8 +18363,8 @@ var (
 )
 var _ ipld.Node = &_StructRepresentation__Repr{}
 
-func (_StructRepresentation__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_StructRepresentation__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_StructRepresentation__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -18613,8 +18613,8 @@ func (na *_StructRepresentation__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -18913,8 +18913,8 @@ var ()
 var _ ipld.Node = (StructRepresentation_Listpairs)(&_StructRepresentation_Listpairs{})
 var _ schema.TypedNode = (StructRepresentation_Listpairs)(&_StructRepresentation_Listpairs{})
 
-func (StructRepresentation_Listpairs) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (StructRepresentation_Listpairs) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n StructRepresentation_Listpairs) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -19104,8 +19104,8 @@ func (na *_StructRepresentation_Listpairs__Assembler) ConvertFrom(v ipld.Node) e
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Listpairs", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Listpairs", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -19276,8 +19276,8 @@ type _StructRepresentation_Listpairs__Repr _StructRepresentation_Listpairs
 var ()
 var _ ipld.Node = &_StructRepresentation_Listpairs__Repr{}
 
-func (_StructRepresentation_Listpairs__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_StructRepresentation_Listpairs__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_StructRepresentation_Listpairs__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -19462,8 +19462,8 @@ func (na *_StructRepresentation_Listpairs__ReprAssembler) ConvertFrom(v ipld.Nod
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Listpairs.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Listpairs.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -19667,8 +19667,8 @@ var (
 var _ ipld.Node = (StructRepresentation_Map)(&_StructRepresentation_Map{})
 var _ schema.TypedNode = (StructRepresentation_Map)(&_StructRepresentation_Map{})
 
-func (StructRepresentation_Map) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (StructRepresentation_Map) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n StructRepresentation_Map) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -19873,8 +19873,8 @@ func (na *_StructRepresentation_Map__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Map", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Map", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -20077,8 +20077,8 @@ var (
 )
 var _ ipld.Node = &_StructRepresentation_Map__Repr{}
 
-func (_StructRepresentation_Map__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_StructRepresentation_Map__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_StructRepresentation_Map__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -20289,8 +20289,8 @@ func (na *_StructRepresentation_Map__ReprAssembler) ConvertFrom(v ipld.Node) err
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Map.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Map.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -20530,8 +20530,8 @@ var (
 var _ ipld.Node = (StructRepresentation_Map_FieldDetails)(&_StructRepresentation_Map_FieldDetails{})
 var _ schema.TypedNode = (StructRepresentation_Map_FieldDetails)(&_StructRepresentation_Map_FieldDetails{})
 
-func (StructRepresentation_Map_FieldDetails) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (StructRepresentation_Map_FieldDetails) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n StructRepresentation_Map_FieldDetails) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -20751,8 +20751,8 @@ func (na *_StructRepresentation_Map_FieldDetails__Assembler) ConvertFrom(v ipld.
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Map_FieldDetails", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Map_FieldDetails", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -20986,8 +20986,8 @@ var (
 )
 var _ ipld.Node = &_StructRepresentation_Map_FieldDetails__Repr{}
 
-func (_StructRepresentation_Map_FieldDetails__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_StructRepresentation_Map_FieldDetails__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_StructRepresentation_Map_FieldDetails__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -21220,8 +21220,8 @@ func (na *_StructRepresentation_Map_FieldDetails__ReprAssembler) ConvertFrom(v i
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Map_FieldDetails.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Map_FieldDetails.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -21493,8 +21493,8 @@ var (
 var _ ipld.Node = (StructRepresentation_Stringjoin)(&_StructRepresentation_Stringjoin{})
 var _ schema.TypedNode = (StructRepresentation_Stringjoin)(&_StructRepresentation_Stringjoin{})
 
-func (StructRepresentation_Stringjoin) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (StructRepresentation_Stringjoin) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n StructRepresentation_Stringjoin) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -21707,8 +21707,8 @@ func (na *_StructRepresentation_Stringjoin__Assembler) ConvertFrom(v ipld.Node)
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Stringjoin", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Stringjoin", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -21946,8 +21946,8 @@ var (
 )
 var _ ipld.Node = &_StructRepresentation_Stringjoin__Repr{}
 
-func (_StructRepresentation_Stringjoin__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_StructRepresentation_Stringjoin__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_StructRepresentation_Stringjoin__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -22165,8 +22165,8 @@ func (na *_StructRepresentation_Stringjoin__ReprAssembler) ConvertFrom(v ipld.No
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Stringjoin.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Stringjoin.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -22439,8 +22439,8 @@ var (
 var _ ipld.Node = (StructRepresentation_Stringpairs)(&_StructRepresentation_Stringpairs{})
 var _ schema.TypedNode = (StructRepresentation_Stringpairs)(&_StructRepresentation_Stringpairs{})
 
-func (StructRepresentation_Stringpairs) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (StructRepresentation_Stringpairs) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n StructRepresentation_Stringpairs) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -22646,8 +22646,8 @@ func (na *_StructRepresentation_Stringpairs__Assembler) ConvertFrom(v ipld.Node)
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Stringpairs", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Stringpairs", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -22889,8 +22889,8 @@ var (
 )
 var _ ipld.Node = &_StructRepresentation_Stringpairs__Repr{}
 
-func (_StructRepresentation_Stringpairs__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_StructRepresentation_Stringpairs__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_StructRepresentation_Stringpairs__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -23089,8 +23089,8 @@ func (na *_StructRepresentation_Stringpairs__ReprAssembler) ConvertFrom(v ipld.N
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Stringpairs.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Stringpairs.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -23360,8 +23360,8 @@ var (
 var _ ipld.Node = (StructRepresentation_Tuple)(&_StructRepresentation_Tuple{})
 var _ schema.TypedNode = (StructRepresentation_Tuple)(&_StructRepresentation_Tuple{})
 
-func (StructRepresentation_Tuple) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (StructRepresentation_Tuple) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n StructRepresentation_Tuple) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -23566,8 +23566,8 @@ func (na *_StructRepresentation_Tuple__Assembler) ConvertFrom(v ipld.Node) error
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Tuple", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Tuple", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -23770,8 +23770,8 @@ var (
 )
 var _ ipld.Node = &_StructRepresentation_Tuple__Repr{}
 
-func (_StructRepresentation_Tuple__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_StructRepresentation_Tuple__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_StructRepresentation_Tuple__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -23982,8 +23982,8 @@ func (na *_StructRepresentation_Tuple__ReprAssembler) ConvertFrom(v ipld.Node) e
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Tuple.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.StructRepresentation_Tuple.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -24213,8 +24213,8 @@ var ()
 var _ ipld.Node = (TypeBool)(&_TypeBool{})
 var _ schema.TypedNode = (TypeBool)(&_TypeBool{})
 
-func (TypeBool) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeBool) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeBool) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -24404,8 +24404,8 @@ func (na *_TypeBool__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeBool", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeBool", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -24576,8 +24576,8 @@ type _TypeBool__Repr _TypeBool
 var ()
 var _ ipld.Node = &_TypeBool__Repr{}
 
-func (_TypeBool__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_TypeBool__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_TypeBool__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -24762,8 +24762,8 @@ func (na *_TypeBool__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeBool.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeBool.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -24961,8 +24961,8 @@ var ()
 var _ ipld.Node = (TypeBytes)(&_TypeBytes{})
 var _ schema.TypedNode = (TypeBytes)(&_TypeBytes{})
 
-func (TypeBytes) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeBytes) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeBytes) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -25152,8 +25152,8 @@ func (na *_TypeBytes__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeBytes", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeBytes", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -25324,8 +25324,8 @@ type _TypeBytes__Repr _TypeBytes
 var ()
 var _ ipld.Node = &_TypeBytes__Repr{}
 
-func (_TypeBytes__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_TypeBytes__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_TypeBytes__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -25510,8 +25510,8 @@ func (na *_TypeBytes__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeBytes.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeBytes.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -25715,8 +25715,8 @@ var (
 var _ ipld.Node = (TypeCopy)(&_TypeCopy{})
 var _ schema.TypedNode = (TypeCopy)(&_TypeCopy{})
 
-func (TypeCopy) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeCopy) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeCopy) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -25914,8 +25914,8 @@ func (na *_TypeCopy__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeCopy", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeCopy", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -26122,8 +26122,8 @@ var (
 )
 var _ ipld.Node = &_TypeCopy__Repr{}
 
-func (_TypeCopy__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_TypeCopy__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_TypeCopy__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -26315,8 +26315,8 @@ func (na *_TypeCopy__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeCopy.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeCopy.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -26591,8 +26591,8 @@ var (
 var _ ipld.Node = (TypeDefn)(&_TypeDefn{})
 var _ schema.TypedNode = (TypeDefn)(&_TypeDefn{})
 
-func (TypeDefn) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeDefn) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeDefn) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -26925,8 +26925,8 @@ func (na *_TypeDefn__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeDefn", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeDefn", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -27337,8 +27337,8 @@ var (
 )
 var _ ipld.Node = &_TypeDefn__Repr{}
 
-func (_TypeDefn__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_TypeDefn__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_TypeDefn__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -27671,8 +27671,8 @@ func (na *_TypeDefn__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeDefn.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeDefn.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -28104,8 +28104,8 @@ var (
 var _ ipld.Node = (TypeDefnInline)(&_TypeDefnInline{})
 var _ schema.TypedNode = (TypeDefnInline)(&_TypeDefnInline{})
 
-func (TypeDefnInline) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeDefnInline) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeDefnInline) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -28320,8 +28320,8 @@ func (na *_TypeDefnInline__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeDefnInline", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeDefnInline", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -28558,8 +28558,8 @@ var (
 )
 var _ ipld.Node = &_TypeDefnInline__Repr{}
 
-func (_TypeDefnInline__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_TypeDefnInline__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_TypeDefnInline__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -28774,8 +28774,8 @@ func (na *_TypeDefnInline__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeDefnInline.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeDefnInline.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -29046,8 +29046,8 @@ var (
 var _ ipld.Node = (TypeEnum)(&_TypeEnum{})
 var _ schema.TypedNode = (TypeEnum)(&_TypeEnum{})
 
-func (TypeEnum) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeEnum) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeEnum) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -29253,8 +29253,8 @@ func (na *_TypeEnum__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeEnum", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeEnum", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -29496,8 +29496,8 @@ var (
 )
 var _ ipld.Node = &_TypeEnum__Repr{}
 
-func (_TypeEnum__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_TypeEnum__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_TypeEnum__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -29696,8 +29696,8 @@ func (na *_TypeEnum__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeEnum.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeEnum.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -29961,8 +29961,8 @@ var ()
 var _ ipld.Node = (TypeFloat)(&_TypeFloat{})
 var _ schema.TypedNode = (TypeFloat)(&_TypeFloat{})
 
-func (TypeFloat) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeFloat) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeFloat) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -30152,8 +30152,8 @@ func (na *_TypeFloat__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeFloat", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeFloat", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -30324,8 +30324,8 @@ type _TypeFloat__Repr _TypeFloat
 var ()
 var _ ipld.Node = &_TypeFloat__Repr{}
 
-func (_TypeFloat__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_TypeFloat__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_TypeFloat__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -30510,8 +30510,8 @@ func (na *_TypeFloat__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeFloat.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeFloat.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -30709,8 +30709,8 @@ var ()
 var _ ipld.Node = (TypeInt)(&_TypeInt{})
 var _ schema.TypedNode = (TypeInt)(&_TypeInt{})
 
-func (TypeInt) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeInt) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeInt) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -30900,8 +30900,8 @@ func (na *_TypeInt__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeInt", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeInt", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -31072,8 +31072,8 @@ type _TypeInt__Repr _TypeInt
 var ()
 var _ ipld.Node = &_TypeInt__Repr{}
 
-func (_TypeInt__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_TypeInt__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_TypeInt__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -31258,8 +31258,8 @@ func (na *_TypeInt__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeInt.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeInt.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -31463,8 +31463,8 @@ var (
 var _ ipld.Node = (TypeLink)(&_TypeLink{})
 var _ schema.TypedNode = (TypeLink)(&_TypeLink{})
 
-func (TypeLink) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeLink) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeLink) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -31669,8 +31669,8 @@ func (na *_TypeLink__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeLink", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeLink", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -31873,8 +31873,8 @@ var (
 )
 var _ ipld.Node = &_TypeLink__Repr{}
 
-func (_TypeLink__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_TypeLink__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_TypeLink__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -32085,8 +32085,8 @@ func (na *_TypeLink__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeLink.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeLink.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -32330,8 +32330,8 @@ var (
 var _ ipld.Node = (TypeList)(&_TypeList{})
 var _ schema.TypedNode = (TypeList)(&_TypeList{})
 
-func (TypeList) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeList) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeList) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -32545,8 +32545,8 @@ func (na *_TypeList__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeList", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeList", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -32823,8 +32823,8 @@ var (
 )
 var _ ipld.Node = &_TypeList__Repr{}
 
-func (_TypeList__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_TypeList__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_TypeList__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -33030,8 +33030,8 @@ func (na *_TypeList__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeList.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeList.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -33346,8 +33346,8 @@ var (
 var _ ipld.Node = (TypeMap)(&_TypeMap{})
 var _ schema.TypedNode = (TypeMap)(&_TypeMap{})
 
-func (TypeMap) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeMap) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeMap) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -33569,8 +33569,8 @@ func (na *_TypeMap__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeMap", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeMap", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -33882,8 +33882,8 @@ var (
 )
 var _ ipld.Node = &_TypeMap__Repr{}
 
-func (_TypeMap__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_TypeMap__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_TypeMap__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -34096,8 +34096,8 @@ func (na *_TypeMap__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeMap.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeMap.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -34438,8 +34438,8 @@ func (m MaybeTypeName) Must() TypeName {
 var _ ipld.Node = (TypeName)(&_TypeName{})
 var _ schema.TypedNode = (TypeName)(&_TypeName{})
 
-func (TypeName) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_String
+func (TypeName) Kind() ipld.Kind {
+	return ipld.Kind_String
 }
 func (TypeName) LookupByString(string) (ipld.Node, error) {
 	return mixins.String{"schemadmt.TypeName"}.LookupByString("")
@@ -34658,8 +34658,8 @@ var (
 var _ ipld.Node = (TypeNameOrInlineDefn)(&_TypeNameOrInlineDefn{})
 var _ schema.TypedNode = (TypeNameOrInlineDefn)(&_TypeNameOrInlineDefn{})
 
-func (TypeNameOrInlineDefn) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeNameOrInlineDefn) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeNameOrInlineDefn) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -34872,8 +34872,8 @@ func (na *_TypeNameOrInlineDefn__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -35090,12 +35090,12 @@ type _TypeNameOrInlineDefn__Repr _TypeNameOrInlineDefn
 
 var _ ipld.Node = &_TypeNameOrInlineDefn__Repr{}
 
-func (n *_TypeNameOrInlineDefn__Repr) ReprKind() ipld.ReprKind {
+func (n *_TypeNameOrInlineDefn__Repr) Kind() ipld.Kind {
 	switch n.tag {
 	case 1:
-		return ipld.ReprKind_String
+		return ipld.Kind_String
 	case 2:
-		return ipld.ReprKind_Map
+		return ipld.Kind_Map
 	default:
 		panic("unreachable")
 	}
@@ -35105,7 +35105,7 @@ func (n *_TypeNameOrInlineDefn__Repr) LookupByString(key string) (ipld.Node, err
 	case 2:
 		return n.x2.Representation().LookupByString(key)
 	default:
-		return nil, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "LookupByString", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: n.ReprKind()}
+		return nil, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "LookupByString", AppropriateKind: ipld.KindSet_JustMap, ActualKind: n.Kind()}
 	}
 }
 func (n *_TypeNameOrInlineDefn__Repr) LookupByNode(key ipld.Node) (ipld.Node, error) {
@@ -35113,18 +35113,18 @@ func (n *_TypeNameOrInlineDefn__Repr) LookupByNode(key ipld.Node) (ipld.Node, er
 	case 2:
 		return n.x2.Representation().LookupByNode(key)
 	default:
-		return nil, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "LookupByNode", AppropriateKind: ipld.ReprKindSet_Recursive, ActualKind: n.ReprKind()}
+		return nil, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "LookupByNode", AppropriateKind: ipld.KindSet_Recursive, ActualKind: n.Kind()}
 	}
 }
 func (n *_TypeNameOrInlineDefn__Repr) LookupByIndex(idx int64) (ipld.Node, error) {
-	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "LookupByIndex", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: n.ReprKind()}
+	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "LookupByIndex", AppropriateKind: ipld.KindSet_JustList, ActualKind: n.Kind()}
 }
 func (n *_TypeNameOrInlineDefn__Repr) LookupBySegment(seg ipld.PathSegment) (ipld.Node, error) {
 	switch n.tag {
 	case 2:
 		return n.x2.Representation().LookupBySegment(seg)
 	default:
-		return nil, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "LookupBySegment", AppropriateKind: ipld.ReprKindSet_Recursive, ActualKind: n.ReprKind()}
+		return nil, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "LookupBySegment", AppropriateKind: ipld.KindSet_Recursive, ActualKind: n.Kind()}
 	}
 }
 func (n *_TypeNameOrInlineDefn__Repr) MapIterator() ipld.MapIterator {
@@ -35153,27 +35153,27 @@ func (n *_TypeNameOrInlineDefn__Repr) IsNull() bool {
 	return false
 }
 func (n *_TypeNameOrInlineDefn__Repr) AsBool() (bool, error) {
-	return false, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "AsBool", AppropriateKind: ipld.ReprKindSet_JustBool, ActualKind: n.ReprKind()}
+	return false, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "AsBool", AppropriateKind: ipld.KindSet_JustBool, ActualKind: n.Kind()}
 }
 func (n *_TypeNameOrInlineDefn__Repr) AsInt() (int64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "AsInt", AppropriateKind: ipld.ReprKindSet_JustInt, ActualKind: n.ReprKind()}
+	return 0, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "AsInt", AppropriateKind: ipld.KindSet_JustInt, ActualKind: n.Kind()}
 }
 func (n *_TypeNameOrInlineDefn__Repr) AsFloat() (float64, error) {
-	return 0, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "AsFloat", AppropriateKind: ipld.ReprKindSet_JustFloat, ActualKind: n.ReprKind()}
+	return 0, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "AsFloat", AppropriateKind: ipld.KindSet_JustFloat, ActualKind: n.Kind()}
 }
 func (n *_TypeNameOrInlineDefn__Repr) AsString() (string, error) {
 	switch n.tag {
 	case 1:
 		return n.x1.Representation().AsString()
 	default:
-		return "", ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "AsString", AppropriateKind: ipld.ReprKindSet_JustString, ActualKind: n.ReprKind()}
+		return "", ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "AsString", AppropriateKind: ipld.KindSet_JustString, ActualKind: n.Kind()}
 	}
 }
 func (n *_TypeNameOrInlineDefn__Repr) AsBytes() ([]byte, error) {
-	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "AsBytes", AppropriateKind: ipld.ReprKindSet_JustBytes, ActualKind: n.ReprKind()}
+	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "AsBytes", AppropriateKind: ipld.KindSet_JustBytes, ActualKind: n.Kind()}
 }
 func (n *_TypeNameOrInlineDefn__Repr) AsLink() (ipld.Link, error) {
-	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "AsLink", AppropriateKind: ipld.ReprKindSet_JustLink, ActualKind: n.ReprKind()}
+	return nil, ipld.ErrWrongKind{TypeName: "schemadmt.TypeNameOrInlineDefn.Repr", MethodName: "AsLink", AppropriateKind: ipld.KindSet_JustLink, ActualKind: n.Kind()}
 }
 func (_TypeNameOrInlineDefn__Repr) Prototype() ipld.NodePrototype {
 	return _TypeNameOrInlineDefn__ReprPrototype{}
@@ -35341,23 +35341,23 @@ func (na *_TypeNameOrInlineDefn__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	switch v.ReprKind() {
-	case ipld.ReprKind_Bool:
+	switch v.Kind() {
+	case ipld.Kind_Bool:
 		v2, _ := v.AsBool()
 		return na.AssignBool(v2)
-	case ipld.ReprKind_Int:
+	case ipld.Kind_Int:
 		v2, _ := v.AsInt()
 		return na.AssignInt(v2)
-	case ipld.ReprKind_Float:
+	case ipld.Kind_Float:
 		v2, _ := v.AsFloat()
 		return na.AssignFloat(v2)
-	case ipld.ReprKind_String:
+	case ipld.Kind_String:
 		v2, _ := v.AsString()
 		return na.AssignString(v2)
-	case ipld.ReprKind_Bytes:
+	case ipld.Kind_Bytes:
 		v2, _ := v.AsBytes()
 		return na.AssignBytes(v2)
-	case ipld.ReprKind_Map:
+	case ipld.Kind_Map:
 		na, err := na.BeginMap(v.Length())
 		if err != nil {
 			return err
@@ -35376,7 +35376,7 @@ func (na *_TypeNameOrInlineDefn__ReprAssembler) ConvertFrom(v ipld.Node) error {
 			}
 		}
 		return na.Finish()
-	case ipld.ReprKind_List:
+	case ipld.Kind_List:
 		na, err := na.BeginList(v.Length())
 		if err != nil {
 			return err
@@ -35392,7 +35392,7 @@ func (na *_TypeNameOrInlineDefn__ReprAssembler) ConvertFrom(v ipld.Node) error {
 			}
 		}
 		return na.Finish()
-	case ipld.ReprKind_Link:
+	case ipld.Kind_Link:
 		v2, _ := v.AsLink()
 		return na.AssignLink(v2)
 	default:
@@ -35441,8 +35441,8 @@ var ()
 var _ ipld.Node = (TypeString)(&_TypeString{})
 var _ schema.TypedNode = (TypeString)(&_TypeString{})
 
-func (TypeString) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeString) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeString) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -35632,8 +35632,8 @@ func (na *_TypeString__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeString", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeString", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -35804,8 +35804,8 @@ type _TypeString__Repr _TypeString
 var ()
 var _ ipld.Node = &_TypeString__Repr{}
 
-func (_TypeString__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_TypeString__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_TypeString__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -35990,8 +35990,8 @@ func (na *_TypeString__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeString.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeString.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -36199,8 +36199,8 @@ var (
 var _ ipld.Node = (TypeStruct)(&_TypeStruct{})
 var _ schema.TypedNode = (TypeStruct)(&_TypeStruct{})
 
-func (TypeStruct) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeStruct) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeStruct) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -36406,8 +36406,8 @@ func (na *_TypeStruct__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeStruct", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeStruct", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -36649,8 +36649,8 @@ var (
 )
 var _ ipld.Node = &_TypeStruct__Repr{}
 
-func (_TypeStruct__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_TypeStruct__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_TypeStruct__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -36849,8 +36849,8 @@ func (na *_TypeStruct__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeStruct.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeStruct.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -37124,8 +37124,8 @@ var (
 var _ ipld.Node = (TypeUnion)(&_TypeUnion{})
 var _ schema.TypedNode = (TypeUnion)(&_TypeUnion{})
 
-func (TypeUnion) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (TypeUnion) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n TypeUnion) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -37331,8 +37331,8 @@ func (na *_TypeUnion__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeUnion", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeUnion", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -37574,8 +37574,8 @@ var (
 )
 var _ ipld.Node = &_TypeUnion__Repr{}
 
-func (_TypeUnion__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_TypeUnion__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_TypeUnion__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -37774,8 +37774,8 @@ func (na *_TypeUnion__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeUnion.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.TypeUnion.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -38065,8 +38065,8 @@ var (
 var _ ipld.Node = (UnionRepresentation)(&_UnionRepresentation{})
 var _ schema.TypedNode = (UnionRepresentation)(&_UnionRepresentation{})
 
-func (UnionRepresentation) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (UnionRepresentation) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n UnionRepresentation) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -38327,8 +38327,8 @@ func (na *_UnionRepresentation__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -38625,8 +38625,8 @@ var (
 )
 var _ ipld.Node = &_UnionRepresentation__Repr{}
 
-func (_UnionRepresentation__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_UnionRepresentation__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_UnionRepresentation__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -38887,8 +38887,8 @@ func (na *_UnionRepresentation__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -39211,8 +39211,8 @@ var (
 var _ ipld.Node = (UnionRepresentation_BytePrefix)(&_UnionRepresentation_BytePrefix{})
 var _ schema.TypedNode = (UnionRepresentation_BytePrefix)(&_UnionRepresentation_BytePrefix{})
 
-func (UnionRepresentation_BytePrefix) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (UnionRepresentation_BytePrefix) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n UnionRepresentation_BytePrefix) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -39410,8 +39410,8 @@ func (na *_UnionRepresentation_BytePrefix__Assembler) ConvertFrom(v ipld.Node) e
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_BytePrefix", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_BytePrefix", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -39618,8 +39618,8 @@ var (
 )
 var _ ipld.Node = &_UnionRepresentation_BytePrefix__Repr{}
 
-func (_UnionRepresentation_BytePrefix__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_UnionRepresentation_BytePrefix__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_UnionRepresentation_BytePrefix__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -39811,8 +39811,8 @@ func (na *_UnionRepresentation_BytePrefix__ReprAssembler) ConvertFrom(v ipld.Nod
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_BytePrefix.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_BytePrefix.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -40057,8 +40057,8 @@ var (
 var _ ipld.Node = (UnionRepresentation_Envelope)(&_UnionRepresentation_Envelope{})
 var _ schema.TypedNode = (UnionRepresentation_Envelope)(&_UnionRepresentation_Envelope{})
 
-func (UnionRepresentation_Envelope) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (UnionRepresentation_Envelope) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n UnionRepresentation_Envelope) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -40272,8 +40272,8 @@ func (na *_UnionRepresentation_Envelope__Assembler) ConvertFrom(v ipld.Node) err
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Envelope", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Envelope", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -40550,8 +40550,8 @@ var (
 )
 var _ ipld.Node = &_UnionRepresentation_Envelope__Repr{}
 
-func (_UnionRepresentation_Envelope__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_UnionRepresentation_Envelope__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_UnionRepresentation_Envelope__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -40757,8 +40757,8 @@ func (na *_UnionRepresentation_Envelope__ReprAssembler) ConvertFrom(v ipld.Node)
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Envelope.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Envelope.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -41065,8 +41065,8 @@ var (
 var _ ipld.Node = (UnionRepresentation_Inline)(&_UnionRepresentation_Inline{})
 var _ schema.TypedNode = (UnionRepresentation_Inline)(&_UnionRepresentation_Inline{})
 
-func (UnionRepresentation_Inline) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (UnionRepresentation_Inline) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n UnionRepresentation_Inline) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -41272,8 +41272,8 @@ func (na *_UnionRepresentation_Inline__Assembler) ConvertFrom(v ipld.Node) error
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Inline", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Inline", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -41515,8 +41515,8 @@ var (
 )
 var _ ipld.Node = &_UnionRepresentation_Inline__Repr{}
 
-func (_UnionRepresentation_Inline__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_UnionRepresentation_Inline__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_UnionRepresentation_Inline__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -41715,8 +41715,8 @@ func (na *_UnionRepresentation_Inline__ReprAssembler) ConvertFrom(v ipld.Node) e
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Inline.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Inline.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -42022,8 +42022,8 @@ func (m MaybeUnionRepresentation_Keyed) Must() UnionRepresentation_Keyed {
 var _ ipld.Node = (UnionRepresentation_Keyed)(&_UnionRepresentation_Keyed{})
 var _ schema.TypedNode = (UnionRepresentation_Keyed)(&_UnionRepresentation_Keyed{})
 
-func (UnionRepresentation_Keyed) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (UnionRepresentation_Keyed) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n UnionRepresentation_Keyed) LookupByString(k string) (ipld.Node, error) {
 	var k2 _String
@@ -42223,8 +42223,8 @@ func (na *_UnionRepresentation_Keyed__Assembler) ConvertFrom(v ipld.Node) error
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Keyed", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Keyed", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -42379,8 +42379,8 @@ type _UnionRepresentation_Keyed__Repr _UnionRepresentation_Keyed
 
 var _ ipld.Node = &_UnionRepresentation_Keyed__Repr{}
 
-func (_UnionRepresentation_Keyed__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_UnionRepresentation_Keyed__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (nr *_UnionRepresentation_Keyed__Repr) LookupByString(k string) (ipld.Node, error) {
 	v, err := (UnionRepresentation_Keyed)(nr).LookupByString(k)
@@ -42565,8 +42565,8 @@ func (na *_UnionRepresentation_Keyed__ReprAssembler) ConvertFrom(v ipld.Node) er
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Keyed.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Keyed.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -42791,8 +42791,8 @@ func (m MaybeUnionRepresentation_Kinded) Must() UnionRepresentation_Kinded {
 var _ ipld.Node = (UnionRepresentation_Kinded)(&_UnionRepresentation_Kinded{})
 var _ schema.TypedNode = (UnionRepresentation_Kinded)(&_UnionRepresentation_Kinded{})
 
-func (UnionRepresentation_Kinded) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (UnionRepresentation_Kinded) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n UnionRepresentation_Kinded) LookupByString(k string) (ipld.Node, error) {
 	var k2 _RepresentationKind
@@ -42992,8 +42992,8 @@ func (na *_UnionRepresentation_Kinded__Assembler) ConvertFrom(v ipld.Node) error
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Kinded", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Kinded", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -43148,8 +43148,8 @@ type _UnionRepresentation_Kinded__Repr _UnionRepresentation_Kinded
 
 var _ ipld.Node = &_UnionRepresentation_Kinded__Repr{}
 
-func (_UnionRepresentation_Kinded__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_UnionRepresentation_Kinded__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (nr *_UnionRepresentation_Kinded__Repr) LookupByString(k string) (ipld.Node, error) {
 	v, err := (UnionRepresentation_Kinded)(nr).LookupByString(k)
@@ -43334,8 +43334,8 @@ func (na *_UnionRepresentation_Kinded__ReprAssembler) ConvertFrom(v ipld.Node) e
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Kinded.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_Kinded.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -43524,8 +43524,8 @@ var (
 var _ ipld.Node = (UnionRepresentation_StringPrefix)(&_UnionRepresentation_StringPrefix{})
 var _ schema.TypedNode = (UnionRepresentation_StringPrefix)(&_UnionRepresentation_StringPrefix{})
 
-func (UnionRepresentation_StringPrefix) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (UnionRepresentation_StringPrefix) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n UnionRepresentation_StringPrefix) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -43723,8 +43723,8 @@ func (na *_UnionRepresentation_StringPrefix__Assembler) ConvertFrom(v ipld.Node)
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_StringPrefix", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_StringPrefix", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -43931,8 +43931,8 @@ var (
 )
 var _ ipld.Node = &_UnionRepresentation_StringPrefix__Repr{}
 
-func (_UnionRepresentation_StringPrefix__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_UnionRepresentation_StringPrefix__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_UnionRepresentation_StringPrefix__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -44124,8 +44124,8 @@ func (na *_UnionRepresentation_StringPrefix__ReprAssembler) ConvertFrom(v ipld.N
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_StringPrefix.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.UnionRepresentation_StringPrefix.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -44356,8 +44356,8 @@ var ()
 var _ ipld.Node = (Unit)(&_Unit{})
 var _ schema.TypedNode = (Unit)(&_Unit{})
 
-func (Unit) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (Unit) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n Unit) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -44547,8 +44547,8 @@ func (na *_Unit__Assembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.Unit", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.Unit", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
@@ -44719,8 +44719,8 @@ type _Unit__Repr _Unit
 var ()
 var _ ipld.Node = &_Unit__Repr{}
 
-func (_Unit__Repr) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (_Unit__Repr) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (n *_Unit__Repr) LookupByString(key string) (ipld.Node, error) {
 	switch key {
@@ -44905,8 +44905,8 @@ func (na *_Unit__ReprAssembler) ConvertFrom(v ipld.Node) error {
 		*na.m = schema.Maybe_Value
 		return nil
 	}
-	if v.ReprKind() != ipld.ReprKind_Map {
-		return ipld.ErrWrongKind{TypeName: "schemadmt.Unit.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+	if v.Kind() != ipld.Kind_Map {
+		return ipld.ErrWrongKind{TypeName: "schemadmt.Unit.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 	}
 	itr := v.MapIterator()
 	for !itr.Done() {
diff --git a/schema/gen/go/adjunctCfg.go b/schema/gen/go/adjunctCfg.go
index d3d603fa..425178f7 100644
--- a/schema/gen/go/adjunctCfg.go
+++ b/schema/gen/go/adjunctCfg.go
@@ -89,7 +89,7 @@ func (cfg *AdjunctCfg) MaybeUsesPtr(t schema.Type) bool {
 // This should probably be improved in type-safety,
 // and validated more aggressively up front when adjcfg is loaded.
 func (cfg *AdjunctCfg) UnionMemlayout(t schema.Type) string {
-	if t.Kind() != schema.Kind_Union {
+	if t.TypeKind() != schema.TypeKind_Union {
 		panic(fmt.Errorf("%s is not a union!", t.Name()))
 	}
 	v, ok := cfg.CfgUnionMemlayout[t.Name()]
diff --git a/schema/gen/go/genBoolReprBool.go b/schema/gen/go/genBoolReprBool.go
index 35022a8b..ede73de1 100644
--- a/schema/gen/go/genBoolReprBool.go
+++ b/schema/gen/go/genBoolReprBool.go
@@ -52,7 +52,7 @@ func (g boolReprBoolReprGenerator) EmitNodeTypeAssertions(w io.Writer) {
 		var _ ipld.Node = &_{{ .Type | TypeSymbol }}__Repr{}
 	`, w, g.AdjCfg, g)
 }
-func (boolReprBoolReprGenerator) EmitNodeMethodReprKind(io.Writer)        {}
+func (boolReprBoolReprGenerator) EmitNodeMethodKind(io.Writer)            {}
 func (boolReprBoolReprGenerator) EmitNodeMethodLookupByString(io.Writer)  {}
 func (boolReprBoolReprGenerator) EmitNodeMethodLookupByNode(io.Writer)    {}
 func (boolReprBoolReprGenerator) EmitNodeMethodLookupByIndex(io.Writer)   {}
@@ -103,6 +103,6 @@ func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodAssignFloat(io.Wr
 func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodAssignString(io.Writer) {}
 func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodAssignBytes(io.Writer)  {}
 func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodAssignLink(io.Writer)   {}
-func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(io.Writer)   {}
+func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(io.Writer)  {}
 func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerMethodPrototype(io.Writer)    {}
 func (boolReprBoolReprBuilderGenerator) EmitNodeAssemblerOtherBits(io.Writer)          {}
diff --git a/schema/gen/go/genBytesReprBytes.go b/schema/gen/go/genBytesReprBytes.go
index 1e933739..96f87ee3 100644
--- a/schema/gen/go/genBytesReprBytes.go
+++ b/schema/gen/go/genBytesReprBytes.go
@@ -52,7 +52,7 @@ func (g bytesReprBytesReprGenerator) EmitNodeTypeAssertions(w io.Writer) {
 		var _ ipld.Node = &_{{ .Type | TypeSymbol }}__Repr{}
 	`, w, g.AdjCfg, g)
 }
-func (bytesReprBytesReprGenerator) EmitNodeMethodReprKind(io.Writer)        {}
+func (bytesReprBytesReprGenerator) EmitNodeMethodKind(io.Writer)            {}
 func (bytesReprBytesReprGenerator) EmitNodeMethodLookupByString(io.Writer)  {}
 func (bytesReprBytesReprGenerator) EmitNodeMethodLookupByNode(io.Writer)    {}
 func (bytesReprBytesReprGenerator) EmitNodeMethodLookupByIndex(io.Writer)   {}
@@ -103,6 +103,6 @@ func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodAssignFloat(io.
 func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodAssignString(io.Writer) {}
 func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodAssignBytes(io.Writer)  {}
 func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodAssignLink(io.Writer)   {}
-func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(io.Writer)   {}
+func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(io.Writer)  {}
 func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerMethodPrototype(io.Writer)    {}
 func (bytesReprBytesReprBuilderGenerator) EmitNodeAssemblerOtherBits(io.Writer)          {}
diff --git a/schema/gen/go/genFloatReprFloat.go b/schema/gen/go/genFloatReprFloat.go
index 446fe48f..0564b340 100644
--- a/schema/gen/go/genFloatReprFloat.go
+++ b/schema/gen/go/genFloatReprFloat.go
@@ -52,7 +52,7 @@ func (g float64ReprFloatReprGenerator) EmitNodeTypeAssertions(w io.Writer) {
 		var _ ipld.Node = &_{{ .Type | TypeSymbol }}__Repr{}
 	`, w, g.AdjCfg, g)
 }
-func (float64ReprFloatReprGenerator) EmitNodeMethodReprKind(io.Writer)        {}
+func (float64ReprFloatReprGenerator) EmitNodeMethodKind(io.Writer)            {}
 func (float64ReprFloatReprGenerator) EmitNodeMethodLookupByString(io.Writer)  {}
 func (float64ReprFloatReprGenerator) EmitNodeMethodLookupByNode(io.Writer)    {}
 func (float64ReprFloatReprGenerator) EmitNodeMethodLookupByIndex(io.Writer)   {}
@@ -103,6 +103,6 @@ func (float64ReprFloatReprBuilderGenerator) EmitNodeAssemblerMethodAssignFloat(i
 func (float64ReprFloatReprBuilderGenerator) EmitNodeAssemblerMethodAssignString(io.Writer) {}
 func (float64ReprFloatReprBuilderGenerator) EmitNodeAssemblerMethodAssignBytes(io.Writer)  {}
 func (float64ReprFloatReprBuilderGenerator) EmitNodeAssemblerMethodAssignLink(io.Writer)   {}
-func (float64ReprFloatReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(io.Writer)   {}
+func (float64ReprFloatReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(io.Writer)  {}
 func (float64ReprFloatReprBuilderGenerator) EmitNodeAssemblerMethodPrototype(io.Writer)    {}
 func (float64ReprFloatReprBuilderGenerator) EmitNodeAssemblerOtherBits(io.Writer)          {}
diff --git a/schema/gen/go/genIntReprInt.go b/schema/gen/go/genIntReprInt.go
index b60821bc..2df9ab71 100644
--- a/schema/gen/go/genIntReprInt.go
+++ b/schema/gen/go/genIntReprInt.go
@@ -52,7 +52,7 @@ func (g intReprIntReprGenerator) EmitNodeTypeAssertions(w io.Writer) {
 		var _ ipld.Node = &_{{ .Type | TypeSymbol }}__Repr{}
 	`, w, g.AdjCfg, g)
 }
-func (intReprIntReprGenerator) EmitNodeMethodReprKind(io.Writer)        {}
+func (intReprIntReprGenerator) EmitNodeMethodKind(io.Writer)            {}
 func (intReprIntReprGenerator) EmitNodeMethodLookupByString(io.Writer)  {}
 func (intReprIntReprGenerator) EmitNodeMethodLookupByNode(io.Writer)    {}
 func (intReprIntReprGenerator) EmitNodeMethodLookupByIndex(io.Writer)   {}
@@ -103,6 +103,6 @@ func (intReprIntReprBuilderGenerator) EmitNodeAssemblerMethodAssignFloat(io.Writ
 func (intReprIntReprBuilderGenerator) EmitNodeAssemblerMethodAssignString(io.Writer) {}
 func (intReprIntReprBuilderGenerator) EmitNodeAssemblerMethodAssignBytes(io.Writer)  {}
 func (intReprIntReprBuilderGenerator) EmitNodeAssemblerMethodAssignLink(io.Writer)   {}
-func (intReprIntReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(io.Writer)   {}
+func (intReprIntReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(io.Writer)  {}
 func (intReprIntReprBuilderGenerator) EmitNodeAssemblerMethodPrototype(io.Writer)    {}
 func (intReprIntReprBuilderGenerator) EmitNodeAssemblerOtherBits(io.Writer)          {}
diff --git a/schema/gen/go/genLinkReprLink.go b/schema/gen/go/genLinkReprLink.go
index 79fd168d..de78e2c8 100644
--- a/schema/gen/go/genLinkReprLink.go
+++ b/schema/gen/go/genLinkReprLink.go
@@ -52,7 +52,7 @@ func (g linkReprLinkReprGenerator) EmitNodeTypeAssertions(w io.Writer) {
 		var _ ipld.Node = &_{{ .Type | TypeSymbol }}__Repr{}
 	`, w, g.AdjCfg, g)
 }
-func (linkReprLinkReprGenerator) EmitNodeMethodReprKind(io.Writer)        {}
+func (linkReprLinkReprGenerator) EmitNodeMethodKind(io.Writer)            {}
 func (linkReprLinkReprGenerator) EmitNodeMethodLookupByString(io.Writer)  {}
 func (linkReprLinkReprGenerator) EmitNodeMethodLookupByNode(io.Writer)    {}
 func (linkReprLinkReprGenerator) EmitNodeMethodLookupByIndex(io.Writer)   {}
@@ -103,6 +103,6 @@ func (linkReprLinkReprBuilderGenerator) EmitNodeAssemblerMethodAssignFloat(io.Wr
 func (linkReprLinkReprBuilderGenerator) EmitNodeAssemblerMethodAssignString(io.Writer) {}
 func (linkReprLinkReprBuilderGenerator) EmitNodeAssemblerMethodAssignBytes(io.Writer)  {}
 func (linkReprLinkReprBuilderGenerator) EmitNodeAssemblerMethodAssignLink(io.Writer)   {}
-func (linkReprLinkReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(io.Writer)   {}
+func (linkReprLinkReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(io.Writer)  {}
 func (linkReprLinkReprBuilderGenerator) EmitNodeAssemblerMethodPrototype(io.Writer)    {}
 func (linkReprLinkReprBuilderGenerator) EmitNodeAssemblerOtherBits(io.Writer)          {}
diff --git a/schema/gen/go/genList.go b/schema/gen/go/genList.go
index 2e0640b4..32fc8311 100644
--- a/schema/gen/go/genList.go
+++ b/schema/gen/go/genList.go
@@ -22,7 +22,7 @@ func (g listGenerator) EmitNativeType(w io.Writer) {
 	// Lists are a pretty straightforward struct enclosing a slice.
 	doTemplate(`
 		{{- if Comments -}}
-		// {{ .Type | TypeSymbol }} matches the IPLD Schema type "{{ .Type.Name }}".  It has {{ .ReprKind }} kind.
+		// {{ .Type | TypeSymbol }} matches the IPLD Schema type "{{ .Type.Name }}".  It has {{ .Kind }} kind.
 		{{- end}}
 		type {{ .Type | TypeSymbol }} = *_{{ .Type | TypeSymbol }}
 		type _{{ .Type | TypeSymbol }} struct {
diff --git a/schema/gen/go/genMap.go b/schema/gen/go/genMap.go
index 861a2995..9a43557f 100644
--- a/schema/gen/go/genMap.go
+++ b/schema/gen/go/genMap.go
@@ -26,7 +26,7 @@ func (g mapGenerator) EmitNativeType(w io.Writer) {
 	// The value in 'm' is a pointer into 't' (except when it's a maybe; maybes are already pointers).
 	doTemplate(`
 		{{- if Comments -}}
-		// {{ .Type | TypeSymbol }} matches the IPLD Schema type "{{ .Type.Name }}".  It has {{ .ReprKind }} kind.
+		// {{ .Type | TypeSymbol }} matches the IPLD Schema type "{{ .Type.Name }}".  It has {{ .Kind }} kind.
 		{{- end}}
 		type {{ .Type | TypeSymbol }} = *_{{ .Type | TypeSymbol }}
 		type _{{ .Type | TypeSymbol }} struct {
@@ -167,7 +167,7 @@ func (g mapGenerator) EmitNodeMethodLookupByString(w io.Writer) {
 	doTemplate(`
 		func (n {{ .Type | TypeSymbol }}) LookupByString(k string) (ipld.Node, error) {
 			var k2 _{{ .Type.KeyType | TypeSymbol }}
-			{{- if eq .Type.KeyType.Kind.String "String" }}
+			{{- if eq .Type.KeyType.TypeKind.String "String" }}
 			if err := (_{{ .Type.KeyType | TypeSymbol }}__Prototype{}).fromString(&k2, k); err != nil {
 				return nil, err // TODO wrap in some kind of ErrInvalidKey
 			}
diff --git a/schema/gen/go/genStringReprString.go b/schema/gen/go/genStringReprString.go
index 88446aa2..2b9a0317 100644
--- a/schema/gen/go/genStringReprString.go
+++ b/schema/gen/go/genStringReprString.go
@@ -52,7 +52,7 @@ func (g stringReprStringReprGenerator) EmitNodeTypeAssertions(w io.Writer) {
 		var _ ipld.Node = &_{{ .Type | TypeSymbol }}__Repr{}
 	`, w, g.AdjCfg, g)
 }
-func (stringReprStringReprGenerator) EmitNodeMethodReprKind(io.Writer)        {}
+func (stringReprStringReprGenerator) EmitNodeMethodKind(io.Writer)            {}
 func (stringReprStringReprGenerator) EmitNodeMethodLookupByString(io.Writer)  {}
 func (stringReprStringReprGenerator) EmitNodeMethodLookupByNode(io.Writer)    {}
 func (stringReprStringReprGenerator) EmitNodeMethodLookupByIndex(io.Writer)   {}
@@ -103,6 +103,6 @@ func (stringReprStringReprBuilderGenerator) EmitNodeAssemblerMethodAssignFloat(i
 func (stringReprStringReprBuilderGenerator) EmitNodeAssemblerMethodAssignString(io.Writer) {}
 func (stringReprStringReprBuilderGenerator) EmitNodeAssemblerMethodAssignBytes(io.Writer)  {}
 func (stringReprStringReprBuilderGenerator) EmitNodeAssemblerMethodAssignLink(io.Writer)   {}
-func (stringReprStringReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(io.Writer)   {}
+func (stringReprStringReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(io.Writer)  {}
 func (stringReprStringReprBuilderGenerator) EmitNodeAssemblerMethodPrototype(io.Writer)    {}
 func (stringReprStringReprBuilderGenerator) EmitNodeAssemblerOtherBits(io.Writer)          {}
diff --git a/schema/gen/go/genStruct.go b/schema/gen/go/genStruct.go
index aea2d6d3..39db4104 100644
--- a/schema/gen/go/genStruct.go
+++ b/schema/gen/go/genStruct.go
@@ -21,7 +21,7 @@ func (structGenerator) IsRepr() bool { return false } // hint used in some gener
 func (g structGenerator) EmitNativeType(w io.Writer) {
 	doTemplate(`
 		{{- if Comments -}}
-		// {{ .Type | TypeSymbol }} matches the IPLD Schema type "{{ .Type.Name }}".  It has {{ .Type.Kind }} type-kind, and may be interrogated like {{ .ReprKind }} kind.
+		// {{ .Type | TypeSymbol }} matches the IPLD Schema type "{{ .Type.Name }}".  It has {{ .Type.TypeKind }} type-kind, and may be interrogated like {{ .Kind }} kind.
 		{{- end}}
 		type {{ .Type | TypeSymbol }} = *_{{ .Type | TypeSymbol }}
 		type _{{ .Type | TypeSymbol }} struct {
@@ -310,8 +310,8 @@ func (g structBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(w io.Writer)
 				*na.m = schema.Maybe_Value
 				return nil
 			}
-			if v.ReprKind() != ipld.ReprKind_Map {
-				return ipld.ErrWrongKind{TypeName: "{{ .PkgName }}.{{ .Type.Name }}", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+			if v.Kind() != ipld.Kind_Map {
+				return ipld.ErrWrongKind{TypeName: "{{ .PkgName }}.{{ .Type.Name }}", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 			}
 			itr := v.MapIterator()
 			for !itr.Done() {
diff --git a/schema/gen/go/genStructReprMap.go b/schema/gen/go/genStructReprMap.go
index 9c7c7f23..eae6bb91 100644
--- a/schema/gen/go/genStructReprMap.go
+++ b/schema/gen/go/genStructReprMap.go
@@ -359,8 +359,8 @@ func (g structReprMapReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(w
 				*na.m = schema.Maybe_Value
 				return nil
 			}
-			if v.ReprKind() != ipld.ReprKind_Map {
-				return ipld.ErrWrongKind{TypeName: "{{ .PkgName }}.{{ .Type.Name }}.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+			if v.Kind() != ipld.Kind_Map {
+				return ipld.ErrWrongKind{TypeName: "{{ .PkgName }}.{{ .Type.Name }}.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 			}
 			itr := v.MapIterator()
 			for !itr.Done() {
diff --git a/schema/gen/go/genUnion.go b/schema/gen/go/genUnion.go
index 007c56f5..ed39baf3 100644
--- a/schema/gen/go/genUnion.go
+++ b/schema/gen/go/genUnion.go
@@ -46,7 +46,7 @@ func (g unionGenerator) EmitNativeType(w io.Writer) {
 	// and since we do it in that one case, it's just as well to do it uniformly.
 	doTemplate(`
 		{{- if Comments -}}
-		// {{ .Type | TypeSymbol }} matches the IPLD Schema type "{{ .Type.Name }}".  It has {{ .Type.Kind }} type-kind, and may be interrogated like {{ .ReprKind }} kind.
+		// {{ .Type | TypeSymbol }} matches the IPLD Schema type "{{ .Type.Name }}".  It has {{ .Type.TypeKind }} type-kind, and may be interrogated like {{ .Kind }} kind.
 		{{- end}}
 		type {{ .Type | TypeSymbol }} = *_{{ .Type | TypeSymbol }}
 		type _{{ .Type | TypeSymbol }} struct {
@@ -371,8 +371,8 @@ func (g unionBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(w io.Writer) {
 				*na.m = schema.Maybe_Value
 				return nil
 			}
-			if v.ReprKind() != ipld.ReprKind_Map {
-				return ipld.ErrWrongKind{TypeName: "{{ .PkgName }}.{{ .Type.Name }}", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+			if v.Kind() != ipld.Kind_Map {
+				return ipld.ErrWrongKind{TypeName: "{{ .PkgName }}.{{ .Type.Name }}", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 			}
 			itr := v.MapIterator()
 			for !itr.Done() {
diff --git a/schema/gen/go/genUnionReprKeyed.go b/schema/gen/go/genUnionReprKeyed.go
index 24f1786a..e88aa940 100644
--- a/schema/gen/go/genUnionReprKeyed.go
+++ b/schema/gen/go/genUnionReprKeyed.go
@@ -273,8 +273,8 @@ func (g unionReprKeyedReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(w
 				*na.m = schema.Maybe_Value
 				return nil
 			}
-			if v.ReprKind() != ipld.ReprKind_Map {
-				return ipld.ErrWrongKind{TypeName: "{{ .PkgName }}.{{ .Type.Name }}.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+			if v.Kind() != ipld.Kind_Map {
+				return ipld.ErrWrongKind{TypeName: "{{ .PkgName }}.{{ .Type.Name }}.Repr", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 			}
 			itr := v.MapIterator()
 			for !itr.Done() {
diff --git a/schema/gen/go/genUnionReprKinded.go b/schema/gen/go/genUnionReprKinded.go
index 6825abdc..71cdf18b 100644
--- a/schema/gen/go/genUnionReprKinded.go
+++ b/schema/gen/go/genUnionReprKinded.go
@@ -7,7 +7,7 @@ import (
 	"github.com/ipld/go-ipld-prime/schema/gen/go/mixins"
 )
 
-var _ TypeGenerator = &unionReprKindedGenerator{}
+var _ TypeGenerator = &unionKindedGenerator{}
 
 // Kinded union representations are quite wild: their behavior varies almost completely per inhabitant,
 //  and their implementation is generally delegating directly to something else,
@@ -18,8 +18,8 @@ var _ TypeGenerator = &unionReprKindedGenerator{}
 //  this depends on whether the error is an ErrWrongKind that was found while checking the method for appropriateness on the union's inhabitant
 //  versus if the error came from the union inhabitant itself after delegation occured.
 
-func NewUnionReprKindedGenerator(pkgName string, typ *schema.TypeUnion, adjCfg *AdjunctCfg) TypeGenerator {
-	return unionReprKindedGenerator{
+func NewUnionKindedGenerator(pkgName string, typ *schema.TypeUnion, adjCfg *AdjunctCfg) TypeGenerator {
+	return unionKindedGenerator{
 		unionGenerator{
 			adjCfg,
 			mixins.MapTraits{
@@ -33,19 +33,19 @@ func NewUnionReprKindedGenerator(pkgName string, typ *schema.TypeUnion, adjCfg *
 	}
 }
 
-type unionReprKindedGenerator struct {
+type unionKindedGenerator struct {
 	unionGenerator
 }
 
-func (g unionReprKindedGenerator) GetRepresentationNodeGen() NodeGenerator {
-	return unionReprKindedReprGenerator{
+func (g unionKindedGenerator) GetRepresentationNodeGen() NodeGenerator {
+	return unionKindedReprGenerator{
 		g.AdjCfg,
 		g.PkgName,
 		g.Type,
 	}
 }
 
-type unionReprKindedReprGenerator struct {
+type unionKindedReprGenerator struct {
 	// Note that there's no MapTraits (or any other FooTraits) mixin in this one!
 	//  This is no accident: *None* of them apply!
 
@@ -54,24 +54,24 @@ type unionReprKindedReprGenerator struct {
 	Type    *schema.TypeUnion
 }
 
-func (unionReprKindedReprGenerator) IsRepr() bool { return true } // hint used in some generalized templates.
+func (unionKindedReprGenerator) IsRepr() bool { return true } // hint used in some generalized templates.
 
-func (g unionReprKindedReprGenerator) EmitNodeType(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeType(w io.Writer) {
 	// The type is structurally the same, but will have a different set of methods.
 	doTemplate(`
 		type _{{ .Type | TypeSymbol }}__Repr _{{ .Type | TypeSymbol }}
 	`, w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeTypeAssertions(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeTypeAssertions(w io.Writer) {
 	doTemplate(`
 		var _ ipld.Node = &_{{ .Type | TypeSymbol }}__Repr{}
 	`, w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodReprKind(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodKind(w io.Writer) {
 	doTemplate(`
-		func (n *_{{ .Type | TypeSymbol }}__Repr) ReprKind() ipld.ReprKind {
+		func (n *_{{ .Type | TypeSymbol }}__Repr) Kind() ipld.Kind {
 			{{- if (eq (.AdjCfg.UnionMemlayout .Type) "embedAll") }}
 			switch n.tag {
 			{{- range $i, $member := .Type.Members }}
@@ -115,7 +115,7 @@ func kindedUnionNodeMethodTemplateMunge(
 
 	errorClause := `return ` + nopeSentinel
 	if !nopeSentinelOnly {
-		errorClause += `, ipld.ErrWrongKind{TypeName: "{{ .PkgName }}.{{ .Type.Name }}.Repr", MethodName: "` + methodName + `", AppropriateKind: ` + appropriateKind + `, ActualKind: n.ReprKind()}`
+		errorClause += `, ipld.ErrWrongKind{TypeName: "{{ .PkgName }}.{{ .Type.Name }}.Repr", MethodName: "` + methodName + `", AppropriateKind: ` + appropriateKind + `, ActualKind: n.Kind()}`
 	}
 	return `
 		func (n *_{{ .Type | TypeSymbol }}__Repr) ` + methodSig + ` {
@@ -147,98 +147,98 @@ func kindedUnionNodeMethodTemplateMunge(
 	`
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodLookupByString(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodLookupByString(w io.Writer) {
 	doTemplate(kindedUnionNodeMethodTemplateMunge(
 		`LookupByString`,
 		`LookupByString(key string) (ipld.Node, error)`,
 		`{{- if .Type.RepresentationStrategy.GetMember (Kind "map") }}`,
 		`{{- if eq $member.RepresentationBehavior.String "map" }}`,
 		`.LookupByString(key)`,
-		`ipld.ReprKindSet_JustMap`,
+		`ipld.KindSet_JustMap`,
 		`nil`,
 		false,
 	), w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodLookupByIndex(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodLookupByIndex(w io.Writer) {
 	doTemplate(kindedUnionNodeMethodTemplateMunge(
 		`LookupByIndex`,
 		`LookupByIndex(idx int64) (ipld.Node, error)`,
 		`{{- if .Type.RepresentationStrategy.GetMember (Kind "list") }}`,
 		`{{- if eq $member.RepresentationBehavior.String "list" }}`,
 		`.LookupByIndex(idx)`,
-		`ipld.ReprKindSet_JustList`,
+		`ipld.KindSet_JustList`,
 		`nil`,
 		false,
 	), w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodLookupByNode(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodLookupByNode(w io.Writer) {
 	doTemplate(kindedUnionNodeMethodTemplateMunge(
 		`LookupByNode`,
 		`LookupByNode(key ipld.Node) (ipld.Node, error)`,
 		`{{- if or (.Type.RepresentationStrategy.GetMember (Kind "map")) (.Type.RepresentationStrategy.GetMember (Kind "list")) }}`,
 		`{{- if or (eq $member.RepresentationBehavior.String "map") (eq $member.RepresentationBehavior.String "list") }}`,
 		`.LookupByNode(key)`,
-		`ipld.ReprKindSet_Recursive`,
+		`ipld.KindSet_Recursive`,
 		`nil`,
 		false,
 	), w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodLookupBySegment(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodLookupBySegment(w io.Writer) {
 	doTemplate(kindedUnionNodeMethodTemplateMunge(
 		`LookupBySegment`,
 		`LookupBySegment(seg ipld.PathSegment) (ipld.Node, error)`,
 		`{{- if or (.Type.RepresentationStrategy.GetMember (Kind "map")) (.Type.RepresentationStrategy.GetMember (Kind "list")) }}`,
 		`{{- if or (eq $member.RepresentationBehavior.String "map") (eq $member.RepresentationBehavior.String "list") }}`,
 		`.LookupBySegment(seg)`,
-		`ipld.ReprKindSet_Recursive`,
+		`ipld.KindSet_Recursive`,
 		`nil`,
 		false,
 	), w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodMapIterator(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodMapIterator(w io.Writer) {
 	doTemplate(kindedUnionNodeMethodTemplateMunge(
 		`MapIterator`,
 		`MapIterator() ipld.MapIterator`,
 		`{{- if .Type.RepresentationStrategy.GetMember (Kind "map") }}`,
 		`{{- if eq $member.RepresentationBehavior.String "map" }}`,
 		`.MapIterator()`,
-		`ipld.ReprKindSet_JustMap`,
+		`ipld.KindSet_JustMap`,
 		`nil`,
 		true,
 	), w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodListIterator(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodListIterator(w io.Writer) {
 	doTemplate(kindedUnionNodeMethodTemplateMunge(
 		`ListIterator`,
 		`ListIterator() ipld.ListIterator`,
 		`{{- if .Type.RepresentationStrategy.GetMember (Kind "list") }}`,
 		`{{- if eq $member.RepresentationBehavior.String "list" }}`,
 		`.ListIterator()`,
-		`ipld.ReprKindSet_JustList`,
+		`ipld.KindSet_JustList`,
 		`nil`,
 		true,
 	), w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodLength(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodLength(w io.Writer) {
 	doTemplate(kindedUnionNodeMethodTemplateMunge(
 		`Length`,
 		`Length() int64`,
 		`{{- if or (.Type.RepresentationStrategy.GetMember (Kind "map")) (.Type.RepresentationStrategy.GetMember (Kind "list")) }}`,
 		`{{- if or (eq $member.RepresentationBehavior.String "map") (eq $member.RepresentationBehavior.String "list") }}`,
 		`.Length()`,
-		`ipld.ReprKindSet_Recursive`,
+		`ipld.KindSet_Recursive`,
 		`-1`,
 		true,
 	), w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodIsAbsent(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodIsAbsent(w io.Writer) {
 	doTemplate(`
 		func (n *_{{ .Type | TypeSymbol }}__Repr) IsAbsent() bool {
 			return false
@@ -246,7 +246,7 @@ func (g unionReprKindedReprGenerator) EmitNodeMethodIsAbsent(w io.Writer) {
 	`, w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodIsNull(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodIsNull(w io.Writer) {
 	doTemplate(`
 		func (n *_{{ .Type | TypeSymbol }}__Repr) IsNull() bool {
 			return false
@@ -254,117 +254,117 @@ func (g unionReprKindedReprGenerator) EmitNodeMethodIsNull(w io.Writer) {
 	`, w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodAsBool(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodAsBool(w io.Writer) {
 	doTemplate(kindedUnionNodeMethodTemplateMunge(
 		`AsBool`,
 		`AsBool() (bool, error)`,
 		`{{- if .Type.RepresentationStrategy.GetMember (Kind "bool") }}`,
 		`{{- if eq $member.RepresentationBehavior.String "bool" }}`,
 		`.AsBool()`,
-		`ipld.ReprKindSet_JustBool`,
+		`ipld.KindSet_JustBool`,
 		`false`,
 		false,
 	), w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodAsInt(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodAsInt(w io.Writer) {
 	doTemplate(kindedUnionNodeMethodTemplateMunge(
 		`AsInt`,
 		`AsInt() (int64, error)`,
 		`{{- if .Type.RepresentationStrategy.GetMember (Kind "int") }}`,
 		`{{- if eq $member.RepresentationBehavior.String "int" }}`,
 		`.AsInt()`,
-		`ipld.ReprKindSet_JustInt`,
+		`ipld.KindSet_JustInt`,
 		`0`,
 		false,
 	), w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodAsFloat(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodAsFloat(w io.Writer) {
 	doTemplate(kindedUnionNodeMethodTemplateMunge(
 		`AsFloat`,
 		`AsFloat() (float64, error)`,
 		`{{- if .Type.RepresentationStrategy.GetMember (Kind "float") }}`,
 		`{{- if eq $member.RepresentationBehavior.String "float" }}`,
 		`.AsFloat()`,
-		`ipld.ReprKindSet_JustFloat`,
+		`ipld.KindSet_JustFloat`,
 		`0`,
 		false,
 	), w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodAsString(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodAsString(w io.Writer) {
 	doTemplate(kindedUnionNodeMethodTemplateMunge(
 		`AsString`,
 		`AsString() (string, error)`,
 		`{{- if .Type.RepresentationStrategy.GetMember (Kind "string") }}`,
 		`{{- if eq $member.RepresentationBehavior.String "string" }}`,
 		`.AsString()`,
-		`ipld.ReprKindSet_JustString`,
+		`ipld.KindSet_JustString`,
 		`""`,
 		false,
 	), w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodAsBytes(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodAsBytes(w io.Writer) {
 	doTemplate(kindedUnionNodeMethodTemplateMunge(
 		`AsBytes`,
 		`AsBytes() ([]byte, error)`,
 		`{{- if .Type.RepresentationStrategy.GetMember (Kind "bytes") }}`,
 		`{{- if eq $member.RepresentationBehavior.String "bytes" }}`,
 		`.AsBytes()`,
-		`ipld.ReprKindSet_JustBytes`,
+		`ipld.KindSet_JustBytes`,
 		`nil`,
 		false,
 	), w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodAsLink(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodAsLink(w io.Writer) {
 	doTemplate(kindedUnionNodeMethodTemplateMunge(
 		`AsLink`,
 		`AsLink() (ipld.Link, error)`,
 		`{{- if .Type.RepresentationStrategy.GetMember (Kind "link") }}`,
 		`{{- if eq $member.RepresentationBehavior.String "link" }}`,
 		`.AsLink()`,
-		`ipld.ReprKindSet_JustLink`,
+		`ipld.KindSet_JustLink`,
 		`nil`,
 		false,
 	), w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodeMethodPrototype(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodeMethodPrototype(w io.Writer) {
 	emitNodeMethodPrototype_typical(w, g.AdjCfg, g)
 }
 
-func (g unionReprKindedReprGenerator) EmitNodePrototypeType(w io.Writer) {
+func (g unionKindedReprGenerator) EmitNodePrototypeType(w io.Writer) {
 	emitNodePrototypeType_typical(w, g.AdjCfg, g)
 }
 
 // --- NodeBuilder and NodeAssembler --->
 
-func (g unionReprKindedReprGenerator) GetNodeBuilderGenerator() NodeBuilderGenerator {
-	return unionReprKindedReprBuilderGenerator{
+func (g unionKindedReprGenerator) GetNodeBuilderGenerator() NodeBuilderGenerator {
+	return unionKindedReprBuilderGenerator{
 		g.AdjCfg,
 		g.PkgName,
 		g.Type,
 	}
 }
 
-type unionReprKindedReprBuilderGenerator struct {
+type unionKindedReprBuilderGenerator struct {
 	AdjCfg  *AdjunctCfg
 	PkgName string
 	Type    *schema.TypeUnion
 }
 
-func (unionReprKindedReprBuilderGenerator) IsRepr() bool { return true } // hint used in some generalized templates.
+func (unionKindedReprBuilderGenerator) IsRepr() bool { return true } // hint used in some generalized templates.
 
-func (g unionReprKindedReprBuilderGenerator) EmitNodeBuilderType(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeBuilderType(w io.Writer) {
 	emitEmitNodeBuilderType_typical(w, g.AdjCfg, g)
 }
-func (g unionReprKindedReprBuilderGenerator) EmitNodeBuilderMethods(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeBuilderMethods(w io.Writer) {
 	emitNodeBuilderMethods_typical(w, g.AdjCfg, g)
 }
-func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerType(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeAssemblerType(w io.Writer) {
 	// Much of this is familiar: the 'w', the 'm' are all as usual.
 	// Some things may look a little odd here compared to all other assemblers:
 	//  we're kinda halfway between what's conventionally seen for a scalar and what's conventionally seen for a recursive.
@@ -460,7 +460,7 @@ func kindedUnionNodeAssemblerMethodTemplateMunge(
 	`
 }
 
-func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodBeginMap(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeAssemblerMethodBeginMap(w io.Writer) {
 	doTemplate(kindedUnionNodeAssemblerMethodTemplateMunge(
 		`BeginMap`,
 		`BeginMap(sizeHint int64) (ipld.MapAssembler, error)`,
@@ -469,7 +469,7 @@ func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodBeginMap(w i
 		true,
 	), w, g.AdjCfg, g)
 }
-func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodBeginList(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeAssemblerMethodBeginList(w io.Writer) {
 	doTemplate(kindedUnionNodeAssemblerMethodTemplateMunge(
 		`BeginList`,
 		`BeginList(sizeHint int64) (ipld.ListAssembler, error)`,
@@ -478,7 +478,7 @@ func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodBeginList(w
 		true,
 	), w, g.AdjCfg, g)
 }
-func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignNull(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignNull(w io.Writer) {
 	// TODO: I think this may need some special handling to account for if our union is itself used in a nullable circumstance; that should overrule this behavior.
 	doTemplate(kindedUnionNodeAssemblerMethodTemplateMunge(
 		`AssignNull`,
@@ -488,7 +488,7 @@ func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignNull(w
 		false,
 	), w, g.AdjCfg, g)
 }
-func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignBool(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignBool(w io.Writer) {
 	doTemplate(kindedUnionNodeAssemblerMethodTemplateMunge(
 		`AssignBool`,
 		`AssignBool(v bool) error `,
@@ -497,7 +497,7 @@ func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignBool(w
 		false,
 	), w, g.AdjCfg, g)
 }
-func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignInt(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignInt(w io.Writer) {
 	doTemplate(kindedUnionNodeAssemblerMethodTemplateMunge(
 		`AssignInt`,
 		`AssignInt(v int64) error `,
@@ -506,7 +506,7 @@ func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignInt(w
 		false,
 	), w, g.AdjCfg, g)
 }
-func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignFloat(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignFloat(w io.Writer) {
 	doTemplate(kindedUnionNodeAssemblerMethodTemplateMunge(
 		`AssignFloat`,
 		`AssignFloat(v float64) error `,
@@ -515,7 +515,7 @@ func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignFloat(
 		false,
 	), w, g.AdjCfg, g)
 }
-func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignString(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignString(w io.Writer) {
 	doTemplate(kindedUnionNodeAssemblerMethodTemplateMunge(
 		`AssignString`,
 		`AssignString(v string) error `,
@@ -524,7 +524,7 @@ func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignString
 		false,
 	), w, g.AdjCfg, g)
 }
-func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignBytes(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignBytes(w io.Writer) {
 	doTemplate(kindedUnionNodeAssemblerMethodTemplateMunge(
 		`AssignBytes`,
 		`AssignBytes(v []byte) error `,
@@ -533,7 +533,7 @@ func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignBytes(
 		false,
 	), w, g.AdjCfg, g)
 }
-func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignLink(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignLink(w io.Writer) {
 	doTemplate(kindedUnionNodeAssemblerMethodTemplateMunge(
 		`AssignLink`,
 		`AssignLink(v ipld.Link) error `,
@@ -542,7 +542,7 @@ func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodAssignLink(w
 		false,
 	), w, g.AdjCfg, g)
 }
-func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(w io.Writer) {
 	// This is a very mundane ConvertFrom: it just calls out to the other methods on this type.
 	//  However, even that is a little more exciting than usual: because we can't *necessarily* reject any kind of arg,
 	//   we have the whole barrage of switch cases here.  We then leave any particular rejections to those methods.
@@ -573,23 +573,23 @@ func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(
 				*na.m = schema.Maybe_Value
 				return nil
 			}
-			switch v.ReprKind() {
-			case ipld.ReprKind_Bool:
+			switch v.Kind() {
+			case ipld.Kind_Bool:
 				v2, _ := v.AsBool()
 				return na.AssignBool(v2)
-			case ipld.ReprKind_Int:
+			case ipld.Kind_Int:
 				v2, _ := v.AsInt()
 				return na.AssignInt(v2)
-			case ipld.ReprKind_Float:
+			case ipld.Kind_Float:
 				v2, _ := v.AsFloat()
 				return na.AssignFloat(v2)
-			case ipld.ReprKind_String:
+			case ipld.Kind_String:
 				v2, _ := v.AsString()
 				return na.AssignString(v2)
-			case ipld.ReprKind_Bytes:
+			case ipld.Kind_Bytes:
 				v2, _ := v.AsBytes()
 				return na.AssignBytes(v2)
-			case ipld.ReprKind_Map:
+			case ipld.Kind_Map:
 				na, err := na.BeginMap(v.Length())
 				if err != nil {
 					return err
@@ -608,7 +608,7 @@ func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(
 					}
 				}
 				return na.Finish()
-			case ipld.ReprKind_List:
+			case ipld.Kind_List:
 				na, err := na.BeginList(v.Length())
 				if err != nil {
 					return err
@@ -624,7 +624,7 @@ func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(
 					}
 				}
 				return na.Finish()
-			case ipld.ReprKind_Link:
+			case ipld.Kind_Link:
 				v2, _ := v.AsLink()
 				return na.AssignLink(v2)
 			default:
@@ -633,13 +633,13 @@ func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodConvertFrom(
 		}
 	`, w, g.AdjCfg, g)
 }
-func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerMethodPrototype(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeAssemblerMethodPrototype(w io.Writer) {
 	doTemplate(`
 		func (na *_{{ .Type | TypeSymbol }}__ReprAssembler) Prototype() ipld.NodePrototype {
 			return _{{ .Type | TypeSymbol }}__ReprPrototype{}
 		}
 	`, w, g.AdjCfg, g)
 }
-func (g unionReprKindedReprBuilderGenerator) EmitNodeAssemblerOtherBits(w io.Writer) {
+func (g unionKindedReprBuilderGenerator) EmitNodeAssemblerOtherBits(w io.Writer) {
 	// somewhat shockingly: nothing.
 }
diff --git a/schema/gen/go/generate.go b/schema/gen/go/generate.go
index 91668196..0e72c8ee 100644
--- a/schema/gen/go/generate.go
+++ b/schema/gen/go/generate.go
@@ -73,7 +73,7 @@ func Generate(pth string, pkgName string, ts schema.TypeSystem, adjCfg *AdjunctC
 				case schema.UnionRepresentation_Keyed:
 					fn(NewUnionReprKeyedGenerator(pkgName, t2, adjCfg), f)
 				case schema.UnionRepresentation_Kinded:
-					fn(NewUnionReprKindedGenerator(pkgName, t2, adjCfg), f)
+					fn(NewUnionKindedGenerator(pkgName, t2, adjCfg), f)
 				default:
 					panic("unrecognized union representation strategy")
 				}
@@ -182,7 +182,7 @@ func GenerateSplayed(pth string, pkgName string, ts schema.TypeSystem, adjCfg *A
 				case schema.UnionRepresentation_Keyed:
 					EmitEntireType(NewUnionReprKeyedGenerator(pkgName, t2, adjCfg), f)
 				case schema.UnionRepresentation_Kinded:
-					EmitEntireType(NewUnionReprKindedGenerator(pkgName, t2, adjCfg), f)
+					EmitEntireType(NewUnionKindedGenerator(pkgName, t2, adjCfg), f)
 				default:
 					panic("unrecognized union representation strategy")
 				}
diff --git a/schema/gen/go/generators.go b/schema/gen/go/generators.go
index 8e7dd09b..08157ec4 100644
--- a/schema/gen/go/generators.go
+++ b/schema/gen/go/generators.go
@@ -38,7 +38,7 @@ type TypeGenerator interface {
 type NodeGenerator interface {
 	EmitNodeType(io.Writer)           // usually already covered by EmitNativeType for the primary node, but has a nonzero body for the repr node
 	EmitNodeTypeAssertions(io.Writer) // optional to include this content
-	EmitNodeMethodReprKind(io.Writer)
+	EmitNodeMethodKind(io.Writer)
 	EmitNodeMethodLookupByString(io.Writer)
 	EmitNodeMethodLookupByNode(io.Writer)
 	EmitNodeMethodLookupByIndex(io.Writer)
@@ -114,7 +114,7 @@ func EmitEntireType(tg TypeGenerator, w io.Writer) {
 func EmitNode(ng NodeGenerator, w io.Writer) {
 	ng.EmitNodeType(w)
 	ng.EmitNodeTypeAssertions(w)
-	ng.EmitNodeMethodReprKind(w)
+	ng.EmitNodeMethodKind(w)
 	ng.EmitNodeMethodLookupByString(w)
 	ng.EmitNodeMethodLookupByNode(w)
 	ng.EmitNodeMethodLookupByIndex(w)
diff --git a/schema/gen/go/genpartsCommon.go b/schema/gen/go/genpartsCommon.go
index d9daac21..3c3bc7e4 100644
--- a/schema/gen/go/genpartsCommon.go
+++ b/schema/gen/go/genpartsCommon.go
@@ -61,10 +61,10 @@ func emitNativeType_scalar(w io.Writer, adjCfg *AdjunctCfg, data interface{}) {
 	//   which is desirable because the compiler then ensures our validate methods can't be evaded.
 	doTemplate(`
 		{{- if Comments -}}
-		// {{ .Type | TypeSymbol }} matches the IPLD Schema type "{{ .Type.Name }}".  It has {{ .ReprKind }} kind.
+		// {{ .Type | TypeSymbol }} matches the IPLD Schema type "{{ .Type.Name }}".  It has {{ .Kind }} kind.
 		{{- end}}
 		type {{ .Type | TypeSymbol }} = *_{{ .Type | TypeSymbol }}
-		type _{{ .Type | TypeSymbol }} struct{ x {{ .ReprKind | KindPrim }} }
+		type _{{ .Type | TypeSymbol }} struct{ x {{ .Kind | KindPrim }} }
 	`, w, adjCfg, data)
 }
 
@@ -73,7 +73,7 @@ func emitNativeAccessors_scalar(w io.Writer, adjCfg *AdjunctCfg, data interface{
 	//  this method unboxes without needing to return an error that's statically impossible,
 	//   which makes it easier to use in chaining.
 	doTemplate(`
-		func (n {{ .Type | TypeSymbol }}) {{ .ReprKind.String | title }}() {{ .ReprKind | KindPrim }} {
+		func (n {{ .Type | TypeSymbol }}) {{ .Kind.String | title }}() {{ .Kind | KindPrim }} {
 			return n.x
 		}
 	`, w, adjCfg, data)
@@ -86,7 +86,7 @@ func emitNativeBuilder_scalar(w io.Writer, adjCfg *AdjunctCfg, data interface{})
 	//  it needs no new memory, so it would be inappropriate to attach to the builder or assembler.
 	// FUTURE: should engage validation flow.
 	doTemplate(`
-		func (_{{ .Type | TypeSymbol }}__Prototype) From{{ .ReprKind.String | title }}(v {{ .ReprKind | KindPrim }}) ({{ .Type | TypeSymbol }}, error) {
+		func (_{{ .Type | TypeSymbol }}__Prototype) From{{ .Kind.String | title }}(v {{ .Kind | KindPrim }}) ({{ .Type | TypeSymbol }}, error) {
 			n := _{{ .Type | TypeSymbol }}{v}
 			return &n, nil
 		}
@@ -102,7 +102,7 @@ func emitNodeTypeAssertions_typical(w io.Writer, adjCfg *AdjunctCfg, data interf
 
 func emitNodeMethodAsKind_scalar(w io.Writer, adjCfg *AdjunctCfg, data interface{}) {
 	doTemplate(`
-		func (n {{ .Type | TypeSymbol }}) As{{ .ReprKind.String | title }}() ({{ .ReprKind | KindPrim }}, error) {
+		func (n {{ .Type | TypeSymbol }}) As{{ .Kind.String | title }}() ({{ .Kind | KindPrim }}, error) {
 			return n.x, nil
 		}
 	`, w, adjCfg, data)
@@ -197,7 +197,7 @@ func emitNodeAssemblerMethodAssignNull_scalar(w io.Writer, adjCfg *AdjunctCfg, d
 				*na.m = schema.Maybe_Null
 				return nil
 			case schema.Maybe_Absent:
-				return mixins.{{ .ReprKind.String | title }}Assembler{"{{ .PkgName }}.{{ .TypeName }}{{ if .IsRepr }}.Repr{{end}}"}.AssignNull()
+				return mixins.{{ .Kind.String | title }}Assembler{"{{ .PkgName }}.{{ .TypeName }}{{ if .IsRepr }}.Repr{{end}}"}.AssignNull()
 			case schema.Maybe_Value, schema.Maybe_Null:
 				panic("invalid state: cannot assign into assembler that's already finished")
 			}
@@ -215,7 +215,7 @@ func emitNodeAssemblerMethodAssignNull_recursive(w io.Writer, adjCfg *AdjunctCfg
 				*na.m = schema.Maybe_Null
 				return nil
 			case schema.Maybe_Absent:
-				return mixins.{{ .ReprKind.String | title }}Assembler{"{{ .PkgName }}.{{ .TypeName }}{{ if .IsRepr }}.Repr{{end}}"}.AssignNull()
+				return mixins.{{ .Kind.String | title }}Assembler{"{{ .PkgName }}.{{ .TypeName }}{{ if .IsRepr }}.Repr{{end}}"}.AssignNull()
 			case schema.Maybe_Value, schema.Maybe_Null:
 				panic("invalid state: cannot assign into assembler that's already finished")
 			case midvalue:
@@ -233,7 +233,7 @@ func emitNodeAssemblerMethodAssignKind_scalar(w io.Writer, adjCfg *AdjunctCfg, d
 	//  This allocation only happens if the 'w' ptr is nil, which means we're being used on a Maybe;
 	//  otherwise, the 'w' ptr should already be set, and we fill that memory location without allocating, as usual.
 	doTemplate(`
-		func (na *_{{ .Type | TypeSymbol }}__Assembler) Assign{{ .ReprKind.String | title }}(v {{ .ReprKind | KindPrim }}) error {
+		func (na *_{{ .Type | TypeSymbol }}__Assembler) Assign{{ .Kind.String | title }}(v {{ .Kind | KindPrim }}) error {
 			switch *na.m {
 			case schema.Maybe_Value, schema.Maybe_Null:
 				panic("invalid state: cannot assign into assembler that's already finished")
@@ -278,10 +278,10 @@ func emitNodeAssemblerMethodConvertFrom_scalar(w io.Writer, adjCfg *AdjunctCfg,
 				*na.m = schema.Maybe_Value
 				return nil
 			}
-			if v2, err := v.As{{ .ReprKind.String | title }}(); err != nil {
+			if v2, err := v.As{{ .Kind.String | title }}(); err != nil {
 				return err
 			} else {
-				return na.Assign{{ .ReprKind.String | title }}(v2)
+				return na.Assign{{ .Kind.String | title }}(v2)
 			}
 		}
 	`, w, adjCfg, data)
diff --git a/schema/gen/go/genpartsList.go b/schema/gen/go/genpartsList.go
index 6125f622..81fecdcf 100644
--- a/schema/gen/go/genpartsList.go
+++ b/schema/gen/go/genpartsList.go
@@ -82,8 +82,8 @@ func emitNodeAssemblerMethodConvertFrom_listoid(w io.Writer, adjCfg *AdjunctCfg,
 				*na.m = schema.Maybe_Value
 				return nil
 			}
-			if v.ReprKind() != ipld.ReprKind_List {
-				return ipld.ErrWrongKind{TypeName: "{{ .PkgName }}.{{ .Type.Name }}{{ if .IsRepr }}.Repr{{end}}", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustList, ActualKind: v.ReprKind()}
+			if v.Kind() != ipld.Kind_List {
+				return ipld.ErrWrongKind{TypeName: "{{ .PkgName }}.{{ .Type.Name }}{{ if .IsRepr }}.Repr{{end}}", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustList, ActualKind: v.Kind()}
 			}
 			itr := v.ListIterator()
 			for !itr.Done() {
diff --git a/schema/gen/go/genpartsMap.go b/schema/gen/go/genpartsMap.go
index 0630ea7e..2ae6df97 100644
--- a/schema/gen/go/genpartsMap.go
+++ b/schema/gen/go/genpartsMap.go
@@ -72,8 +72,8 @@ func emitNodeAssemblerMethodConvertFrom_mapoid(w io.Writer, adjCfg *AdjunctCfg,
 				*na.m = schema.Maybe_Value
 				return nil
 			}
-			if v.ReprKind() != ipld.ReprKind_Map {
-				return ipld.ErrWrongKind{TypeName: "{{ .PkgName }}.{{ .Type.Name }}{{ if .IsRepr }}.Repr{{end}}", MethodName: "ConvertFrom", AppropriateKind: ipld.ReprKindSet_JustMap, ActualKind: v.ReprKind()}
+			if v.Kind() != ipld.Kind_Map {
+				return ipld.ErrWrongKind{TypeName: "{{ .PkgName }}.{{ .Type.Name }}{{ if .IsRepr }}.Repr{{end}}", MethodName: "ConvertFrom", AppropriateKind: ipld.KindSet_JustMap, ActualKind: v.Kind()}
 			}
 			itr := v.MapIterator()
 			for !itr.Done() {
@@ -217,7 +217,7 @@ func emitNodeAssemblerHelper_mapoid_mapAssemblerMethods(w io.Writer, adjCfg *Adj
 			}
 
 			var k2 _{{ .Type.KeyType | TypeSymbol }}
-			{{- if or (not (eq .Type.KeyType.Kind.String "String")) .IsRepr }}
+			{{- if or (not (eq .Type.KeyType.TypeKind.String "String")) .IsRepr }}
 			if err := (_{{ .Type.KeyType | TypeSymbol }}__ReprPrototype{}).fromString(&k2, k); err != nil {
 				return nil, err // TODO wrap in some kind of ErrInvalidKey
 			}
diff --git a/schema/gen/go/mixins/boolGenMixin.go b/schema/gen/go/mixins/boolGenMixin.go
index e1a6b9a8..4d8b376e 100644
--- a/schema/gen/go/mixins/boolGenMixin.go
+++ b/schema/gen/go/mixins/boolGenMixin.go
@@ -12,57 +12,57 @@ type BoolTraits struct {
 	TypeSymbol string // see doc in kindTraitsGenerator
 }
 
-func (BoolTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Bool
+func (BoolTraits) Kind() ipld.Kind {
+	return ipld.Kind_Bool
 }
-func (g BoolTraits) EmitNodeMethodReprKind(w io.Writer) {
+func (g BoolTraits) EmitNodeMethodKind(w io.Writer) {
 	doTemplate(`
-		func ({{ .TypeSymbol }}) ReprKind() ipld.ReprKind {
-			return ipld.ReprKind_Bool
+		func ({{ .TypeSymbol }}) Kind() ipld.Kind {
+			return ipld.Kind_Bool
 		}
 	`, w, g)
 }
 func (g BoolTraits) EmitNodeMethodLookupByString(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bool}.emitNodeMethodLookupByString(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bool}.emitNodeMethodLookupByString(w)
 }
 func (g BoolTraits) EmitNodeMethodLookupByNode(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bool}.emitNodeMethodLookupByNode(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bool}.emitNodeMethodLookupByNode(w)
 }
 func (g BoolTraits) EmitNodeMethodLookupByIndex(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bool}.emitNodeMethodLookupByIndex(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bool}.emitNodeMethodLookupByIndex(w)
 }
 func (g BoolTraits) EmitNodeMethodLookupBySegment(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bool}.emitNodeMethodLookupBySegment(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bool}.emitNodeMethodLookupBySegment(w)
 }
 func (g BoolTraits) EmitNodeMethodMapIterator(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bool}.emitNodeMethodMapIterator(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bool}.emitNodeMethodMapIterator(w)
 }
 func (g BoolTraits) EmitNodeMethodListIterator(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bool}.emitNodeMethodListIterator(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bool}.emitNodeMethodListIterator(w)
 }
 func (g BoolTraits) EmitNodeMethodLength(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bool}.emitNodeMethodLength(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bool}.emitNodeMethodLength(w)
 }
 func (g BoolTraits) EmitNodeMethodIsAbsent(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bool}.emitNodeMethodIsAbsent(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bool}.emitNodeMethodIsAbsent(w)
 }
 func (g BoolTraits) EmitNodeMethodIsNull(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bool}.emitNodeMethodIsNull(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bool}.emitNodeMethodIsNull(w)
 }
 func (g BoolTraits) EmitNodeMethodAsInt(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bool}.emitNodeMethodAsInt(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bool}.emitNodeMethodAsInt(w)
 }
 func (g BoolTraits) EmitNodeMethodAsFloat(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bool}.emitNodeMethodAsFloat(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bool}.emitNodeMethodAsFloat(w)
 }
 func (g BoolTraits) EmitNodeMethodAsString(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bool}.emitNodeMethodAsString(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bool}.emitNodeMethodAsString(w)
 }
 func (g BoolTraits) EmitNodeMethodAsBytes(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bool}.emitNodeMethodAsBytes(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bool}.emitNodeMethodAsBytes(w)
 }
 func (g BoolTraits) EmitNodeMethodAsLink(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bool}.emitNodeMethodAsLink(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bool}.emitNodeMethodAsLink(w)
 }
 
 type BoolAssemblerTraits struct {
@@ -71,33 +71,33 @@ type BoolAssemblerTraits struct {
 	AppliedPrefix string // see doc in kindAssemblerTraitsGenerator
 }
 
-func (BoolAssemblerTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Bool
+func (BoolAssemblerTraits) Kind() ipld.Kind {
+	return ipld.Kind_Bool
 }
 func (g BoolAssemblerTraits) EmitNodeAssemblerMethodBeginMap(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bool}.emitNodeAssemblerMethodBeginMap(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bool}.emitNodeAssemblerMethodBeginMap(w)
 }
 func (g BoolAssemblerTraits) EmitNodeAssemblerMethodBeginList(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bool}.emitNodeAssemblerMethodBeginList(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bool}.emitNodeAssemblerMethodBeginList(w)
 }
 func (g BoolAssemblerTraits) EmitNodeAssemblerMethodAssignNull(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bool}.emitNodeAssemblerMethodAssignNull(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bool}.emitNodeAssemblerMethodAssignNull(w)
 }
 func (g BoolAssemblerTraits) EmitNodeAssemblerMethodAssignInt(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bool}.emitNodeAssemblerMethodAssignInt(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bool}.emitNodeAssemblerMethodAssignInt(w)
 }
 func (g BoolAssemblerTraits) EmitNodeAssemblerMethodAssignFloat(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bool}.emitNodeAssemblerMethodAssignFloat(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bool}.emitNodeAssemblerMethodAssignFloat(w)
 }
 func (g BoolAssemblerTraits) EmitNodeAssemblerMethodAssignString(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bool}.emitNodeAssemblerMethodAssignString(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bool}.emitNodeAssemblerMethodAssignString(w)
 }
 func (g BoolAssemblerTraits) EmitNodeAssemblerMethodAssignBytes(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bool}.emitNodeAssemblerMethodAssignBytes(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bool}.emitNodeAssemblerMethodAssignBytes(w)
 }
 func (g BoolAssemblerTraits) EmitNodeAssemblerMethodAssignLink(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bool}.emitNodeAssemblerMethodAssignLink(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bool}.emitNodeAssemblerMethodAssignLink(w)
 }
 func (g BoolAssemblerTraits) EmitNodeAssemblerMethodPrototype(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bool}.emitNodeAssemblerMethodPrototype(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bool}.emitNodeAssemblerMethodPrototype(w)
 }
diff --git a/schema/gen/go/mixins/bytesGenMixin.go b/schema/gen/go/mixins/bytesGenMixin.go
index 63e0dc3b..6d9136a6 100644
--- a/schema/gen/go/mixins/bytesGenMixin.go
+++ b/schema/gen/go/mixins/bytesGenMixin.go
@@ -12,57 +12,57 @@ type BytesTraits struct {
 	TypeSymbol string // see doc in kindTraitsGenerator
 }
 
-func (BytesTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Bytes
+func (BytesTraits) Kind() ipld.Kind {
+	return ipld.Kind_Bytes
 }
-func (g BytesTraits) EmitNodeMethodReprKind(w io.Writer) {
+func (g BytesTraits) EmitNodeMethodKind(w io.Writer) {
 	doTemplate(`
-		func ({{ .TypeSymbol }}) ReprKind() ipld.ReprKind {
-			return ipld.ReprKind_Bytes
+		func ({{ .TypeSymbol }}) Kind() ipld.Kind {
+			return ipld.Kind_Bytes
 		}
 	`, w, g)
 }
 func (g BytesTraits) EmitNodeMethodLookupByString(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bytes}.emitNodeMethodLookupByString(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bytes}.emitNodeMethodLookupByString(w)
 }
 func (g BytesTraits) EmitNodeMethodLookupByNode(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bytes}.emitNodeMethodLookupByNode(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bytes}.emitNodeMethodLookupByNode(w)
 }
 func (g BytesTraits) EmitNodeMethodLookupByIndex(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bytes}.emitNodeMethodLookupByIndex(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bytes}.emitNodeMethodLookupByIndex(w)
 }
 func (g BytesTraits) EmitNodeMethodLookupBySegment(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bytes}.emitNodeMethodLookupBySegment(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bytes}.emitNodeMethodLookupBySegment(w)
 }
 func (g BytesTraits) EmitNodeMethodMapIterator(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bytes}.emitNodeMethodMapIterator(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bytes}.emitNodeMethodMapIterator(w)
 }
 func (g BytesTraits) EmitNodeMethodListIterator(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bytes}.emitNodeMethodListIterator(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bytes}.emitNodeMethodListIterator(w)
 }
 func (g BytesTraits) EmitNodeMethodLength(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bytes}.emitNodeMethodLength(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bytes}.emitNodeMethodLength(w)
 }
 func (g BytesTraits) EmitNodeMethodIsAbsent(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bytes}.emitNodeMethodIsAbsent(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bytes}.emitNodeMethodIsAbsent(w)
 }
 func (g BytesTraits) EmitNodeMethodIsNull(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bytes}.emitNodeMethodIsNull(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bytes}.emitNodeMethodIsNull(w)
 }
 func (g BytesTraits) EmitNodeMethodAsBool(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bytes}.emitNodeMethodAsBool(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bytes}.emitNodeMethodAsBool(w)
 }
 func (g BytesTraits) EmitNodeMethodAsInt(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bytes}.emitNodeMethodAsInt(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bytes}.emitNodeMethodAsInt(w)
 }
 func (g BytesTraits) EmitNodeMethodAsFloat(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bytes}.emitNodeMethodAsFloat(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bytes}.emitNodeMethodAsFloat(w)
 }
 func (g BytesTraits) EmitNodeMethodAsString(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bytes}.emitNodeMethodAsString(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bytes}.emitNodeMethodAsString(w)
 }
 func (g BytesTraits) EmitNodeMethodAsLink(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Bytes}.emitNodeMethodAsLink(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Bytes}.emitNodeMethodAsLink(w)
 }
 
 type BytesAssemblerTraits struct {
@@ -71,33 +71,33 @@ type BytesAssemblerTraits struct {
 	AppliedPrefix string // see doc in kindAssemblerTraitsGenerator
 }
 
-func (BytesAssemblerTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Bytes
+func (BytesAssemblerTraits) Kind() ipld.Kind {
+	return ipld.Kind_Bytes
 }
 func (g BytesAssemblerTraits) EmitNodeAssemblerMethodBeginMap(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bytes}.emitNodeAssemblerMethodBeginMap(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bytes}.emitNodeAssemblerMethodBeginMap(w)
 }
 func (g BytesAssemblerTraits) EmitNodeAssemblerMethodBeginList(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bytes}.emitNodeAssemblerMethodBeginList(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bytes}.emitNodeAssemblerMethodBeginList(w)
 }
 func (g BytesAssemblerTraits) EmitNodeAssemblerMethodAssignNull(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bytes}.emitNodeAssemblerMethodAssignNull(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bytes}.emitNodeAssemblerMethodAssignNull(w)
 }
 func (g BytesAssemblerTraits) EmitNodeAssemblerMethodAssignBool(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bytes}.emitNodeAssemblerMethodAssignBool(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bytes}.emitNodeAssemblerMethodAssignBool(w)
 }
 func (g BytesAssemblerTraits) EmitNodeAssemblerMethodAssignInt(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bytes}.emitNodeAssemblerMethodAssignInt(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bytes}.emitNodeAssemblerMethodAssignInt(w)
 }
 func (g BytesAssemblerTraits) EmitNodeAssemblerMethodAssignFloat(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bytes}.emitNodeAssemblerMethodAssignFloat(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bytes}.emitNodeAssemblerMethodAssignFloat(w)
 }
 func (g BytesAssemblerTraits) EmitNodeAssemblerMethodAssignString(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bytes}.emitNodeAssemblerMethodAssignString(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bytes}.emitNodeAssemblerMethodAssignString(w)
 }
 func (g BytesAssemblerTraits) EmitNodeAssemblerMethodAssignLink(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bytes}.emitNodeAssemblerMethodAssignLink(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bytes}.emitNodeAssemblerMethodAssignLink(w)
 }
 func (g BytesAssemblerTraits) EmitNodeAssemblerMethodPrototype(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Bytes}.emitNodeAssemblerMethodPrototype(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Bytes}.emitNodeAssemblerMethodPrototype(w)
 }
diff --git a/schema/gen/go/mixins/floatGenMixin.go b/schema/gen/go/mixins/floatGenMixin.go
index d09b1e5a..0ff69947 100644
--- a/schema/gen/go/mixins/floatGenMixin.go
+++ b/schema/gen/go/mixins/floatGenMixin.go
@@ -12,57 +12,57 @@ type FloatTraits struct {
 	TypeSymbol string // see doc in kindTraitsGenerator
 }
 
-func (FloatTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Float
+func (FloatTraits) Kind() ipld.Kind {
+	return ipld.Kind_Float
 }
-func (g FloatTraits) EmitNodeMethodReprKind(w io.Writer) {
+func (g FloatTraits) EmitNodeMethodKind(w io.Writer) {
 	doTemplate(`
-		func ({{ .TypeSymbol }}) ReprKind() ipld.ReprKind {
-			return ipld.ReprKind_Float
+		func ({{ .TypeSymbol }}) Kind() ipld.Kind {
+			return ipld.Kind_Float
 		}
 	`, w, g)
 }
 func (g FloatTraits) EmitNodeMethodLookupByString(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Float}.emitNodeMethodLookupByString(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Float}.emitNodeMethodLookupByString(w)
 }
 func (g FloatTraits) EmitNodeMethodLookupByNode(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Float}.emitNodeMethodLookupByNode(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Float}.emitNodeMethodLookupByNode(w)
 }
 func (g FloatTraits) EmitNodeMethodLookupByIndex(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Float}.emitNodeMethodLookupByIndex(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Float}.emitNodeMethodLookupByIndex(w)
 }
 func (g FloatTraits) EmitNodeMethodLookupBySegment(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Float}.emitNodeMethodLookupBySegment(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Float}.emitNodeMethodLookupBySegment(w)
 }
 func (g FloatTraits) EmitNodeMethodMapIterator(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Float}.emitNodeMethodMapIterator(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Float}.emitNodeMethodMapIterator(w)
 }
 func (g FloatTraits) EmitNodeMethodListIterator(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Float}.emitNodeMethodListIterator(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Float}.emitNodeMethodListIterator(w)
 }
 func (g FloatTraits) EmitNodeMethodLength(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Float}.emitNodeMethodLength(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Float}.emitNodeMethodLength(w)
 }
 func (g FloatTraits) EmitNodeMethodIsAbsent(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Float}.emitNodeMethodIsAbsent(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Float}.emitNodeMethodIsAbsent(w)
 }
 func (g FloatTraits) EmitNodeMethodIsNull(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Float}.emitNodeMethodIsNull(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Float}.emitNodeMethodIsNull(w)
 }
 func (g FloatTraits) EmitNodeMethodAsBool(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Float}.emitNodeMethodAsBool(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Float}.emitNodeMethodAsBool(w)
 }
 func (g FloatTraits) EmitNodeMethodAsInt(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Float}.emitNodeMethodAsInt(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Float}.emitNodeMethodAsInt(w)
 }
 func (g FloatTraits) EmitNodeMethodAsString(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Float}.emitNodeMethodAsString(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Float}.emitNodeMethodAsString(w)
 }
 func (g FloatTraits) EmitNodeMethodAsBytes(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Float}.emitNodeMethodAsBytes(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Float}.emitNodeMethodAsBytes(w)
 }
 func (g FloatTraits) EmitNodeMethodAsLink(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Float}.emitNodeMethodAsLink(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Float}.emitNodeMethodAsLink(w)
 }
 
 type FloatAssemblerTraits struct {
@@ -71,33 +71,33 @@ type FloatAssemblerTraits struct {
 	AppliedPrefix string // see doc in kindAssemblerTraitsGenerator
 }
 
-func (FloatAssemblerTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Float
+func (FloatAssemblerTraits) Kind() ipld.Kind {
+	return ipld.Kind_Float
 }
 func (g FloatAssemblerTraits) EmitNodeAssemblerMethodBeginMap(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Float}.emitNodeAssemblerMethodBeginMap(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Float}.emitNodeAssemblerMethodBeginMap(w)
 }
 func (g FloatAssemblerTraits) EmitNodeAssemblerMethodBeginList(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Float}.emitNodeAssemblerMethodBeginList(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Float}.emitNodeAssemblerMethodBeginList(w)
 }
 func (g FloatAssemblerTraits) EmitNodeAssemblerMethodAssignNull(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Float}.emitNodeAssemblerMethodAssignNull(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Float}.emitNodeAssemblerMethodAssignNull(w)
 }
 func (g FloatAssemblerTraits) EmitNodeAssemblerMethodAssignBool(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Float}.emitNodeAssemblerMethodAssignBool(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Float}.emitNodeAssemblerMethodAssignBool(w)
 }
 func (g FloatAssemblerTraits) EmitNodeAssemblerMethodAssignInt(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Float}.emitNodeAssemblerMethodAssignInt(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Float}.emitNodeAssemblerMethodAssignInt(w)
 }
 func (g FloatAssemblerTraits) EmitNodeAssemblerMethodAssignString(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Float}.emitNodeAssemblerMethodAssignString(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Float}.emitNodeAssemblerMethodAssignString(w)
 }
 func (g FloatAssemblerTraits) EmitNodeAssemblerMethodAssignBytes(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Float}.emitNodeAssemblerMethodAssignBytes(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Float}.emitNodeAssemblerMethodAssignBytes(w)
 }
 func (g FloatAssemblerTraits) EmitNodeAssemblerMethodAssignLink(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Float}.emitNodeAssemblerMethodAssignLink(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Float}.emitNodeAssemblerMethodAssignLink(w)
 }
 func (g FloatAssemblerTraits) EmitNodeAssemblerMethodPrototype(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Float}.emitNodeAssemblerMethodPrototype(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Float}.emitNodeAssemblerMethodPrototype(w)
 }
diff --git a/schema/gen/go/mixins/intGenMixin.go b/schema/gen/go/mixins/intGenMixin.go
index a01abcbc..b7a20f64 100644
--- a/schema/gen/go/mixins/intGenMixin.go
+++ b/schema/gen/go/mixins/intGenMixin.go
@@ -12,57 +12,57 @@ type IntTraits struct {
 	TypeSymbol string // see doc in kindTraitsGenerator
 }
 
-func (IntTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Int
+func (IntTraits) Kind() ipld.Kind {
+	return ipld.Kind_Int
 }
-func (g IntTraits) EmitNodeMethodReprKind(w io.Writer) {
+func (g IntTraits) EmitNodeMethodKind(w io.Writer) {
 	doTemplate(`
-		func ({{ .TypeSymbol }}) ReprKind() ipld.ReprKind {
-			return ipld.ReprKind_Int
+		func ({{ .TypeSymbol }}) Kind() ipld.Kind {
+			return ipld.Kind_Int
 		}
 	`, w, g)
 }
 func (g IntTraits) EmitNodeMethodLookupByString(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Int}.emitNodeMethodLookupByString(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Int}.emitNodeMethodLookupByString(w)
 }
 func (g IntTraits) EmitNodeMethodLookupByNode(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Int}.emitNodeMethodLookupByNode(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Int}.emitNodeMethodLookupByNode(w)
 }
 func (g IntTraits) EmitNodeMethodLookupByIndex(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Int}.emitNodeMethodLookupByIndex(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Int}.emitNodeMethodLookupByIndex(w)
 }
 func (g IntTraits) EmitNodeMethodLookupBySegment(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Int}.emitNodeMethodLookupBySegment(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Int}.emitNodeMethodLookupBySegment(w)
 }
 func (g IntTraits) EmitNodeMethodMapIterator(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Int}.emitNodeMethodMapIterator(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Int}.emitNodeMethodMapIterator(w)
 }
 func (g IntTraits) EmitNodeMethodListIterator(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Int}.emitNodeMethodListIterator(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Int}.emitNodeMethodListIterator(w)
 }
 func (g IntTraits) EmitNodeMethodLength(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Int}.emitNodeMethodLength(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Int}.emitNodeMethodLength(w)
 }
 func (g IntTraits) EmitNodeMethodIsAbsent(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Int}.emitNodeMethodIsAbsent(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Int}.emitNodeMethodIsAbsent(w)
 }
 func (g IntTraits) EmitNodeMethodIsNull(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Int}.emitNodeMethodIsNull(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Int}.emitNodeMethodIsNull(w)
 }
 func (g IntTraits) EmitNodeMethodAsBool(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Int}.emitNodeMethodAsBool(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Int}.emitNodeMethodAsBool(w)
 }
 func (g IntTraits) EmitNodeMethodAsFloat(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Int}.emitNodeMethodAsFloat(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Int}.emitNodeMethodAsFloat(w)
 }
 func (g IntTraits) EmitNodeMethodAsString(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Int}.emitNodeMethodAsString(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Int}.emitNodeMethodAsString(w)
 }
 func (g IntTraits) EmitNodeMethodAsBytes(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Int}.emitNodeMethodAsBytes(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Int}.emitNodeMethodAsBytes(w)
 }
 func (g IntTraits) EmitNodeMethodAsLink(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Int}.emitNodeMethodAsLink(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Int}.emitNodeMethodAsLink(w)
 }
 
 type IntAssemblerTraits struct {
@@ -71,33 +71,33 @@ type IntAssemblerTraits struct {
 	AppliedPrefix string // see doc in kindAssemblerTraitsGenerator
 }
 
-func (IntAssemblerTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Int
+func (IntAssemblerTraits) Kind() ipld.Kind {
+	return ipld.Kind_Int
 }
 func (g IntAssemblerTraits) EmitNodeAssemblerMethodBeginMap(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Int}.emitNodeAssemblerMethodBeginMap(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Int}.emitNodeAssemblerMethodBeginMap(w)
 }
 func (g IntAssemblerTraits) EmitNodeAssemblerMethodBeginList(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Int}.emitNodeAssemblerMethodBeginList(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Int}.emitNodeAssemblerMethodBeginList(w)
 }
 func (g IntAssemblerTraits) EmitNodeAssemblerMethodAssignNull(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Int}.emitNodeAssemblerMethodAssignNull(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Int}.emitNodeAssemblerMethodAssignNull(w)
 }
 func (g IntAssemblerTraits) EmitNodeAssemblerMethodAssignBool(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Int}.emitNodeAssemblerMethodAssignBool(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Int}.emitNodeAssemblerMethodAssignBool(w)
 }
 func (g IntAssemblerTraits) EmitNodeAssemblerMethodAssignFloat(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Int}.emitNodeAssemblerMethodAssignFloat(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Int}.emitNodeAssemblerMethodAssignFloat(w)
 }
 func (g IntAssemblerTraits) EmitNodeAssemblerMethodAssignString(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Int}.emitNodeAssemblerMethodAssignString(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Int}.emitNodeAssemblerMethodAssignString(w)
 }
 func (g IntAssemblerTraits) EmitNodeAssemblerMethodAssignBytes(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Int}.emitNodeAssemblerMethodAssignBytes(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Int}.emitNodeAssemblerMethodAssignBytes(w)
 }
 func (g IntAssemblerTraits) EmitNodeAssemblerMethodAssignLink(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Int}.emitNodeAssemblerMethodAssignLink(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Int}.emitNodeAssemblerMethodAssignLink(w)
 }
 func (g IntAssemblerTraits) EmitNodeAssemblerMethodPrototype(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Int}.emitNodeAssemblerMethodPrototype(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Int}.emitNodeAssemblerMethodPrototype(w)
 }
diff --git a/schema/gen/go/mixins/kindTraits.go b/schema/gen/go/mixins/kindTraits.go
index 3a48200d..4c81fe16 100644
--- a/schema/gen/go/mixins/kindTraits.go
+++ b/schema/gen/go/mixins/kindTraits.go
@@ -28,11 +28,11 @@ type kindTraitsGenerator struct {
 	PkgName    string
 	TypeName   string // as will be printed in messages (e.g. can be goosed up a bit, like "Thing.Repr" instead of "_Thing__Repr").
 	TypeSymbol string // the identifier in code (sometimes is munged internals like "_Thing__Repr" corresponding to no publicly admitted schema.Type.Name).
-	Kind       ipld.ReprKind
+	Kind   ipld.Kind
 }
 
 func (g kindTraitsGenerator) emitNodeMethodLookupByString(w io.Writer) {
-	if ipld.ReprKindSet_JustMap.Contains(g.Kind) {
+	if ipld.KindSet_JustMap.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -43,7 +43,7 @@ func (g kindTraitsGenerator) emitNodeMethodLookupByString(w io.Writer) {
 }
 
 func (g kindTraitsGenerator) emitNodeMethodLookupByNode(w io.Writer) {
-	if ipld.ReprKindSet_JustMap.Contains(g.Kind) {
+	if ipld.KindSet_JustMap.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -54,7 +54,7 @@ func (g kindTraitsGenerator) emitNodeMethodLookupByNode(w io.Writer) {
 }
 
 func (g kindTraitsGenerator) emitNodeMethodLookupByIndex(w io.Writer) {
-	if ipld.ReprKindSet_JustList.Contains(g.Kind) {
+	if ipld.KindSet_JustList.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -65,7 +65,7 @@ func (g kindTraitsGenerator) emitNodeMethodLookupByIndex(w io.Writer) {
 }
 
 func (g kindTraitsGenerator) emitNodeMethodLookupBySegment(w io.Writer) {
-	if ipld.ReprKindSet_Recursive.Contains(g.Kind) {
+	if ipld.KindSet_Recursive.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -76,7 +76,7 @@ func (g kindTraitsGenerator) emitNodeMethodLookupBySegment(w io.Writer) {
 }
 
 func (g kindTraitsGenerator) emitNodeMethodMapIterator(w io.Writer) {
-	if ipld.ReprKindSet_JustMap.Contains(g.Kind) {
+	if ipld.KindSet_JustMap.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -87,7 +87,7 @@ func (g kindTraitsGenerator) emitNodeMethodMapIterator(w io.Writer) {
 }
 
 func (g kindTraitsGenerator) emitNodeMethodListIterator(w io.Writer) {
-	if ipld.ReprKindSet_JustList.Contains(g.Kind) {
+	if ipld.KindSet_JustList.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -98,7 +98,7 @@ func (g kindTraitsGenerator) emitNodeMethodListIterator(w io.Writer) {
 }
 
 func (g kindTraitsGenerator) emitNodeMethodLength(w io.Writer) {
-	if ipld.ReprKindSet_Recursive.Contains(g.Kind) {
+	if ipld.KindSet_Recursive.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -125,7 +125,7 @@ func (g kindTraitsGenerator) emitNodeMethodIsNull(w io.Writer) {
 }
 
 func (g kindTraitsGenerator) emitNodeMethodAsBool(w io.Writer) {
-	if ipld.ReprKindSet_JustBool.Contains(g.Kind) {
+	if ipld.KindSet_JustBool.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -136,7 +136,7 @@ func (g kindTraitsGenerator) emitNodeMethodAsBool(w io.Writer) {
 }
 
 func (g kindTraitsGenerator) emitNodeMethodAsInt(w io.Writer) {
-	if ipld.ReprKindSet_JustInt.Contains(g.Kind) {
+	if ipld.KindSet_JustInt.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -147,7 +147,7 @@ func (g kindTraitsGenerator) emitNodeMethodAsInt(w io.Writer) {
 }
 
 func (g kindTraitsGenerator) emitNodeMethodAsFloat(w io.Writer) {
-	if ipld.ReprKindSet_JustFloat.Contains(g.Kind) {
+	if ipld.KindSet_JustFloat.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -158,7 +158,7 @@ func (g kindTraitsGenerator) emitNodeMethodAsFloat(w io.Writer) {
 }
 
 func (g kindTraitsGenerator) emitNodeMethodAsString(w io.Writer) {
-	if ipld.ReprKindSet_JustString.Contains(g.Kind) {
+	if ipld.KindSet_JustString.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -169,7 +169,7 @@ func (g kindTraitsGenerator) emitNodeMethodAsString(w io.Writer) {
 }
 
 func (g kindTraitsGenerator) emitNodeMethodAsBytes(w io.Writer) {
-	if ipld.ReprKindSet_JustBytes.Contains(g.Kind) {
+	if ipld.KindSet_JustBytes.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -180,7 +180,7 @@ func (g kindTraitsGenerator) emitNodeMethodAsBytes(w io.Writer) {
 }
 
 func (g kindTraitsGenerator) emitNodeMethodAsLink(w io.Writer) {
-	if ipld.ReprKindSet_JustLink.Contains(g.Kind) {
+	if ipld.KindSet_JustLink.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -196,7 +196,7 @@ type kindAssemblerTraitsGenerator struct {
 	PkgName       string
 	TypeName      string // as will be printed in messages (e.g. can be goosed up a bit, like "Thing.Repr" instead of "_Thing__Repr").
 	AppliedPrefix string // the prefix of what to attach methods to... this one is a little wild: should probably be either "_{{ .Type | TypeSymbol }}__" or "_{{ .Type | TypeSymbol }}__Repr", and we'll just add the words "Builder" and "Assembler".
-	Kind          ipld.ReprKind
+	Kind      ipld.Kind
 }
 
 // bailed on extracting a common emitNodeBuilderType: too many variations in content and pointer placement to be worth it.
@@ -208,7 +208,7 @@ type kindAssemblerTraitsGenerator struct {
 //  - to still be ready for boatloads of exceptions if the representation isn't directly castable to and from the type-level node.
 
 func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodBeginMap(w io.Writer) {
-	if ipld.ReprKindSet_JustMap.Contains(g.Kind) {
+	if ipld.KindSet_JustMap.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -219,7 +219,7 @@ func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodBeginMap(w io.Write
 }
 
 func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodBeginList(w io.Writer) {
-	if ipld.ReprKindSet_JustList.Contains(g.Kind) {
+	if ipld.KindSet_JustList.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -230,7 +230,7 @@ func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodBeginList(w io.Writ
 }
 
 func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodAssignNull(w io.Writer) {
-	if ipld.ReprKindSet_JustNull.Contains(g.Kind) {
+	if ipld.KindSet_JustNull.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -241,7 +241,7 @@ func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodAssignNull(w io.Wri
 }
 
 func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodAssignBool(w io.Writer) {
-	if ipld.ReprKindSet_JustBool.Contains(g.Kind) {
+	if ipld.KindSet_JustBool.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -252,7 +252,7 @@ func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodAssignBool(w io.Wri
 }
 
 func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodAssignInt(w io.Writer) {
-	if ipld.ReprKindSet_JustInt.Contains(g.Kind) {
+	if ipld.KindSet_JustInt.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -263,7 +263,7 @@ func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodAssignInt(w io.Writ
 }
 
 func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodAssignFloat(w io.Writer) {
-	if ipld.ReprKindSet_JustFloat.Contains(g.Kind) {
+	if ipld.KindSet_JustFloat.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -274,7 +274,7 @@ func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodAssignFloat(w io.Wr
 }
 
 func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodAssignString(w io.Writer) {
-	if ipld.ReprKindSet_JustString.Contains(g.Kind) {
+	if ipld.KindSet_JustString.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -285,7 +285,7 @@ func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodAssignString(w io.W
 }
 
 func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodAssignBytes(w io.Writer) {
-	if ipld.ReprKindSet_JustBytes.Contains(g.Kind) {
+	if ipld.KindSet_JustBytes.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
@@ -296,7 +296,7 @@ func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodAssignBytes(w io.Wr
 }
 
 func (g kindAssemblerTraitsGenerator) emitNodeAssemblerMethodAssignLink(w io.Writer) {
-	if ipld.ReprKindSet_JustLink.Contains(g.Kind) {
+	if ipld.KindSet_JustLink.Contains(g.Kind) {
 		panic("gen internals error: you should've overriden this")
 	}
 	doTemplate(`
diff --git a/schema/gen/go/mixins/linkGenMixin.go b/schema/gen/go/mixins/linkGenMixin.go
index ac70d4d0..5223b9a1 100644
--- a/schema/gen/go/mixins/linkGenMixin.go
+++ b/schema/gen/go/mixins/linkGenMixin.go
@@ -12,57 +12,57 @@ type LinkTraits struct {
 	TypeSymbol string // see doc in kindTraitsGenerator
 }
 
-func (LinkTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Link
+func (LinkTraits) Kind() ipld.Kind {
+	return ipld.Kind_Link
 }
-func (g LinkTraits) EmitNodeMethodReprKind(w io.Writer) {
+func (g LinkTraits) EmitNodeMethodKind(w io.Writer) {
 	doTemplate(`
-		func ({{ .TypeSymbol }}) ReprKind() ipld.ReprKind {
-			return ipld.ReprKind_Link
+		func ({{ .TypeSymbol }}) Kind() ipld.Kind {
+			return ipld.Kind_Link
 		}
 	`, w, g)
 }
 func (g LinkTraits) EmitNodeMethodLookupByString(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Link}.emitNodeMethodLookupByString(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Link}.emitNodeMethodLookupByString(w)
 }
 func (g LinkTraits) EmitNodeMethodLookupByNode(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Link}.emitNodeMethodLookupByNode(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Link}.emitNodeMethodLookupByNode(w)
 }
 func (g LinkTraits) EmitNodeMethodLookupByIndex(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Link}.emitNodeMethodLookupByIndex(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Link}.emitNodeMethodLookupByIndex(w)
 }
 func (g LinkTraits) EmitNodeMethodLookupBySegment(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Link}.emitNodeMethodLookupBySegment(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Link}.emitNodeMethodLookupBySegment(w)
 }
 func (g LinkTraits) EmitNodeMethodMapIterator(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Link}.emitNodeMethodMapIterator(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Link}.emitNodeMethodMapIterator(w)
 }
 func (g LinkTraits) EmitNodeMethodListIterator(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Link}.emitNodeMethodListIterator(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Link}.emitNodeMethodListIterator(w)
 }
 func (g LinkTraits) EmitNodeMethodLength(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Link}.emitNodeMethodLength(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Link}.emitNodeMethodLength(w)
 }
 func (g LinkTraits) EmitNodeMethodIsAbsent(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Link}.emitNodeMethodIsAbsent(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Link}.emitNodeMethodIsAbsent(w)
 }
 func (g LinkTraits) EmitNodeMethodIsNull(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Link}.emitNodeMethodIsNull(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Link}.emitNodeMethodIsNull(w)
 }
 func (g LinkTraits) EmitNodeMethodAsBool(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Link}.emitNodeMethodAsBool(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Link}.emitNodeMethodAsBool(w)
 }
 func (g LinkTraits) EmitNodeMethodAsInt(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Link}.emitNodeMethodAsInt(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Link}.emitNodeMethodAsInt(w)
 }
 func (g LinkTraits) EmitNodeMethodAsFloat(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Link}.emitNodeMethodAsFloat(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Link}.emitNodeMethodAsFloat(w)
 }
 func (g LinkTraits) EmitNodeMethodAsString(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Link}.emitNodeMethodAsString(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Link}.emitNodeMethodAsString(w)
 }
 func (g LinkTraits) EmitNodeMethodAsBytes(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Link}.emitNodeMethodAsBytes(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Link}.emitNodeMethodAsBytes(w)
 }
 
 type LinkAssemblerTraits struct {
@@ -71,33 +71,33 @@ type LinkAssemblerTraits struct {
 	AppliedPrefix string // see doc in kindAssemblerTraitsGenerator
 }
 
-func (LinkAssemblerTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Link
+func (LinkAssemblerTraits) Kind() ipld.Kind {
+	return ipld.Kind_Link
 }
 func (g LinkAssemblerTraits) EmitNodeAssemblerMethodBeginMap(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Link}.emitNodeAssemblerMethodBeginMap(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Link}.emitNodeAssemblerMethodBeginMap(w)
 }
 func (g LinkAssemblerTraits) EmitNodeAssemblerMethodBeginList(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Link}.emitNodeAssemblerMethodBeginList(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Link}.emitNodeAssemblerMethodBeginList(w)
 }
 func (g LinkAssemblerTraits) EmitNodeAssemblerMethodAssignNull(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Link}.emitNodeAssemblerMethodAssignNull(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Link}.emitNodeAssemblerMethodAssignNull(w)
 }
 func (g LinkAssemblerTraits) EmitNodeAssemblerMethodAssignBool(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Link}.emitNodeAssemblerMethodAssignBool(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Link}.emitNodeAssemblerMethodAssignBool(w)
 }
 func (g LinkAssemblerTraits) EmitNodeAssemblerMethodAssignInt(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Link}.emitNodeAssemblerMethodAssignInt(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Link}.emitNodeAssemblerMethodAssignInt(w)
 }
 func (g LinkAssemblerTraits) EmitNodeAssemblerMethodAssignFloat(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Link}.emitNodeAssemblerMethodAssignFloat(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Link}.emitNodeAssemblerMethodAssignFloat(w)
 }
 func (g LinkAssemblerTraits) EmitNodeAssemblerMethodAssignString(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Link}.emitNodeAssemblerMethodAssignString(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Link}.emitNodeAssemblerMethodAssignString(w)
 }
 func (g LinkAssemblerTraits) EmitNodeAssemblerMethodAssignBytes(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Link}.emitNodeAssemblerMethodAssignBytes(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Link}.emitNodeAssemblerMethodAssignBytes(w)
 }
 func (g LinkAssemblerTraits) EmitNodeAssemblerMethodPrototype(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Link}.emitNodeAssemblerMethodPrototype(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Link}.emitNodeAssemblerMethodPrototype(w)
 }
diff --git a/schema/gen/go/mixins/listGenMixin.go b/schema/gen/go/mixins/listGenMixin.go
index 939888aa..a1019507 100644
--- a/schema/gen/go/mixins/listGenMixin.go
+++ b/schema/gen/go/mixins/listGenMixin.go
@@ -12,18 +12,18 @@ type ListTraits struct {
 	TypeSymbol string // see doc in kindTraitsGenerator
 }
 
-func (ListTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_List
+func (ListTraits) Kind() ipld.Kind {
+	return ipld.Kind_List
 }
-func (g ListTraits) EmitNodeMethodReprKind(w io.Writer) {
+func (g ListTraits) EmitNodeMethodKind(w io.Writer) {
 	doTemplate(`
-		func ({{ .TypeSymbol }}) ReprKind() ipld.ReprKind {
-			return ipld.ReprKind_List
+		func ({{ .TypeSymbol }}) Kind() ipld.Kind {
+			return ipld.Kind_List
 		}
 	`, w, g)
 }
 func (g ListTraits) EmitNodeMethodLookupByString(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_List}.emitNodeMethodLookupByString(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_List}.emitNodeMethodLookupByString(w)
 }
 func (g ListTraits) EmitNodeMethodLookupBySegment(w io.Writer) {
 	doTemplate(`
@@ -37,31 +37,31 @@ func (g ListTraits) EmitNodeMethodLookupBySegment(w io.Writer) {
 	`, w, g)
 }
 func (g ListTraits) EmitNodeMethodMapIterator(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_List}.emitNodeMethodMapIterator(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_List}.emitNodeMethodMapIterator(w)
 }
 func (g ListTraits) EmitNodeMethodIsAbsent(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_List}.emitNodeMethodIsAbsent(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_List}.emitNodeMethodIsAbsent(w)
 }
 func (g ListTraits) EmitNodeMethodIsNull(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_List}.emitNodeMethodIsNull(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_List}.emitNodeMethodIsNull(w)
 }
 func (g ListTraits) EmitNodeMethodAsBool(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_List}.emitNodeMethodAsBool(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_List}.emitNodeMethodAsBool(w)
 }
 func (g ListTraits) EmitNodeMethodAsInt(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_List}.emitNodeMethodAsInt(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_List}.emitNodeMethodAsInt(w)
 }
 func (g ListTraits) EmitNodeMethodAsFloat(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_List}.emitNodeMethodAsFloat(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_List}.emitNodeMethodAsFloat(w)
 }
 func (g ListTraits) EmitNodeMethodAsString(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_List}.emitNodeMethodAsString(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_List}.emitNodeMethodAsString(w)
 }
 func (g ListTraits) EmitNodeMethodAsBytes(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_List}.emitNodeMethodAsBytes(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_List}.emitNodeMethodAsBytes(w)
 }
 func (g ListTraits) EmitNodeMethodAsLink(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_List}.emitNodeMethodAsLink(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_List}.emitNodeMethodAsLink(w)
 }
 
 type ListAssemblerTraits struct {
@@ -70,33 +70,33 @@ type ListAssemblerTraits struct {
 	AppliedPrefix string // see doc in kindAssemblerTraitsGenerator
 }
 
-func (ListAssemblerTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_List
+func (ListAssemblerTraits) Kind() ipld.Kind {
+	return ipld.Kind_List
 }
 func (g ListAssemblerTraits) EmitNodeAssemblerMethodBeginMap(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_List}.emitNodeAssemblerMethodBeginMap(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_List}.emitNodeAssemblerMethodBeginMap(w)
 }
 func (g ListAssemblerTraits) EmitNodeAssemblerMethodAssignNull(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_List}.emitNodeAssemblerMethodAssignNull(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_List}.emitNodeAssemblerMethodAssignNull(w)
 }
 func (g ListAssemblerTraits) EmitNodeAssemblerMethodAssignBool(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_List}.emitNodeAssemblerMethodAssignBool(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_List}.emitNodeAssemblerMethodAssignBool(w)
 }
 func (g ListAssemblerTraits) EmitNodeAssemblerMethodAssignInt(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_List}.emitNodeAssemblerMethodAssignInt(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_List}.emitNodeAssemblerMethodAssignInt(w)
 }
 func (g ListAssemblerTraits) EmitNodeAssemblerMethodAssignFloat(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_List}.emitNodeAssemblerMethodAssignFloat(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_List}.emitNodeAssemblerMethodAssignFloat(w)
 }
 func (g ListAssemblerTraits) EmitNodeAssemblerMethodAssignString(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_List}.emitNodeAssemblerMethodAssignString(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_List}.emitNodeAssemblerMethodAssignString(w)
 }
 func (g ListAssemblerTraits) EmitNodeAssemblerMethodAssignBytes(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_List}.emitNodeAssemblerMethodAssignBytes(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_List}.emitNodeAssemblerMethodAssignBytes(w)
 }
 func (g ListAssemblerTraits) EmitNodeAssemblerMethodAssignLink(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_List}.emitNodeAssemblerMethodAssignLink(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_List}.emitNodeAssemblerMethodAssignLink(w)
 }
 func (g ListAssemblerTraits) EmitNodeAssemblerMethodPrototype(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_List}.emitNodeAssemblerMethodPrototype(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_List}.emitNodeAssemblerMethodPrototype(w)
 }
diff --git a/schema/gen/go/mixins/mapGenMixin.go b/schema/gen/go/mixins/mapGenMixin.go
index e271be82..cd5dee83 100644
--- a/schema/gen/go/mixins/mapGenMixin.go
+++ b/schema/gen/go/mixins/mapGenMixin.go
@@ -12,18 +12,18 @@ type MapTraits struct {
 	TypeSymbol string // see doc in kindTraitsGenerator
 }
 
-func (MapTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (MapTraits) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
-func (g MapTraits) EmitNodeMethodReprKind(w io.Writer) {
+func (g MapTraits) EmitNodeMethodKind(w io.Writer) {
 	doTemplate(`
-		func ({{ .TypeSymbol }}) ReprKind() ipld.ReprKind {
-			return ipld.ReprKind_Map
+		func ({{ .TypeSymbol }}) Kind() ipld.Kind {
+			return ipld.Kind_Map
 		}
 	`, w, g)
 }
 func (g MapTraits) EmitNodeMethodLookupByIndex(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Map}.emitNodeMethodLookupByIndex(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Map}.emitNodeMethodLookupByIndex(w)
 }
 func (g MapTraits) EmitNodeMethodLookupBySegment(w io.Writer) {
 	doTemplate(`
@@ -33,31 +33,31 @@ func (g MapTraits) EmitNodeMethodLookupBySegment(w io.Writer) {
 	`, w, g)
 }
 func (g MapTraits) EmitNodeMethodListIterator(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Map}.emitNodeMethodListIterator(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Map}.emitNodeMethodListIterator(w)
 }
 func (g MapTraits) EmitNodeMethodIsAbsent(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Map}.emitNodeMethodIsAbsent(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Map}.emitNodeMethodIsAbsent(w)
 }
 func (g MapTraits) EmitNodeMethodIsNull(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Map}.emitNodeMethodIsNull(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Map}.emitNodeMethodIsNull(w)
 }
 func (g MapTraits) EmitNodeMethodAsBool(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Map}.emitNodeMethodAsBool(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Map}.emitNodeMethodAsBool(w)
 }
 func (g MapTraits) EmitNodeMethodAsInt(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Map}.emitNodeMethodAsInt(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Map}.emitNodeMethodAsInt(w)
 }
 func (g MapTraits) EmitNodeMethodAsFloat(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Map}.emitNodeMethodAsFloat(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Map}.emitNodeMethodAsFloat(w)
 }
 func (g MapTraits) EmitNodeMethodAsString(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Map}.emitNodeMethodAsString(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Map}.emitNodeMethodAsString(w)
 }
 func (g MapTraits) EmitNodeMethodAsBytes(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Map}.emitNodeMethodAsBytes(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Map}.emitNodeMethodAsBytes(w)
 }
 func (g MapTraits) EmitNodeMethodAsLink(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_Map}.emitNodeMethodAsLink(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_Map}.emitNodeMethodAsLink(w)
 }
 
 type MapAssemblerTraits struct {
@@ -66,33 +66,33 @@ type MapAssemblerTraits struct {
 	AppliedPrefix string // see doc in kindAssemblerTraitsGenerator
 }
 
-func (MapAssemblerTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (MapAssemblerTraits) Kind() ipld.Kind {
+	return ipld.Kind_Map
 }
 func (g MapAssemblerTraits) EmitNodeAssemblerMethodBeginList(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Map}.emitNodeAssemblerMethodBeginList(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Map}.emitNodeAssemblerMethodBeginList(w)
 }
 func (g MapAssemblerTraits) EmitNodeAssemblerMethodAssignNull(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Map}.emitNodeAssemblerMethodAssignNull(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Map}.emitNodeAssemblerMethodAssignNull(w)
 }
 func (g MapAssemblerTraits) EmitNodeAssemblerMethodAssignBool(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Map}.emitNodeAssemblerMethodAssignBool(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Map}.emitNodeAssemblerMethodAssignBool(w)
 }
 func (g MapAssemblerTraits) EmitNodeAssemblerMethodAssignInt(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Map}.emitNodeAssemblerMethodAssignInt(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Map}.emitNodeAssemblerMethodAssignInt(w)
 }
 func (g MapAssemblerTraits) EmitNodeAssemblerMethodAssignFloat(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Map}.emitNodeAssemblerMethodAssignFloat(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Map}.emitNodeAssemblerMethodAssignFloat(w)
 }
 func (g MapAssemblerTraits) EmitNodeAssemblerMethodAssignString(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Map}.emitNodeAssemblerMethodAssignString(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Map}.emitNodeAssemblerMethodAssignString(w)
 }
 func (g MapAssemblerTraits) EmitNodeAssemblerMethodAssignBytes(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Map}.emitNodeAssemblerMethodAssignBytes(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Map}.emitNodeAssemblerMethodAssignBytes(w)
 }
 func (g MapAssemblerTraits) EmitNodeAssemblerMethodAssignLink(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Map}.emitNodeAssemblerMethodAssignLink(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Map}.emitNodeAssemblerMethodAssignLink(w)
 }
 func (g MapAssemblerTraits) EmitNodeAssemblerMethodPrototype(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_Map}.emitNodeAssemblerMethodPrototype(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_Map}.emitNodeAssemblerMethodPrototype(w)
 }
diff --git a/schema/gen/go/mixins/stringGenMixin.go b/schema/gen/go/mixins/stringGenMixin.go
index e6ad7b14..e13516b5 100644
--- a/schema/gen/go/mixins/stringGenMixin.go
+++ b/schema/gen/go/mixins/stringGenMixin.go
@@ -12,57 +12,57 @@ type StringTraits struct {
 	TypeSymbol string // see doc in kindTraitsGenerator
 }
 
-func (StringTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_String
+func (StringTraits) Kind() ipld.Kind {
+	return ipld.Kind_String
 }
-func (g StringTraits) EmitNodeMethodReprKind(w io.Writer) {
+func (g StringTraits) EmitNodeMethodKind(w io.Writer) {
 	doTemplate(`
-		func ({{ .TypeSymbol }}) ReprKind() ipld.ReprKind {
-			return ipld.ReprKind_String
+		func ({{ .TypeSymbol }}) Kind() ipld.Kind {
+			return ipld.Kind_String
 		}
 	`, w, g)
 }
 func (g StringTraits) EmitNodeMethodLookupByString(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_String}.emitNodeMethodLookupByString(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_String}.emitNodeMethodLookupByString(w)
 }
 func (g StringTraits) EmitNodeMethodLookupByNode(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_String}.emitNodeMethodLookupByNode(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_String}.emitNodeMethodLookupByNode(w)
 }
 func (g StringTraits) EmitNodeMethodLookupByIndex(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_String}.emitNodeMethodLookupByIndex(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_String}.emitNodeMethodLookupByIndex(w)
 }
 func (g StringTraits) EmitNodeMethodLookupBySegment(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_String}.emitNodeMethodLookupBySegment(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_String}.emitNodeMethodLookupBySegment(w)
 }
 func (g StringTraits) EmitNodeMethodMapIterator(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_String}.emitNodeMethodMapIterator(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_String}.emitNodeMethodMapIterator(w)
 }
 func (g StringTraits) EmitNodeMethodListIterator(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_String}.emitNodeMethodListIterator(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_String}.emitNodeMethodListIterator(w)
 }
 func (g StringTraits) EmitNodeMethodLength(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_String}.emitNodeMethodLength(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_String}.emitNodeMethodLength(w)
 }
 func (g StringTraits) EmitNodeMethodIsAbsent(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_String}.emitNodeMethodIsAbsent(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_String}.emitNodeMethodIsAbsent(w)
 }
 func (g StringTraits) EmitNodeMethodIsNull(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_String}.emitNodeMethodIsNull(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_String}.emitNodeMethodIsNull(w)
 }
 func (g StringTraits) EmitNodeMethodAsBool(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_String}.emitNodeMethodAsBool(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_String}.emitNodeMethodAsBool(w)
 }
 func (g StringTraits) EmitNodeMethodAsInt(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_String}.emitNodeMethodAsInt(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_String}.emitNodeMethodAsInt(w)
 }
 func (g StringTraits) EmitNodeMethodAsFloat(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_String}.emitNodeMethodAsFloat(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_String}.emitNodeMethodAsFloat(w)
 }
 func (g StringTraits) EmitNodeMethodAsBytes(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_String}.emitNodeMethodAsBytes(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_String}.emitNodeMethodAsBytes(w)
 }
 func (g StringTraits) EmitNodeMethodAsLink(w io.Writer) {
-	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.ReprKind_String}.emitNodeMethodAsLink(w)
+	kindTraitsGenerator{g.PkgName, g.TypeName, g.TypeSymbol, ipld.Kind_String}.emitNodeMethodAsLink(w)
 }
 
 type StringAssemblerTraits struct {
@@ -71,33 +71,33 @@ type StringAssemblerTraits struct {
 	AppliedPrefix string // see doc in kindAssemblerTraitsGenerator
 }
 
-func (StringAssemblerTraits) ReprKind() ipld.ReprKind {
-	return ipld.ReprKind_String
+func (StringAssemblerTraits) Kind() ipld.Kind {
+	return ipld.Kind_String
 }
 func (g StringAssemblerTraits) EmitNodeAssemblerMethodBeginMap(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_String}.emitNodeAssemblerMethodBeginMap(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_String}.emitNodeAssemblerMethodBeginMap(w)
 }
 func (g StringAssemblerTraits) EmitNodeAssemblerMethodBeginList(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_String}.emitNodeAssemblerMethodBeginList(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_String}.emitNodeAssemblerMethodBeginList(w)
 }
 func (g StringAssemblerTraits) EmitNodeAssemblerMethodAssignNull(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_String}.emitNodeAssemblerMethodAssignNull(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_String}.emitNodeAssemblerMethodAssignNull(w)
 }
 func (g StringAssemblerTraits) EmitNodeAssemblerMethodAssignBool(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_String}.emitNodeAssemblerMethodAssignBool(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_String}.emitNodeAssemblerMethodAssignBool(w)
 }
 func (g StringAssemblerTraits) EmitNodeAssemblerMethodAssignInt(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_String}.emitNodeAssemblerMethodAssignInt(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_String}.emitNodeAssemblerMethodAssignInt(w)
 }
 func (g StringAssemblerTraits) EmitNodeAssemblerMethodAssignFloat(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_String}.emitNodeAssemblerMethodAssignFloat(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_String}.emitNodeAssemblerMethodAssignFloat(w)
 }
 func (g StringAssemblerTraits) EmitNodeAssemblerMethodAssignBytes(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_String}.emitNodeAssemblerMethodAssignBytes(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_String}.emitNodeAssemblerMethodAssignBytes(w)
 }
 func (g StringAssemblerTraits) EmitNodeAssemblerMethodAssignLink(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_String}.emitNodeAssemblerMethodAssignLink(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_String}.emitNodeAssemblerMethodAssignLink(w)
 }
 func (g StringAssemblerTraits) EmitNodeAssemblerMethodPrototype(w io.Writer) {
-	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.ReprKind_String}.emitNodeAssemblerMethodPrototype(w)
+	kindAssemblerTraitsGenerator{g.PkgName, g.TypeName, g.AppliedPrefix, ipld.Kind_String}.emitNodeAssemblerMethodPrototype(w)
 }
diff --git a/schema/gen/go/templateUtil.go b/schema/gen/go/templateUtil.go
index ea9c1d5e..fb7c327d 100644
--- a/schema/gen/go/templateUtil.go
+++ b/schema/gen/go/templateUtil.go
@@ -31,74 +31,74 @@ func doTemplate(tmplstr string, w io.Writer, adjCfg *AdjunctCfg, data interface{
 			//  (This may seem silly, but empirically, I found myself writing a dummy line to store the value of dot before endering a range clause >20 times; that's plenty.)
 			"dot": func() interface{} { return data },
 
-			"KindPrim": func(k ipld.ReprKind) string {
+			"KindPrim": func(k ipld.Kind) string {
 				switch k {
-				case ipld.ReprKind_Map:
+				case ipld.Kind_Map:
 					panic("this isn't useful for non-scalars")
-				case ipld.ReprKind_List:
+				case ipld.Kind_List:
 					panic("this isn't useful for non-scalars")
-				case ipld.ReprKind_Null:
+				case ipld.Kind_Null:
 					panic("this isn't useful for null")
-				case ipld.ReprKind_Bool:
+				case ipld.Kind_Bool:
 					return "bool"
-				case ipld.ReprKind_Int:
+				case ipld.Kind_Int:
 					return "int64"
-				case ipld.ReprKind_Float:
+				case ipld.Kind_Float:
 					return "float64"
-				case ipld.ReprKind_String:
+				case ipld.Kind_String:
 					return "string"
-				case ipld.ReprKind_Bytes:
+				case ipld.Kind_Bytes:
 					return "[]byte"
-				case ipld.ReprKind_Link:
+				case ipld.Kind_Link:
 					return "ipld.Link"
 				default:
 					panic("invalid enumeration value!")
 				}
 			},
-			"Kind": func(s string) ipld.ReprKind {
+			"Kind": func(s string) ipld.Kind {
 				switch s {
 				case "map":
-					return ipld.ReprKind_Map
+					return ipld.Kind_Map
 				case "list":
-					return ipld.ReprKind_List
+					return ipld.Kind_List
 				case "null":
-					return ipld.ReprKind_Null
+					return ipld.Kind_Null
 				case "bool":
-					return ipld.ReprKind_Bool
+					return ipld.Kind_Bool
 				case "int":
-					return ipld.ReprKind_Int
+					return ipld.Kind_Int
 				case "float":
-					return ipld.ReprKind_Float
+					return ipld.Kind_Float
 				case "string":
-					return ipld.ReprKind_String
+					return ipld.Kind_String
 				case "bytes":
-					return ipld.ReprKind_Bytes
+					return ipld.Kind_Bytes
 				case "link":
-					return ipld.ReprKind_Link
+					return ipld.Kind_Link
 				default:
 					panic("invalid enumeration value!")
 				}
 			},
-			"KindSymbol": func(k ipld.ReprKind) string {
+			"KindSymbol": func(k ipld.Kind) string {
 				switch k {
-				case ipld.ReprKind_Map:
-					return "ipld.ReprKind_Map"
-				case ipld.ReprKind_List:
-					return "ipld.ReprKind_List"
-				case ipld.ReprKind_Null:
-					return "ipld.ReprKind_Null"
-				case ipld.ReprKind_Bool:
-					return "ipld.ReprKind_Bool"
-				case ipld.ReprKind_Int:
-					return "ipld.ReprKind_Int"
-				case ipld.ReprKind_Float:
-					return "ipld.ReprKind_Float"
-				case ipld.ReprKind_String:
-					return "ipld.ReprKind_String"
-				case ipld.ReprKind_Bytes:
-					return "ipld.ReprKind_Bytes"
-				case ipld.ReprKind_Link:
-					return "ipld.ReprKind_Link"
+				case ipld.Kind_Map:
+					return "ipld.Kind_Map"
+				case ipld.Kind_List:
+					return "ipld.Kind_List"
+				case ipld.Kind_Null:
+					return "ipld.Kind_Null"
+				case ipld.Kind_Bool:
+					return "ipld.Kind_Bool"
+				case ipld.Kind_Int:
+					return "ipld.Kind_Int"
+				case ipld.Kind_Float:
+					return "ipld.Kind_Float"
+				case ipld.Kind_String:
+					return "ipld.Kind_String"
+				case ipld.Kind_Bytes:
+					return "ipld.Kind_Bytes"
+				case ipld.Kind_Link:
+					return "ipld.Kind_Link"
 				default:
 					panic("invalid enumeration value!")
 				}
diff --git a/schema/gen/go/testLists_test.go b/schema/gen/go/testLists_test.go
index d86484d2..f9ff2bc9 100644
--- a/schema/gen/go/testLists_test.go
+++ b/schema/gen/go/testLists_test.go
@@ -36,7 +36,7 @@ func TestListsContainingMaybe(t *testing.T) {
 					la.AssembleValue().AssignString("2")
 				}).(schema.TypedNode)
 				t.Run("typed-read", func(t *testing.T) {
-					Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_List)
+					Require(t, n.Kind(), ShouldEqual, ipld.Kind_List)
 					Wish(t, n.Length(), ShouldEqual, int64(2))
 					Wish(t, must.String(must.Node(n.LookupByIndex(0))), ShouldEqual, "1")
 					Wish(t, must.String(must.Node(n.LookupByIndex(1))), ShouldEqual, "2")
@@ -45,7 +45,7 @@ func TestListsContainingMaybe(t *testing.T) {
 				})
 				t.Run("repr-read", func(t *testing.T) {
 					nr := n.Representation()
-					Require(t, nr.ReprKind(), ShouldEqual, ipld.ReprKind_List)
+					Require(t, nr.Kind(), ShouldEqual, ipld.Kind_List)
 					Wish(t, nr.Length(), ShouldEqual, int64(2))
 					Wish(t, must.String(must.Node(nr.LookupByIndex(0))), ShouldEqual, "1")
 					Wish(t, must.String(must.Node(nr.LookupByIndex(1))), ShouldEqual, "2")
@@ -71,7 +71,7 @@ func TestListsContainingMaybe(t *testing.T) {
 					la.AssembleValue().AssignNull()
 				}).(schema.TypedNode)
 				t.Run("typed-read", func(t *testing.T) {
-					Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_List)
+					Require(t, n.Kind(), ShouldEqual, ipld.Kind_List)
 					Wish(t, n.Length(), ShouldEqual, int64(2))
 					Wish(t, must.String(must.Node(n.LookupByIndex(0))), ShouldEqual, "1")
 					Wish(t, must.Node(n.LookupByIndex(1)), ShouldEqual, ipld.Null)
@@ -80,7 +80,7 @@ func TestListsContainingMaybe(t *testing.T) {
 				})
 				t.Run("repr-read", func(t *testing.T) {
 					nr := n.Representation()
-					Require(t, nr.ReprKind(), ShouldEqual, ipld.ReprKind_List)
+					Require(t, nr.Kind(), ShouldEqual, ipld.Kind_List)
 					Wish(t, nr.Length(), ShouldEqual, int64(2))
 					Wish(t, must.String(must.Node(n.LookupByIndex(0))), ShouldEqual, "1")
 					Wish(t, must.Node(n.LookupByIndex(1)), ShouldEqual, ipld.Null)
@@ -166,7 +166,7 @@ func TestListsContainingLists(t *testing.T) {
 				})
 			}).(schema.TypedNode)
 			t.Run("typed-read", func(t *testing.T) {
-				Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_List)
+				Require(t, n.Kind(), ShouldEqual, ipld.Kind_List)
 				Require(t, n.Length(), ShouldEqual, int64(3))
 				Require(t, must.Node(n.LookupByIndex(0)).Length(), ShouldEqual, int64(3))
 				Require(t, must.Node(n.LookupByIndex(1)).Length(), ShouldEqual, int64(1))
@@ -179,7 +179,7 @@ func TestListsContainingLists(t *testing.T) {
 			})
 			t.Run("repr-read", func(t *testing.T) {
 				nr := n.Representation()
-				Require(t, nr.ReprKind(), ShouldEqual, ipld.ReprKind_List)
+				Require(t, nr.Kind(), ShouldEqual, ipld.Kind_List)
 				Require(t, nr.Length(), ShouldEqual, int64(3))
 				Require(t, must.Node(nr.LookupByIndex(0)).Length(), ShouldEqual, int64(3))
 				Require(t, must.Node(nr.LookupByIndex(1)).Length(), ShouldEqual, int64(1))
diff --git a/schema/gen/go/testMaps_test.go b/schema/gen/go/testMaps_test.go
index 2fbbda6f..b2427555 100644
--- a/schema/gen/go/testMaps_test.go
+++ b/schema/gen/go/testMaps_test.go
@@ -36,7 +36,7 @@ func TestMapsContainingMaybe(t *testing.T) {
 					ma.AssembleEntry("two").AssignString("2")
 				}).(schema.TypedNode)
 				t.Run("typed-read", func(t *testing.T) {
-					Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+					Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 					Wish(t, n.Length(), ShouldEqual, int64(2))
 					Wish(t, must.String(must.Node(n.LookupByString("one"))), ShouldEqual, "1")
 					Wish(t, must.String(must.Node(n.LookupByString("two"))), ShouldEqual, "2")
@@ -45,7 +45,7 @@ func TestMapsContainingMaybe(t *testing.T) {
 				})
 				t.Run("repr-read", func(t *testing.T) {
 					nr := n.Representation()
-					Require(t, nr.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+					Require(t, nr.Kind(), ShouldEqual, ipld.Kind_Map)
 					Wish(t, nr.Length(), ShouldEqual, int64(2))
 					Wish(t, must.String(must.Node(nr.LookupByString("one"))), ShouldEqual, "1")
 					Wish(t, must.String(must.Node(nr.LookupByString("two"))), ShouldEqual, "2")
@@ -71,7 +71,7 @@ func TestMapsContainingMaybe(t *testing.T) {
 					ma.AssembleEntry("none").AssignNull()
 				}).(schema.TypedNode)
 				t.Run("typed-read", func(t *testing.T) {
-					Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+					Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 					Wish(t, n.Length(), ShouldEqual, int64(2))
 					Wish(t, must.String(must.Node(n.LookupByString("one"))), ShouldEqual, "1")
 					Wish(t, must.Node(n.LookupByString("none")), ShouldEqual, ipld.Null)
@@ -80,7 +80,7 @@ func TestMapsContainingMaybe(t *testing.T) {
 				})
 				t.Run("repr-read", func(t *testing.T) {
 					nr := n.Representation()
-					Require(t, nr.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+					Require(t, nr.Kind(), ShouldEqual, ipld.Kind_Map)
 					Wish(t, nr.Length(), ShouldEqual, int64(2))
 					Wish(t, must.String(must.Node(nr.LookupByString("one"))), ShouldEqual, "1")
 					Wish(t, must.Node(nr.LookupByString("none")), ShouldEqual, ipld.Null)
@@ -163,18 +163,18 @@ func TestMapsContainingMaps(t *testing.T) {
 		}
 		reading := func(t *testing.T, n ipld.Node, fieldName string) {
 			withNode(n, func(n ipld.Node) {
-				Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+				Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 				Wish(t, n.Length(), ShouldEqual, int64(3))
 				withNode(must.Node(n.LookupByString("one")), func(n ipld.Node) {
-					Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+					Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 					Wish(t, n.Length(), ShouldEqual, int64(2))
 					withNode(must.Node(n.LookupByString("zot")), func(n ipld.Node) {
-						Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+						Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 						Wish(t, n.Length(), ShouldEqual, int64(1))
 						Wish(t, must.String(must.Node(n.LookupByString(fieldName))), ShouldEqual, "11")
 					})
 					withNode(must.Node(n.LookupByString("zop")), func(n ipld.Node) {
-						Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+						Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 						Wish(t, n.Length(), ShouldEqual, int64(1))
 						Wish(t, must.String(must.Node(n.LookupByString(fieldName))), ShouldEqual, "12")
 					})
@@ -182,7 +182,7 @@ func TestMapsContainingMaps(t *testing.T) {
 				withNode(must.Node(n.LookupByString("two")), func(n ipld.Node) {
 					Wish(t, n.Length(), ShouldEqual, int64(1))
 					withNode(must.Node(n.LookupByString("zim")), func(n ipld.Node) {
-						Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+						Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 						Wish(t, n.Length(), ShouldEqual, int64(1))
 						Wish(t, must.String(must.Node(n.LookupByString(fieldName))), ShouldEqual, "21")
 					})
@@ -255,18 +255,18 @@ func TestMapsWithComplexKeys(t *testing.T) {
 				ma.AssembleValue().AssignString("3")
 			}).(schema.TypedNode)
 			t.Run("typed-read", func(t *testing.T) {
-				Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+				Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 				Wish(t, n.Length(), ShouldEqual, int64(3))
 				n2 := must.Node(n.LookupByString("c:d"))
-				Require(t, n2.ReprKind(), ShouldEqual, ipld.ReprKind_String)
+				Require(t, n2.Kind(), ShouldEqual, ipld.Kind_String)
 				Wish(t, must.String(n2), ShouldEqual, "2")
 			})
 			t.Run("repr-read", func(t *testing.T) {
 				nr := n.Representation()
-				Require(t, nr.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+				Require(t, nr.Kind(), ShouldEqual, ipld.Kind_Map)
 				Wish(t, nr.Length(), ShouldEqual, int64(3))
 				n2 := must.Node(nr.LookupByString("c:d"))
-				Require(t, n2.ReprKind(), ShouldEqual, ipld.ReprKind_String)
+				Require(t, n2.Kind(), ShouldEqual, ipld.Kind_String)
 				Wish(t, must.String(n2), ShouldEqual, "2")
 			})
 		})
diff --git a/schema/gen/go/testString_test.go b/schema/gen/go/testString_test.go
index 292748a0..097167ce 100644
--- a/schema/gen/go/testString_test.go
+++ b/schema/gen/go/testString_test.go
@@ -29,11 +29,11 @@ func TestString(t *testing.T) {
 			Wish(t, nb.AssignString("woiu"), ShouldEqual, nil)
 			n := nb.Build().(schema.TypedNode)
 			t.Run("read string", func(t *testing.T) {
-				Wish(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_String)
+				Wish(t, n.Kind(), ShouldEqual, ipld.Kind_String)
 			})
 			t.Run("read representation", func(t *testing.T) {
 				nr := n.Representation()
-				Wish(t, nr.ReprKind(), ShouldEqual, ipld.ReprKind_String)
+				Wish(t, nr.Kind(), ShouldEqual, ipld.Kind_String)
 				Wish(t, str(nr), ShouldEqual, "woiu")
 			})
 		})
diff --git a/schema/gen/go/testStructReprStringjoin_test.go b/schema/gen/go/testStructReprStringjoin_test.go
index 5fb01785..4544da9b 100644
--- a/schema/gen/go/testStructReprStringjoin_test.go
+++ b/schema/gen/go/testStructReprStringjoin_test.go
@@ -59,13 +59,13 @@ func TestStructReprStringjoin(t *testing.T) {
 					ma.AssembleEntry("field").AssignString("valoo")
 				}).(schema.TypedNode)
 				t.Run("typed-read", func(t *testing.T) {
-					Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+					Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 					Wish(t, n.Length(), ShouldEqual, int64(1))
 					Wish(t, must.String(must.Node(n.LookupByString("field"))), ShouldEqual, "valoo")
 				})
 				t.Run("repr-read", func(t *testing.T) {
 					nr := n.Representation()
-					Require(t, nr.ReprKind(), ShouldEqual, ipld.ReprKind_String)
+					Require(t, nr.Kind(), ShouldEqual, ipld.Kind_String)
 					Wish(t, must.String(nr), ShouldEqual, "valoo")
 				})
 			})
@@ -87,14 +87,14 @@ func TestStructReprStringjoin(t *testing.T) {
 					ma.AssembleEntry("bar").AssignString("v2")
 				}).(schema.TypedNode)
 				t.Run("typed-read", func(t *testing.T) {
-					Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+					Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 					Wish(t, n.Length(), ShouldEqual, int64(2))
 					Wish(t, must.String(must.Node(n.LookupByString("foo"))), ShouldEqual, "v1")
 					Wish(t, must.String(must.Node(n.LookupByString("bar"))), ShouldEqual, "v2")
 				})
 				t.Run("repr-read", func(t *testing.T) {
 					nr := n.Representation()
-					Require(t, nr.ReprKind(), ShouldEqual, ipld.ReprKind_String)
+					Require(t, nr.Kind(), ShouldEqual, ipld.Kind_String)
 					Wish(t, must.String(nr), ShouldEqual, "v1:v2")
 				})
 			})
@@ -120,7 +120,7 @@ func TestStructReprStringjoin(t *testing.T) {
 					ma.AssembleEntry("bar").AssignString("v4")
 				}).(schema.TypedNode)
 				t.Run("typed-read", func(t *testing.T) {
-					Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+					Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 					Wish(t, n.Length(), ShouldEqual, int64(3))
 					Wish(t, must.String(must.Node(n.LookupByString("foo"))), ShouldEqual, "v1")
 					Wish(t, must.String(must.Node(n.LookupByString("bar"))), ShouldEqual, "v4")
@@ -131,7 +131,7 @@ func TestStructReprStringjoin(t *testing.T) {
 				})
 				t.Run("repr-read", func(t *testing.T) {
 					nr := n.Representation()
-					Require(t, nr.ReprKind(), ShouldEqual, ipld.ReprKind_String)
+					Require(t, nr.Kind(), ShouldEqual, ipld.Kind_String)
 					Wish(t, must.String(nr), ShouldEqual, "v1-v2:v3-v4")
 				})
 			})
diff --git a/schema/gen/go/testStructReprTuple_test.go b/schema/gen/go/testStructReprTuple_test.go
index e7202516..93a4fd7f 100644
--- a/schema/gen/go/testStructReprTuple_test.go
+++ b/schema/gen/go/testStructReprTuple_test.go
@@ -49,13 +49,13 @@ func TestStructReprTuple(t *testing.T) {
 					ma.AssembleEntry("field").AssignString("valoo")
 				}).(schema.TypedNode)
 				t.Run("typed-read", func(t *testing.T) {
-					Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+					Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 					Wish(t, n.Length(), ShouldEqual, int64(1))
 					Wish(t, must.String(must.Node(n.LookupByString("field"))), ShouldEqual, "valoo")
 				})
 				t.Run("repr-read", func(t *testing.T) {
 					nr := n.Representation()
-					Require(t, nr.ReprKind(), ShouldEqual, ipld.ReprKind_List)
+					Require(t, nr.Kind(), ShouldEqual, ipld.Kind_List)
 					Wish(t, nr.Length(), ShouldEqual, int64(1))
 					Wish(t, must.String(must.Node(nr.LookupByIndex(0))), ShouldEqual, "valoo")
 				})
@@ -80,7 +80,7 @@ func TestStructReprTuple(t *testing.T) {
 					ma.AssembleEntry("qux").AssignString("3")
 				}).(schema.TypedNode)
 				t.Run("typed-read", func(t *testing.T) {
-					Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+					Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 					Wish(t, n.Length(), ShouldEqual, int64(4))
 					Wish(t, must.String(must.Node(n.LookupByString("foo"))), ShouldEqual, "0")
 					Wish(t, must.String(must.Node(n.LookupByString("bar"))), ShouldEqual, "1")
@@ -89,7 +89,7 @@ func TestStructReprTuple(t *testing.T) {
 				})
 				t.Run("repr-read", func(t *testing.T) {
 					nr := n.Representation()
-					Require(t, nr.ReprKind(), ShouldEqual, ipld.ReprKind_List)
+					Require(t, nr.Kind(), ShouldEqual, ipld.Kind_List)
 					Wish(t, nr.Length(), ShouldEqual, int64(4))
 					Wish(t, must.String(must.Node(nr.LookupByIndex(0))), ShouldEqual, "0")
 					Wish(t, must.String(must.Node(nr.LookupByIndex(1))), ShouldEqual, "1")
@@ -118,7 +118,7 @@ func TestStructReprTuple(t *testing.T) {
 					ma.AssembleEntry("bar").AssignNull()
 				}).(schema.TypedNode)
 				t.Run("typed-read", func(t *testing.T) {
-					Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+					Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 					Wish(t, n.Length(), ShouldEqual, int64(4))
 					Wish(t, must.String(must.Node(n.LookupByString("foo"))), ShouldEqual, "0")
 					Wish(t, must.Node(n.LookupByString("bar")), ShouldEqual, ipld.Null)
@@ -127,7 +127,7 @@ func TestStructReprTuple(t *testing.T) {
 				})
 				t.Run("repr-read", func(t *testing.T) {
 					nr := n.Representation()
-					Require(t, nr.ReprKind(), ShouldEqual, ipld.ReprKind_List)
+					Require(t, nr.Kind(), ShouldEqual, ipld.Kind_List)
 					Wish(t, nr.Length(), ShouldEqual, int64(2))
 					Wish(t, must.String(must.Node(nr.LookupByIndex(0))), ShouldEqual, "0")
 					Wish(t, must.Node(nr.LookupByIndex(1)), ShouldEqual, ipld.Null)
diff --git a/schema/gen/go/testStruct_test.go b/schema/gen/go/testStruct_test.go
index c1782d74..996e3b05 100644
--- a/schema/gen/go/testStruct_test.go
+++ b/schema/gen/go/testStruct_test.go
@@ -112,18 +112,18 @@ func TestStructNesting(t *testing.T) {
 				})
 			}).(schema.TypedNode)
 			t.Run("typed-read", func(t *testing.T) {
-				Require(t, n.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+				Require(t, n.Kind(), ShouldEqual, ipld.Kind_Map)
 				Wish(t, n.Length(), ShouldEqual, int64(1))
 				n2 := must.Node(n.LookupByString("x"))
-				Require(t, n2.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+				Require(t, n2.Kind(), ShouldEqual, ipld.Kind_Map)
 				Wish(t, must.String(must.Node(n2.LookupByString("s"))), ShouldEqual, "woo")
 			})
 			t.Run("repr-read", func(t *testing.T) {
 				nr := n.Representation()
-				Require(t, nr.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+				Require(t, nr.Kind(), ShouldEqual, ipld.Kind_Map)
 				Wish(t, nr.Length(), ShouldEqual, int64(1))
 				n2 := must.Node(nr.LookupByString("r"))
-				Require(t, n2.ReprKind(), ShouldEqual, ipld.ReprKind_Map)
+				Require(t, n2.Kind(), ShouldEqual, ipld.Kind_Map)
 				Wish(t, must.String(must.Node(n2.LookupByString("q"))), ShouldEqual, "woo")
 			})
 		})
diff --git a/schema/gen/go/testStructsContainingMaybe_test.go b/schema/gen/go/testStructsContainingMaybe_test.go
index 47555078..5444bbdf 100644
--- a/schema/gen/go/testStructsContainingMaybe_test.go
+++ b/schema/gen/go/testStructsContainingMaybe_test.go
@@ -53,7 +53,7 @@ func TestStructsContainingMaybe(t *testing.T) {
 			typeJson: `{"f1":"a","f2":"b","f3":"c","f4":"d","f5":"e"}`,
 			reprJson: `{"r1":"a","r2":"b","r3":"c","r4":"d","f5":"e"}`,
 			typePoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				{"f1", "a"},
 				{"f2", "b"},
 				{"f3", "c"},
@@ -61,7 +61,7 @@ func TestStructsContainingMaybe(t *testing.T) {
 				{"f5", "e"},
 			},
 			reprPoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				{"r1", "a"},
 				{"r2", "b"},
 				{"r3", "c"},
@@ -74,7 +74,7 @@ func TestStructsContainingMaybe(t *testing.T) {
 			typeJson: `{"f1":"a","f2":"b","f3":null,"f4":null,"f5":"e"}`,
 			reprJson: `{"r1":"a","r2":"b","r3":null,"r4":null,"f5":"e"}`,
 			typePoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				{"f1", "a"},
 				{"f2", "b"},
 				{"f3", ipld.Null},
@@ -82,7 +82,7 @@ func TestStructsContainingMaybe(t *testing.T) {
 				{"f5", "e"},
 			},
 			reprPoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				{"r1", "a"},
 				{"r2", "b"},
 				{"r3", ipld.Null},
@@ -95,7 +95,7 @@ func TestStructsContainingMaybe(t *testing.T) {
 			typeJson: `{"f1":"a","f3":"c","f5":"e"}`,
 			reprJson: `{"r1":"a","r3":"c","f5":"e"}`,
 			typePoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				{"f1", "a"},
 				{"f2", ipld.Absent},
 				{"f3", "c"},
@@ -103,7 +103,7 @@ func TestStructsContainingMaybe(t *testing.T) {
 				{"f5", "e"},
 			},
 			reprPoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				{"r1", "a"},
 				//{"r2", ipld.ErrNotExists{}}, // TODO: need better error typing from traversal package.
 				{"r3", "c"},
@@ -123,7 +123,7 @@ func TestStructsContainingMaybe(t *testing.T) {
 			typeJson: `{"f1":"a","f2":"b","f3":null}`,
 			reprJson: `{"r1":"a","r2":"b","r3":null}`,
 			typePoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				{"f1", "a"},
 				{"f2", "b"},
 				{"f3", ipld.Null},
@@ -131,7 +131,7 @@ func TestStructsContainingMaybe(t *testing.T) {
 				{"f5", ipld.Absent},
 			},
 			reprPoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				{"r1", "a"},
 				{"r2", "b"},
 				{"r3", ipld.Null},
diff --git a/schema/gen/go/testUnionsKinded_test.go b/schema/gen/go/testUnionsKinded_test.go
index d7415fb4..600a6bf2 100644
--- a/schema/gen/go/testUnionsKinded_test.go
+++ b/schema/gen/go/testUnionsKinded_test.go
@@ -27,9 +27,9 @@ func TestUnionKinded(t *testing.T) {
 			"String",
 			"SmolStruct",
 		},
-		schema.SpawnUnionRepresentationKinded(map[ipld.ReprKind]schema.TypeName{
-			ipld.ReprKind_String: "String",
-			ipld.ReprKind_Map:    "SmolStruct",
+		schema.SpawnUnionRepresentationKinded(map[ipld.Kind]schema.TypeName{
+			ipld.Kind_String: "String",
+			ipld.Kind_Map:    "SmolStruct",
 		}),
 	))
 
@@ -41,12 +41,12 @@ func TestUnionKinded(t *testing.T) {
 			typeJson: `{"String":"whee"}`,
 			reprJson: `"whee"`,
 			typePoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				{"String", "whee"},
 				//{"SmolStruct", ipld.ErrNotExists{}}, // TODO: need better error typing from traversal package.
 			},
 			reprPoints: []testcasePoint{
-				{"", ipld.ReprKind_String},
+				{"", ipld.Kind_String},
 				{"", "whee"},
 			},
 		},
@@ -55,13 +55,13 @@ func TestUnionKinded(t *testing.T) {
 			typeJson: `{"SmolStruct":{"s":"whee"}}`,
 			reprJson: `{"q":"whee"}`,
 			typePoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				//{"String", ipld.ErrNotExists{}}, // TODO: need better error typing from traversal package.
-				{"SmolStruct", ipld.ReprKind_Map},
+				{"SmolStruct", ipld.Kind_Map},
 				{"SmolStruct/s", "whee"},
 			},
 			reprPoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				{"q", "whee"},
 			},
 		},
diff --git a/schema/gen/go/testUnions_test.go b/schema/gen/go/testUnions_test.go
index f28015de..e798bf77 100644
--- a/schema/gen/go/testUnions_test.go
+++ b/schema/gen/go/testUnions_test.go
@@ -32,12 +32,12 @@ func TestUnionKeyed(t *testing.T) {
 			typeJson: `{"String":"whee"}`,
 			reprJson: `{"a":"whee"}`,
 			typePoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				{"String", "whee"},
 				//{"Strung", ipld.ErrNotExists{}}, // TODO: need better error typing from traversal package.
 			},
 			reprPoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				{"a", "whee"},
 				//{"b", ipld.ErrNotExists{}}, // TODO: need better error typing from traversal package.
 			},
@@ -47,12 +47,12 @@ func TestUnionKeyed(t *testing.T) {
 			typeJson: `{"Strung":"whee"}`,
 			reprJson: `{"b":"whee"}`,
 			typePoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				//{"String", ipld.ErrNotExists{}}, // TODO: need better error typing from traversal package.
 				{"Strung", "whee"},
 			},
 			reprPoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				//{"a", ipld.ErrNotExists{}}, // TODO: need better error typing from traversal package.
 				{"b", "whee"},
 			},
@@ -126,12 +126,12 @@ func TestUnionKeyedComplexChildren(t *testing.T) {
 			typeJson: `{"String":"whee"}`,
 			reprJson: `{"a":"whee"}`,
 			typePoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				{"String", "whee"},
 				//{"SmolStruct", ipld.ErrNotExists{}}, // TODO: need better error typing from traversal package.
 			},
 			reprPoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				{"a", "whee"},
 				//{"b", ipld.ErrNotExists{}}, // TODO: need better error typing from traversal package.
 			},
@@ -141,15 +141,15 @@ func TestUnionKeyedComplexChildren(t *testing.T) {
 			typeJson: `{"SmolStruct":{"s":"whee"}}`,
 			reprJson: `{"b":{"q":"whee"}}`,
 			typePoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				//{"String", ipld.ErrNotExists{}}, // TODO: need better error typing from traversal package.
-				{"SmolStruct", ipld.ReprKind_Map},
+				{"SmolStruct", ipld.Kind_Map},
 				{"SmolStruct/s", "whee"},
 			},
 			reprPoints: []testcasePoint{
-				{"", ipld.ReprKind_Map},
+				{"", ipld.Kind_Map},
 				//{"a", ipld.ErrNotExists{}}, // TODO: need better error typing from traversal package.
-				{"b", ipld.ReprKind_Map},
+				{"b", ipld.Kind_Map},
 				{"b/q", "whee"},
 			},
 		},
diff --git a/schema/gen/go/testcase_test.go b/schema/gen/go/testcase_test.go
index 0d98e2b4..5911e4c5 100644
--- a/schema/gen/go/testcase_test.go
+++ b/schema/gen/go/testcase_test.go
@@ -237,7 +237,7 @@ func wishPoint(t *testing.T, n ipld.Node, point testcasePoint) {
 //
 // If the expected value is a primitive string, it'll AsStrong on the Node; etc.
 //
-// Using an ipld.ReprKind value is also possible, which will just check the kind and not the value contents.
+// Using an ipld.Kind value is also possible, which will just check the kind and not the value contents.
 //
 // If an ipld.Node is the expected value, a full deep ShouldEqual is used as normal.
 func closeEnough(actual, expected interface{}) (string, bool) {
@@ -249,17 +249,17 @@ func closeEnough(actual, expected interface{}) (string, bool) {
 		return "this checker only supports checking ipld.Node values", false
 	}
 	switch expected.(type) {
-	case ipld.ReprKind:
-		return ShouldEqual(a.ReprKind(), expected)
+	case ipld.Kind:
+		return ShouldEqual(a.Kind(), expected)
 	case string:
-		if a.ReprKind() != ipld.ReprKind_String {
-			return fmt.Sprintf("expected something with kind string, got kind %s", a.ReprKind()), false
+		if a.Kind() != ipld.Kind_String {
+			return fmt.Sprintf("expected something with kind string, got kind %s", a.Kind()), false
 		}
 		x, _ := a.AsString()
 		return ShouldEqual(x, expected)
 	case int:
-		if a.ReprKind() != ipld.ReprKind_Int {
-			return fmt.Sprintf("expected something with kind int, got kind %s", a.ReprKind()), false
+		if a.Kind() != ipld.Kind_Int {
+			return fmt.Sprintf("expected something with kind int, got kind %s", a.Kind()), false
 		}
 		x, _ := a.AsInt()
 		return ShouldEqual(x, expected)
diff --git a/schema/kind.go b/schema/kind.go
index 604a82d2..10c30e02 100644
--- a/schema/kind.go
+++ b/schema/kind.go
@@ -4,66 +4,66 @@ import (
 	ipld "github.com/ipld/go-ipld-prime"
 )
 
-// Kind is an enum of kind in the IPLD Schema system.
+// TypeKind is an enum of kind in the IPLD Schema system.
 //
-// Note that schema.Kind is distinct from ipld.ReprKind!
+// Note that schema.TypeKind is distinct from ipld.Kind!
 // Schema kinds include concepts such as "struct" and "enum", which are
 // concepts only introduced by the Schema layer, and not present in the
 // Data Model layer.
-type Kind uint8
+type TypeKind uint8
 
 const (
-	Kind_Invalid Kind = 0
-	Kind_Map     Kind = '{'
-	Kind_List    Kind = '['
-	Kind_Unit    Kind = '1'
-	Kind_Bool    Kind = 'b'
-	Kind_Int     Kind = 'i'
-	Kind_Float   Kind = 'f'
-	Kind_String  Kind = 's'
-	Kind_Bytes   Kind = 'x'
-	Kind_Link    Kind = '/'
-	Kind_Struct  Kind = '$'
-	Kind_Union   Kind = '^'
-	Kind_Enum    Kind = '%'
-	// FUTURE: Kind_Any = '?'?
+	TypeKind_Invalid TypeKind = 0
+	TypeKind_Map     TypeKind = '{'
+	TypeKind_List    TypeKind = '['
+	TypeKind_Unit    TypeKind = '1'
+	TypeKind_Bool    TypeKind = 'b'
+	TypeKind_Int     TypeKind = 'i'
+	TypeKind_Float   TypeKind = 'f'
+	TypeKind_String  TypeKind = 's'
+	TypeKind_Bytes   TypeKind = 'x'
+	TypeKind_Link    TypeKind = '/'
+	TypeKind_Struct  TypeKind = '$'
+	TypeKind_Union   TypeKind = '^'
+	TypeKind_Enum    TypeKind = '%'
+	// FUTURE: TypeKind_Any = '?'?
 )
 
-func (k Kind) String() string {
+func (k TypeKind) String() string {
 	switch k {
-	case Kind_Invalid:
+	case TypeKind_Invalid:
 		return "Invalid"
-	case Kind_Map:
+	case TypeKind_Map:
 		return "Map"
-	case Kind_List:
+	case TypeKind_List:
 		return "List"
-	case Kind_Unit:
+	case TypeKind_Unit:
 		return "Unit"
-	case Kind_Bool:
+	case TypeKind_Bool:
 		return "Bool"
-	case Kind_Int:
+	case TypeKind_Int:
 		return "Int"
-	case Kind_Float:
+	case TypeKind_Float:
 		return "Float"
-	case Kind_String:
+	case TypeKind_String:
 		return "String"
-	case Kind_Bytes:
+	case TypeKind_Bytes:
 		return "Bytes"
-	case Kind_Link:
+	case TypeKind_Link:
 		return "Link"
-	case Kind_Struct:
+	case TypeKind_Struct:
 		return "Struct"
-	case Kind_Union:
+	case TypeKind_Union:
 		return "Union"
-	case Kind_Enum:
+	case TypeKind_Enum:
 		return "Enum"
 	default:
 		panic("invalid enumeration value!")
 	}
 }
 
-// ActsLike returns a constant from the ipld.ReprKind enum describing what
-// this schema.Kind acts like at the Data Model layer.
+// ActsLike returns a constant from the ipld.Kind enum describing what
+// this schema.TypeKind acts like at the Data Model layer.
 //
 // Things with similar names are generally conserved
 // (e.g. "map" acts like "map");
@@ -74,34 +74,34 @@ func (k Kind) String() string {
 // it does not necessarily describe how it will be *serialized*
 // (for example, a struct will always act like a map, even if it has a tuple
 // representation strategy and thus becomes a list when serialized).
-func (k Kind) ActsLike() ipld.ReprKind {
+func (k TypeKind) ActsLike() ipld.Kind {
 	switch k {
-	case Kind_Invalid:
-		return ipld.ReprKind_Invalid
-	case Kind_Map:
-		return ipld.ReprKind_Map
-	case Kind_List:
-		return ipld.ReprKind_List
-	case Kind_Unit:
-		return ipld.ReprKind_Bool // maps to 'true'.
-	case Kind_Bool:
-		return ipld.ReprKind_Bool
-	case Kind_Int:
-		return ipld.ReprKind_Int
-	case Kind_Float:
-		return ipld.ReprKind_Float
-	case Kind_String:
-		return ipld.ReprKind_String
-	case Kind_Bytes:
-		return ipld.ReprKind_Bytes
-	case Kind_Link:
-		return ipld.ReprKind_Link
-	case Kind_Struct:
-		return ipld.ReprKind_Map // clear enough: fields are keys.
-	case Kind_Union:
-		return ipld.ReprKind_Map // REVIEW: unions are tricky.
-	case Kind_Enum:
-		return ipld.ReprKind_String // 'AsString' is the one clear thing to define.
+	case TypeKind_Invalid:
+		return ipld.Kind_Invalid
+	case TypeKind_Map:
+		return ipld.Kind_Map
+	case TypeKind_List:
+		return ipld.Kind_List
+	case TypeKind_Unit:
+		return ipld.Kind_Bool // maps to 'true'.
+	case TypeKind_Bool:
+		return ipld.Kind_Bool
+	case TypeKind_Int:
+		return ipld.Kind_Int
+	case TypeKind_Float:
+		return ipld.Kind_Float
+	case TypeKind_String:
+		return ipld.Kind_String
+	case TypeKind_Bytes:
+		return ipld.Kind_Bytes
+	case TypeKind_Link:
+		return ipld.Kind_Link
+	case TypeKind_Struct:
+		return ipld.Kind_Map // clear enough: fields are keys.
+	case TypeKind_Union:
+		return ipld.Kind_Map // REVIEW: unions are tricky.
+	case TypeKind_Enum:
+		return ipld.Kind_String // 'AsString' is the one clear thing to define.
 	default:
 		panic("invalid enumeration value!")
 	}
diff --git a/schema/schema2/kind.go b/schema/schema2/kind.go
index 604a82d2..10c30e02 100644
--- a/schema/schema2/kind.go
+++ b/schema/schema2/kind.go
@@ -4,66 +4,66 @@ import (
 	ipld "github.com/ipld/go-ipld-prime"
 )
 
-// Kind is an enum of kind in the IPLD Schema system.
+// TypeKind is an enum of kind in the IPLD Schema system.
 //
-// Note that schema.Kind is distinct from ipld.ReprKind!
+// Note that schema.TypeKind is distinct from ipld.Kind!
 // Schema kinds include concepts such as "struct" and "enum", which are
 // concepts only introduced by the Schema layer, and not present in the
 // Data Model layer.
-type Kind uint8
+type TypeKind uint8
 
 const (
-	Kind_Invalid Kind = 0
-	Kind_Map     Kind = '{'
-	Kind_List    Kind = '['
-	Kind_Unit    Kind = '1'
-	Kind_Bool    Kind = 'b'
-	Kind_Int     Kind = 'i'
-	Kind_Float   Kind = 'f'
-	Kind_String  Kind = 's'
-	Kind_Bytes   Kind = 'x'
-	Kind_Link    Kind = '/'
-	Kind_Struct  Kind = '$'
-	Kind_Union   Kind = '^'
-	Kind_Enum    Kind = '%'
-	// FUTURE: Kind_Any = '?'?
+	TypeKind_Invalid TypeKind = 0
+	TypeKind_Map     TypeKind = '{'
+	TypeKind_List    TypeKind = '['
+	TypeKind_Unit    TypeKind = '1'
+	TypeKind_Bool    TypeKind = 'b'
+	TypeKind_Int     TypeKind = 'i'
+	TypeKind_Float   TypeKind = 'f'
+	TypeKind_String  TypeKind = 's'
+	TypeKind_Bytes   TypeKind = 'x'
+	TypeKind_Link    TypeKind = '/'
+	TypeKind_Struct  TypeKind = '$'
+	TypeKind_Union   TypeKind = '^'
+	TypeKind_Enum    TypeKind = '%'
+	// FUTURE: TypeKind_Any = '?'?
 )
 
-func (k Kind) String() string {
+func (k TypeKind) String() string {
 	switch k {
-	case Kind_Invalid:
+	case TypeKind_Invalid:
 		return "Invalid"
-	case Kind_Map:
+	case TypeKind_Map:
 		return "Map"
-	case Kind_List:
+	case TypeKind_List:
 		return "List"
-	case Kind_Unit:
+	case TypeKind_Unit:
 		return "Unit"
-	case Kind_Bool:
+	case TypeKind_Bool:
 		return "Bool"
-	case Kind_Int:
+	case TypeKind_Int:
 		return "Int"
-	case Kind_Float:
+	case TypeKind_Float:
 		return "Float"
-	case Kind_String:
+	case TypeKind_String:
 		return "String"
-	case Kind_Bytes:
+	case TypeKind_Bytes:
 		return "Bytes"
-	case Kind_Link:
+	case TypeKind_Link:
 		return "Link"
-	case Kind_Struct:
+	case TypeKind_Struct:
 		return "Struct"
-	case Kind_Union:
+	case TypeKind_Union:
 		return "Union"
-	case Kind_Enum:
+	case TypeKind_Enum:
 		return "Enum"
 	default:
 		panic("invalid enumeration value!")
 	}
 }
 
-// ActsLike returns a constant from the ipld.ReprKind enum describing what
-// this schema.Kind acts like at the Data Model layer.
+// ActsLike returns a constant from the ipld.Kind enum describing what
+// this schema.TypeKind acts like at the Data Model layer.
 //
 // Things with similar names are generally conserved
 // (e.g. "map" acts like "map");
@@ -74,34 +74,34 @@ func (k Kind) String() string {
 // it does not necessarily describe how it will be *serialized*
 // (for example, a struct will always act like a map, even if it has a tuple
 // representation strategy and thus becomes a list when serialized).
-func (k Kind) ActsLike() ipld.ReprKind {
+func (k TypeKind) ActsLike() ipld.Kind {
 	switch k {
-	case Kind_Invalid:
-		return ipld.ReprKind_Invalid
-	case Kind_Map:
-		return ipld.ReprKind_Map
-	case Kind_List:
-		return ipld.ReprKind_List
-	case Kind_Unit:
-		return ipld.ReprKind_Bool // maps to 'true'.
-	case Kind_Bool:
-		return ipld.ReprKind_Bool
-	case Kind_Int:
-		return ipld.ReprKind_Int
-	case Kind_Float:
-		return ipld.ReprKind_Float
-	case Kind_String:
-		return ipld.ReprKind_String
-	case Kind_Bytes:
-		return ipld.ReprKind_Bytes
-	case Kind_Link:
-		return ipld.ReprKind_Link
-	case Kind_Struct:
-		return ipld.ReprKind_Map // clear enough: fields are keys.
-	case Kind_Union:
-		return ipld.ReprKind_Map // REVIEW: unions are tricky.
-	case Kind_Enum:
-		return ipld.ReprKind_String // 'AsString' is the one clear thing to define.
+	case TypeKind_Invalid:
+		return ipld.Kind_Invalid
+	case TypeKind_Map:
+		return ipld.Kind_Map
+	case TypeKind_List:
+		return ipld.Kind_List
+	case TypeKind_Unit:
+		return ipld.Kind_Bool // maps to 'true'.
+	case TypeKind_Bool:
+		return ipld.Kind_Bool
+	case TypeKind_Int:
+		return ipld.Kind_Int
+	case TypeKind_Float:
+		return ipld.Kind_Float
+	case TypeKind_String:
+		return ipld.Kind_String
+	case TypeKind_Bytes:
+		return ipld.Kind_Bytes
+	case TypeKind_Link:
+		return ipld.Kind_Link
+	case TypeKind_Struct:
+		return ipld.Kind_Map // clear enough: fields are keys.
+	case TypeKind_Union:
+		return ipld.Kind_Map // REVIEW: unions are tricky.
+	case TypeKind_Enum:
+		return ipld.Kind_String // 'AsString' is the one clear thing to define.
 	default:
 		panic("invalid enumeration value!")
 	}
diff --git a/schema/schema2/type.go b/schema/schema2/type.go
index d875820d..32c4cdd0 100644
--- a/schema/schema2/type.go
+++ b/schema/schema2/type.go
@@ -50,24 +50,24 @@ type Type interface {
 	// that string will not be required to be unique.
 	Name() TypeName
 
-	// Returns the Kind of this Type.
+	// Returns the TypeKind of this Type.
 	//
 	// The returned value is a 1:1 association with which of the concrete
 	// "schema.Type*" structs this interface can be cast to.
 	//
-	// Note that a schema.Kind is a different enum than ipld.ReprKind;
+	// Note that a schema.TypeKind is a different enum than ipld.Kind;
 	// and furthermore, there's no strict relationship between them.
-	// schema.TypedNode values can be described by *two* distinct ReprKinds:
+	// schema.TypedNode values can be described by *two* distinct Kinds:
 	// one which describes how the Node itself will act,
 	// and another which describes how the Node presents for serialization.
 	// For some combinations of Type and representation strategy, one or both
-	// of the ReprKinds can be determined statically; but not always:
+	// of the Kinds can be determined statically; but not always:
 	// it can sometimes be necessary to inspect the value quite concretely
-	// (e.g., `schema.TypedNode{}.Representation().ReprKind()`) in order to find
+	// (e.g., `schema.TypedNode{}.Representation().Kind()`) in order to find
 	// out exactly how a node will be serialized!  This is because some types
 	// can vary in representation kind based on their value (specifically,
 	// kinded-representation unions have this property).
-	Kind() Kind
+	TypeKind() TypeKind
 
 	// RepresentationBehavior returns a description of how the representation
 	// of this type will behave in terms of the IPLD Data Model.
@@ -81,7 +81,7 @@ type Type interface {
 	// (It follows that a kinded union cannot have another kinded union as a member.)
 	//
 	// You may also be interested in a related property that might have been called "TypeBehavior".
-	// However, this method doesn't exist, because it's a deterministic property of `Kind()`!
-	// You can use `Kind.ActsLike()` to get type-level behavioral information.
-	RepresentationBehavior() ipld.ReprKind
+	// However, this method doesn't exist, because it's a deterministic property of `TypeKind()`!
+	// You can use `TypeKind.ActsLike()` to get type-level behavioral information.
+	RepresentationBehavior() ipld.Kind
 }
diff --git a/schema/schema2/type_bool.go b/schema/schema2/type_bool.go
index d7aab732..8d6edaef 100644
--- a/schema/schema2/type_bool.go
+++ b/schema/schema2/type_bool.go
@@ -21,14 +21,14 @@ func (t *TypeBool) TypeSystem() *TypeSystem {
 	return t.ts
 }
 
-func (TypeBool) Kind() Kind {
-	return Kind_Bool
+func (TypeBool) TypeKind() TypeKind {
+	return TypeKind_Bool
 }
 
 func (t *TypeBool) Name() TypeName {
 	return t.name
 }
 
-func (t TypeBool) RepresentationBehavior() ipld.ReprKind {
-	return ipld.ReprKind_Bool
+func (t TypeBool) RepresentationBehavior() ipld.Kind {
+	return ipld.Kind_Bool
 }
diff --git a/schema/schema2/type_bytes.go b/schema/schema2/type_bytes.go
index 60d18423..8ec4b97f 100644
--- a/schema/schema2/type_bytes.go
+++ b/schema/schema2/type_bytes.go
@@ -21,14 +21,14 @@ func (t *TypeBytes) TypeSystem() *TypeSystem {
 	return t.ts
 }
 
-func (TypeBytes) Kind() Kind {
-	return Kind_Bytes
+func (TypeBytes) TypeKind() TypeKind {
+	return TypeKind_Bytes
 }
 
 func (t *TypeBytes) Name() TypeName {
 	return t.name
 }
 
-func (t TypeBytes) RepresentationBehavior() ipld.ReprKind {
-	return ipld.ReprKind_Bytes
+func (t TypeBytes) RepresentationBehavior() ipld.Kind {
+	return ipld.Kind_Bytes
 }
diff --git a/schema/schema2/type_enum.go b/schema/schema2/type_enum.go
index 05e07b0d..671f04c6 100644
--- a/schema/schema2/type_enum.go
+++ b/schema/schema2/type_enum.go
@@ -33,20 +33,20 @@ func (t *TypeEnum) TypeSystem() *TypeSystem {
 	return t.ts
 }
 
-func (TypeEnum) Kind() Kind {
-	return Kind_Struct
+func (TypeEnum) TypeKind() TypeKind {
+	return TypeKind_Struct
 }
 
 func (t *TypeEnum) Name() TypeName {
 	return t.name
 }
 
-func (t TypeEnum) RepresentationBehavior() ipld.ReprKind {
+func (t TypeEnum) RepresentationBehavior() ipld.Kind {
 	switch t.dmt.FieldRepresentation().AsInterface().(type) {
 	case schemadmt.EnumRepresentation_String:
-		return ipld.ReprKind_String
+		return ipld.Kind_String
 	case schemadmt.EnumRepresentation_Int:
-		return ipld.ReprKind_Int
+		return ipld.Kind_Int
 	default:
 		panic("unreachable")
 	}
diff --git a/schema/schema2/type_float.go b/schema/schema2/type_float.go
index 3f7a49ab..ab0039a7 100644
--- a/schema/schema2/type_float.go
+++ b/schema/schema2/type_float.go
@@ -21,14 +21,14 @@ func (t *TypeFloat) TypeSystem() *TypeSystem {
 	return t.ts
 }
 
-func (TypeFloat) Kind() Kind {
-	return Kind_Float
+func (TypeFloat) TypeKind() TypeKind {
+	return TypeKind_Float
 }
 
 func (t *TypeFloat) Name() TypeName {
 	return t.name
 }
 
-func (t TypeFloat) RepresentationBehavior() ipld.ReprKind {
-	return ipld.ReprKind_Float
+func (t TypeFloat) RepresentationBehavior() ipld.Kind {
+	return ipld.Kind_Float
 }
diff --git a/schema/schema2/type_int.go b/schema/schema2/type_int.go
index 92e08e54..a322ebb5 100644
--- a/schema/schema2/type_int.go
+++ b/schema/schema2/type_int.go
@@ -21,14 +21,14 @@ func (t *TypeInt) TypeSystem() *TypeSystem {
 	return t.ts
 }
 
-func (TypeInt) Kind() Kind {
-	return Kind_Int
+func (TypeInt) TypeKind() TypeKind {
+	return TypeKind_Int
 }
 
 func (t *TypeInt) Name() TypeName {
 	return t.name
 }
 
-func (t TypeInt) RepresentationBehavior() ipld.ReprKind {
-	return ipld.ReprKind_Int
+func (t TypeInt) RepresentationBehavior() ipld.Kind {
+	return ipld.Kind_Int
 }
diff --git a/schema/schema2/type_link.go b/schema/schema2/type_link.go
index 327fb122..1359aee5 100644
--- a/schema/schema2/type_link.go
+++ b/schema/schema2/type_link.go
@@ -21,16 +21,16 @@ func (t *TypeLink) TypeSystem() *TypeSystem {
 	return t.ts
 }
 
-func (TypeLink) Kind() Kind {
-	return Kind_Link
+func (TypeLink) TypeKind() TypeKind {
+	return TypeKind_Link
 }
 
 func (t *TypeLink) Name() TypeName {
 	return t.name
 }
 
-func (t TypeLink) RepresentationBehavior() ipld.ReprKind {
-	return ipld.ReprKind_Link
+func (t TypeLink) RepresentationBehavior() ipld.Kind {
+	return ipld.Kind_Link
 }
 
 // -- specific to TypeLink -->
diff --git a/schema/schema2/type_list.go b/schema/schema2/type_list.go
index f3ac1ef6..b2cabd9f 100644
--- a/schema/schema2/type_list.go
+++ b/schema/schema2/type_list.go
@@ -21,16 +21,16 @@ func (t *TypeList) TypeSystem() *TypeSystem {
 	return t.ts
 }
 
-func (TypeList) Kind() Kind {
-	return Kind_Map
+func (TypeList) TypeKind() TypeKind {
+	return TypeKind_Map
 }
 
 func (t *TypeList) Name() TypeName {
 	return t.name
 }
 
-func (t TypeList) RepresentationBehavior() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (t TypeList) RepresentationBehavior() ipld.Kind {
+	return ipld.Kind_Map
 }
 
 // -- specific to TypeList -->
diff --git a/schema/schema2/type_map.go b/schema/schema2/type_map.go
index 869d6057..462afe4c 100644
--- a/schema/schema2/type_map.go
+++ b/schema/schema2/type_map.go
@@ -21,16 +21,16 @@ func (t *TypeMap) TypeSystem() *TypeSystem {
 	return t.ts
 }
 
-func (TypeMap) Kind() Kind {
-	return Kind_Map
+func (TypeMap) TypeKind() TypeKind {
+	return TypeKind_Map
 }
 
 func (t *TypeMap) Name() TypeName {
 	return t.name
 }
 
-func (t TypeMap) RepresentationBehavior() ipld.ReprKind {
-	return ipld.ReprKind_Map
+func (t TypeMap) RepresentationBehavior() ipld.Kind {
+	return ipld.Kind_Map
 }
 
 // -- specific to TypeMap -->
diff --git a/schema/schema2/type_string.go b/schema/schema2/type_string.go
index b5fe1f58..860c9c5d 100644
--- a/schema/schema2/type_string.go
+++ b/schema/schema2/type_string.go
@@ -21,14 +21,14 @@ func (t *TypeString) TypeSystem() *TypeSystem {
 	return t.ts
 }
 
-func (TypeString) Kind() Kind {
-	return Kind_String
+func (TypeString) TypeKind() TypeKind {
+	return TypeKind_String
 }
 
 func (t *TypeString) Name() TypeName {
 	return t.name
 }
 
-func (t TypeString) RepresentationBehavior() ipld.ReprKind {
-	return ipld.ReprKind_String
+func (t TypeString) RepresentationBehavior() ipld.Kind {
+	return ipld.Kind_String
 }
diff --git a/schema/schema2/type_struct.go b/schema/schema2/type_struct.go
index 858d4ebf..06bebb9f 100644
--- a/schema/schema2/type_struct.go
+++ b/schema/schema2/type_struct.go
@@ -54,26 +54,26 @@ func (t *TypeStruct) TypeSystem() *TypeSystem {
 	return t.ts
 }
 
-func (TypeStruct) Kind() Kind {
-	return Kind_Struct
+func (TypeStruct) TypeKind() TypeKind {
+	return TypeKind_Struct
 }
 
 func (t *TypeStruct) Name() TypeName {
 	return t.name
 }
 
-func (t TypeStruct) RepresentationBehavior() ipld.ReprKind {
+func (t TypeStruct) RepresentationBehavior() ipld.Kind {
 	switch t.dmt.FieldRepresentation().AsInterface().(type) {
 	case schemadmt.StructRepresentation_Map:
-		return ipld.ReprKind_Map
+		return ipld.Kind_Map
 	case schemadmt.StructRepresentation_Tuple:
-		return ipld.ReprKind_List
+		return ipld.Kind_List
 	case schemadmt.StructRepresentation_Stringpairs:
-		return ipld.ReprKind_String
+		return ipld.Kind_String
 	case schemadmt.StructRepresentation_Stringjoin:
-		return ipld.ReprKind_String
+		return ipld.Kind_String
 	case schemadmt.StructRepresentation_Listpairs:
-		return ipld.ReprKind_List
+		return ipld.Kind_List
 	default:
 		panic("unreachable")
 	}
diff --git a/schema/schema2/type_union.go b/schema/schema2/type_union.go
index bdd04dc8..7716a854 100644
--- a/schema/schema2/type_union.go
+++ b/schema/schema2/type_union.go
@@ -55,28 +55,28 @@ func (t *TypeUnion) TypeSystem() *TypeSystem {
 	return t.ts
 }
 
-func (TypeUnion) Kind() Kind {
-	return Kind_Union
+func (TypeUnion) TypeKind() TypeKind {
+	return TypeKind_Union
 }
 
 func (t *TypeUnion) Name() TypeName {
 	return t.name
 }
 
-func (t TypeUnion) RepresentationBehavior() ipld.ReprKind {
+func (t TypeUnion) RepresentationBehavior() ipld.Kind {
 	switch t.dmt.FieldRepresentation().AsInterface().(type) {
 	case schemadmt.UnionRepresentation_Keyed:
-		return ipld.ReprKind_Map
+		return ipld.Kind_Map
 	case schemadmt.UnionRepresentation_Kinded:
-		return ipld.ReprKind_Invalid // you can't know with this one, until you see the value (and thus can see its inhabitant's behavior)!
+		return ipld.Kind_Invalid // you can't know with this one, until you see the value (and thus can see its inhabitant's behavior)!
 	case schemadmt.UnionRepresentation_Envelope:
-		return ipld.ReprKind_Map
+		return ipld.Kind_Map
 	case schemadmt.UnionRepresentation_Inline:
-		return ipld.ReprKind_Map
+		return ipld.Kind_Map
 	case schemadmt.UnionRepresentation_StringPrefix:
-		return ipld.ReprKind_String
+		return ipld.Kind_String
 	case schemadmt.UnionRepresentation_BytePrefix:
-		return ipld.ReprKind_Bytes
+		return ipld.Kind_Bytes
 	default:
 		panic("unreachable")
 	}
@@ -120,7 +120,7 @@ func (r UnionRepresentation_Keyed) GetDiscriminantForType(t Type) string {
 
 // GetMember returns type info for the member matching the kind argument,
 // or may return nil if that kind is not mapped to a member of this union.
-func (r UnionRepresentation_Kinded) GetMember(k ipld.ReprKind) Type {
+func (r UnionRepresentation_Kinded) GetMember(k ipld.Kind) Type {
 	rkdmt, _ := schemadmt.Type.RepresentationKind.FromString(k.String()) // FUTURE: this is currently awkward because we used a string where we should use an enum; this can be fixed when codegen for enums is implemented.
 	tn := r.dmt.Lookup(rkdmt)
 	if tn == nil {
diff --git a/schema/schema2/typesystem.go b/schema/schema2/typesystem.go
index 99587331..3ec0bf8d 100644
--- a/schema/schema2/typesystem.go
+++ b/schema/schema2/typesystem.go
@@ -160,7 +160,7 @@ func BuildTypeSystem(schdmt schemadmt.Schema) (*TypeSystem, []error) {
 					//  We create these temporary things rather than looking in the typesystem map we're accumulating because it makes the process work correctly regardless of order.
 					//  For some of the kinds, this is fairly overkill (we know that the representation behavior of a bool type is bool because it doesn't have any other representation strategies!)
 					//   but I've ground the whole thing out in a consistent way anyway.
-					var mkind ipld.ReprKind
+					var mkind ipld.Kind
 					switch t3 := typesdmt.Lookup(v).AsInterface().(type) {
 					case schemadmt.TypeBool:
 						mkind = TypeBool{dmt: t3}.RepresentationBehavior()
@@ -179,7 +179,7 @@ func BuildTypeSystem(schdmt schemadmt.Schema) (*TypeSystem, []error) {
 					case schemadmt.TypeLink:
 						mkind = TypeLink{dmt: t3}.RepresentationBehavior()
 					case schemadmt.TypeUnion:
-						mkind = TypeUnion{dmt: t3}.RepresentationBehavior() // this actually flies!  it will yield ReprKind_Invalid for a kinded union, though, which we'll treat with a special error message.
+						mkind = TypeUnion{dmt: t3}.RepresentationBehavior() // this actually flies!  it will yield Kind_Invalid for a kinded union, though, which we'll treat with a special error message.
 					case schemadmt.TypeStruct:
 						mkind = TypeStruct{dmt: t3}.RepresentationBehavior()
 					case schemadmt.TypeEnum:
@@ -190,7 +190,7 @@ func BuildTypeSystem(schdmt schemadmt.Schema) (*TypeSystem, []error) {
 						panic("unreachable")
 					}
 					// TODO RepresentationKind is supposed to be an enum, but is not presently generated as such.  This block's use of `k` as a string should turn into something cleaner when enum gen is implemented and used for RepresentationKind.
-					if mkind == ipld.ReprKind_Invalid {
+					if mkind == ipld.Kind_Invalid {
 						ee = append(ee, fmt.Errorf("kinded union %s declares a %s kind should be received as type %s, which is not sensible because that type is also a kinded union", tn, k, v))
 					} else if k.String() != mkind.String() {
 						ee = append(ee, fmt.Errorf("kinded union %s declares a %s kind should be received as type %s, but that type's representation kind is %s", tn, k, v, mkind))
@@ -207,7 +207,7 @@ func BuildTypeSystem(schdmt schemadmt.Schema) (*TypeSystem, []error) {
 					_, v := itr.Next()
 					// As with the switch above which handles kinded union members, we go for the full destructuring here.
 					//  It's slightly overkill considering that most of the type kinds will flatly error in practice, but consistency is nice.
-					var mkind ipld.ReprKind
+					var mkind ipld.Kind
 					switch t3 := typesdmt.Lookup(v).AsInterface().(type) {
 					case schemadmt.TypeBool:
 						mkind = TypeBool{dmt: t3}.RepresentationBehavior()
@@ -240,7 +240,7 @@ func BuildTypeSystem(schdmt schemadmt.Schema) (*TypeSystem, []error) {
 					case schemadmt.TypeStruct:
 						// Check representation strategy first.  Still has to be mappy.
 						t4 := TypeStruct{dmt: t3}
-						if t4.RepresentationBehavior() != ipld.ReprKind_Map {
+						if t4.RepresentationBehavior() != ipld.Kind_Map {
 							goto kindcheck // it'll fail, of course, but this goto DRY's the error message.
 						}
 
@@ -267,7 +267,7 @@ func BuildTypeSystem(schdmt schemadmt.Schema) (*TypeSystem, []error) {
 						panic("unreachable")
 					}
 				kindcheck:
-					if mkind != ipld.ReprKind_Map {
+					if mkind != ipld.Kind_Map {
 						ee = append(ee, fmt.Errorf("union %s has representation strategy inline, which requires all members have map representations, so %s (which has representation kind %s) is not a valid member", tn, v, mkind))
 					}
 				}
diff --git a/schema/schema2/typesystem_test.go b/schema/schema2/typesystem_test.go
index 5411a71d..5546d19a 100644
--- a/schema/schema2/typesystem_test.go
+++ b/schema/schema2/typesystem_test.go
@@ -27,7 +27,7 @@ func TestBuildTypeSystem(t *testing.T) {
 			nil,
 		)
 		Wish(t, ts.types["Woop"], ShouldBeSameTypeAs, &TypeString{})
-		Wish(t, ts.types["Woop"].Kind(), ShouldEqual, Kind_String)
+		Wish(t, ts.types["Woop"].TypeKind(), ShouldEqual, TypeKind_String)
 	})
 	t.Run("MissingTypeInList", func(t *testing.T) {
 		testParse(t,
@@ -96,7 +96,7 @@ func TestBuildTypeSystem(t *testing.T) {
 			nil,
 		)
 		Wish(t, ts.types["SomeMap"], ShouldBeSameTypeAs, &TypeMap{})
-		Wish(t, ts.types["SomeMap"].Kind(), ShouldEqual, Kind_Map)
+		Wish(t, ts.types["SomeMap"].TypeKind(), ShouldEqual, TypeKind_Map)
 		Wish(t, ts.types["SomeMap"].(*TypeMap).KeyType().Name().String(), ShouldEqual, "String")
 	})
 	t.Run("ComplexValidMapKeyType", func(t *testing.T) {
@@ -143,7 +143,7 @@ func TestBuildTypeSystem(t *testing.T) {
 			nil,
 		)
 		Wish(t, ts.types["SomeMap"], ShouldBeSameTypeAs, &TypeMap{})
-		Wish(t, ts.types["SomeMap"].Kind(), ShouldEqual, Kind_Map)
+		Wish(t, ts.types["SomeMap"].TypeKind(), ShouldEqual, TypeKind_Map)
 		Wish(t, ts.types["SomeMap"].(*TypeMap).KeyType().Name().String(), ShouldEqual, "StringyStruct")
 	})
 	t.Run("InvalidMapKeyType", func(t *testing.T) {
diff --git a/schema/tmpBuilders.go b/schema/tmpBuilders.go
index 3b93599a..690a7a2a 100644
--- a/schema/tmpBuilders.go
+++ b/schema/tmpBuilders.go
@@ -104,7 +104,7 @@ func SpawnUnion(name TypeName, members []TypeName, repr UnionRepresentation) *Ty
 func SpawnUnionRepresentationKeyed(table map[string]TypeName) UnionRepresentation_Keyed {
 	return UnionRepresentation_Keyed{table}
 }
-func SpawnUnionRepresentationKinded(table map[ipld.ReprKind]TypeName) UnionRepresentation_Kinded {
+func SpawnUnionRepresentationKinded(table map[ipld.Kind]TypeName) UnionRepresentation_Kinded {
 	return UnionRepresentation_Kinded{table}
 }
 
diff --git a/schema/type.go b/schema/type.go
index 2d47163d..c776bef2 100644
--- a/schema/type.go
+++ b/schema/type.go
@@ -55,24 +55,24 @@ type Type interface {
 	// that string will not be required to be unique.
 	Name() TypeName
 
-	// Returns the Kind of this Type.
+	// Returns the TypeKind of this Type.
 	//
 	// The returned value is a 1:1 association with which of the concrete
 	// "schema.Type*" structs this interface can be cast to.
 	//
-	// Note that a schema.Kind is a different enum than ipld.ReprKind;
+	// Note that a schema.TypeKind is a different enum than ipld.Kind;
 	// and furthermore, there's no strict relationship between them.
-	// schema.TypedNode values can be described by *two* distinct ReprKinds:
+	// schema.TypedNode values can be described by *two* distinct Kinds:
 	// one which describes how the Node itself will act,
 	// and another which describes how the Node presents for serialization.
 	// For some combinations of Type and representation strategy, one or both
-	// of the ReprKinds can be determined statically; but not always:
+	// of the Kinds can be determined statically; but not always:
 	// it can sometimes be necessary to inspect the value quite concretely
-	// (e.g., `schema.TypedNode{}.Representation().ReprKind()`) in order to find
+	// (e.g., `schema.TypedNode{}.Representation().Kind()`) in order to find
 	// out exactly how a node will be serialized!  This is because some types
 	// can vary in representation kind based on their value (specifically,
 	// kinded-representation unions have this property).
-	Kind() Kind
+	TypeKind() TypeKind
 
 	// RepresentationBehavior returns a description of how the representation
 	// of this type will behave in terms of the IPLD Data Model.
@@ -86,9 +86,9 @@ type Type interface {
 	// (It follows that a kinded union cannot have another kinded union as a member.)
 	//
 	// You may also be interested in a related property that might have been called "TypeBehavior".
-	// However, this method doesn't exist, because it's a deterministic property of `Kind()`!
-	// You can use `Kind.ActsLike()` to get type-level behavioral information.
-	RepresentationBehavior() ipld.ReprKind
+	// However, this method doesn't exist, because it's a deterministic property of `TypeKind()`!
+	// You can use `TypeKind.ActsLike()` to get type-level behavioral information.
+	RepresentationBehavior() ipld.Kind
 }
 
 var (
@@ -133,7 +133,7 @@ type TypeFloat struct {
 type TypeMap struct {
 	typeBase
 	anonymous     bool
-	keyType       TypeName // must be ReprKind==string (e.g. Type==String|Enum).
+	keyType       TypeName // must be Kind==string (e.g. Type==String|Enum).
 	valueType     TypeName
 	valueNullable bool
 }
@@ -179,7 +179,7 @@ type UnionRepresentation_Keyed struct {
 	table map[string]TypeName // key is user-defined freetext
 }
 type UnionRepresentation_Kinded struct {
-	table map[ipld.ReprKind]TypeName
+	table map[ipld.Kind]TypeName
 }
 type UnionRepresentation_Envelope struct {
 	discriminantKey string
diff --git a/schema/typeMethods.go b/schema/typeMethods.go
index ba82484a..300c9195 100644
--- a/schema/typeMethods.go
+++ b/schema/typeMethods.go
@@ -12,57 +12,57 @@ func (t *typeBase) _Type(ts *TypeSystem) {
 func (t typeBase) TypeSystem() *TypeSystem { return t.universe }
 func (t typeBase) Name() TypeName          { return t.name }
 
-func (TypeBool) Kind() Kind   { return Kind_Bool }
-func (TypeString) Kind() Kind { return Kind_String }
-func (TypeBytes) Kind() Kind  { return Kind_Bytes }
-func (TypeInt) Kind() Kind    { return Kind_Int }
-func (TypeFloat) Kind() Kind  { return Kind_Float }
-func (TypeMap) Kind() Kind    { return Kind_Map }
-func (TypeList) Kind() Kind   { return Kind_List }
-func (TypeLink) Kind() Kind   { return Kind_Link }
-func (TypeUnion) Kind() Kind  { return Kind_Union }
-func (TypeStruct) Kind() Kind { return Kind_Struct }
-func (TypeEnum) Kind() Kind   { return Kind_Enum }
-
-func (TypeBool) RepresentationBehavior() ipld.ReprKind   { return ipld.ReprKind_Bool }
-func (TypeString) RepresentationBehavior() ipld.ReprKind { return ipld.ReprKind_String }
-func (TypeBytes) RepresentationBehavior() ipld.ReprKind  { return ipld.ReprKind_Bytes }
-func (TypeInt) RepresentationBehavior() ipld.ReprKind    { return ipld.ReprKind_Int }
-func (TypeFloat) RepresentationBehavior() ipld.ReprKind  { return ipld.ReprKind_Float }
-func (TypeMap) RepresentationBehavior() ipld.ReprKind    { return ipld.ReprKind_Map }
-func (TypeList) RepresentationBehavior() ipld.ReprKind   { return ipld.ReprKind_List }
-func (TypeLink) RepresentationBehavior() ipld.ReprKind   { return ipld.ReprKind_Link }
-func (t TypeUnion) RepresentationBehavior() ipld.ReprKind {
+func (TypeBool) TypeKind() TypeKind   { return TypeKind_Bool }
+func (TypeString) TypeKind() TypeKind { return TypeKind_String }
+func (TypeBytes) TypeKind() TypeKind  { return TypeKind_Bytes }
+func (TypeInt) TypeKind() TypeKind    { return TypeKind_Int }
+func (TypeFloat) TypeKind() TypeKind  { return TypeKind_Float }
+func (TypeMap) TypeKind() TypeKind    { return TypeKind_Map }
+func (TypeList) TypeKind() TypeKind   { return TypeKind_List }
+func (TypeLink) TypeKind() TypeKind   { return TypeKind_Link }
+func (TypeUnion) TypeKind() TypeKind  { return TypeKind_Union }
+func (TypeStruct) TypeKind() TypeKind { return TypeKind_Struct }
+func (TypeEnum) TypeKind() TypeKind   { return TypeKind_Enum }
+
+func (TypeBool) RepresentationBehavior() ipld.Kind   { return ipld.Kind_Bool }
+func (TypeString) RepresentationBehavior() ipld.Kind { return ipld.Kind_String }
+func (TypeBytes) RepresentationBehavior() ipld.Kind  { return ipld.Kind_Bytes }
+func (TypeInt) RepresentationBehavior() ipld.Kind    { return ipld.Kind_Int }
+func (TypeFloat) RepresentationBehavior() ipld.Kind  { return ipld.Kind_Float }
+func (TypeMap) RepresentationBehavior() ipld.Kind    { return ipld.Kind_Map }
+func (TypeList) RepresentationBehavior() ipld.Kind   { return ipld.Kind_List }
+func (TypeLink) RepresentationBehavior() ipld.Kind   { return ipld.Kind_Link }
+func (t TypeUnion) RepresentationBehavior() ipld.Kind {
 	switch t.representation.(type) {
 	case UnionRepresentation_Keyed:
-		return ipld.ReprKind_Map
+		return ipld.Kind_Map
 	case UnionRepresentation_Kinded:
-		return ipld.ReprKind_Invalid // you can't know with this one, until you see the value (and thus can its inhabitant's behavior)!
+		return ipld.Kind_Invalid // you can't know with this one, until you see the value (and thus can its inhabitant's behavior)!
 	case UnionRepresentation_Envelope:
-		return ipld.ReprKind_Map
+		return ipld.Kind_Map
 	case UnionRepresentation_Inline:
-		return ipld.ReprKind_Map
+		return ipld.Kind_Map
 	default:
 		panic("unreachable")
 	}
 }
-func (t TypeStruct) RepresentationBehavior() ipld.ReprKind {
+func (t TypeStruct) RepresentationBehavior() ipld.Kind {
 	switch t.representation.(type) {
 	case StructRepresentation_Map:
-		return ipld.ReprKind_Map
+		return ipld.Kind_Map
 	case StructRepresentation_Tuple:
-		return ipld.ReprKind_List
+		return ipld.Kind_List
 	case StructRepresentation_StringPairs:
-		return ipld.ReprKind_String
+		return ipld.Kind_String
 	case StructRepresentation_Stringjoin:
-		return ipld.ReprKind_String
+		return ipld.Kind_String
 	default:
 		panic("unreachable")
 	}
 }
-func (t TypeEnum) RepresentationBehavior() ipld.ReprKind {
+func (t TypeEnum) RepresentationBehavior() ipld.Kind {
 	// TODO: this should have a representation strategy switch too; sometimes that will indicate int representation behavior.
-	return ipld.ReprKind_String
+	return ipld.Kind_String
 }
 
 /* interesting methods per Type type */
@@ -150,7 +150,7 @@ func (r UnionRepresentation_Keyed) GetDiscriminant(t Type) string {
 
 // GetMember returns type info for the member matching the kind argument,
 // or may return nil if that kind is not mapped to a member of this union.
-func (r UnionRepresentation_Kinded) GetMember(k ipld.ReprKind) TypeName {
+func (r UnionRepresentation_Kinded) GetMember(k ipld.Kind) TypeName {
 	return r.table[k]
 }
 
diff --git a/schema/typedNode.go b/schema/typedNode.go
index 3ae60ebc..bb276424 100644
--- a/schema/typedNode.go
+++ b/schema/typedNode.go
@@ -6,9 +6,9 @@ import (
 
 // schema.TypedNode is a superset of the ipld.Node interface, and has additional behaviors.
 //
-// A schema.TypedNode can be inspected for its schema.Type and schema.Kind,
+// A schema.TypedNode can be inspected for its schema.Type and schema.TypeKind,
 // which conveys much more and richer information than the Data Model layer
-// ipld.ReprKind.
+// ipld.Kind.
 //
 // There are many different implementations of schema.TypedNode.
 // One implementation can wrap any other existing ipld.Node (i.e., it's zero-copy)
@@ -28,13 +28,13 @@ import (
 // return ErrNotExists, because the representation isn't a schema.TypedNode!
 type TypedNode interface {
 	// schema.TypedNode acts just like a regular Node for almost all purposes;
-	// which ipld.ReprKind it acts as is determined by the TypeKind.
+	// which ipld.Kind it acts as is determined by the TypeKind.
 	// (Note that the representation strategy of the type does *not* affect
-	// the ReprKind of schema.TypedNode -- rather, the representation strategy
-	// affects the `.Representation().ReprKind()`.)
+	// the Kind of schema.TypedNode -- rather, the representation strategy
+	// affects the `.Representation().Kind()`.)
 	//
-	// For example: if the `.Type().Kind()` of this node is "struct",
-	// it will act like ReprKind() == "map"
+	// For example: if the `.Type().TypeKind()` of this node is "struct",
+	// it will act like Kind() == "map"
 	// (even if Type().(Struct).ReprStrategy() is "tuple").
 	ipld.Node
 
@@ -44,10 +44,10 @@ type TypedNode interface {
 	// Representation returns an ipld.Node which sees the data in this node
 	// in its representation form.
 	//
-	// For example: if the `.Type().Kind()` of this node is "struct",
-	// `.Representation().Kind()` may vary based on its representation strategy:
-	// if the representation strategy is "map", then it will be ReprKind=="map";
-	// if the streatgy is "tuple", then it will be ReprKind=="list".
+	// For example: if the `.Type().TypeKind()` of this node is "struct",
+	// `.Representation().TypeKind()` may vary based on its representation strategy:
+	// if the representation strategy is "map", then it will be Kind=="map";
+	// if the streatgy is "tuple", then it will be Kind=="list".
 	Representation() ipld.Node
 }
 
diff --git a/traversal/focus.go b/traversal/focus.go
index 27c6d04c..e8480b6f 100644
--- a/traversal/focus.go
+++ b/traversal/focus.go
@@ -87,16 +87,16 @@ func (prog *Progress) get(n ipld.Node, p ipld.Path, trackProgress bool) (ipld.No
 	var prev ipld.Node // for LinkContext
 	for i, seg := range segments {
 		// Traverse the segment.
-		switch n.ReprKind() {
-		case ipld.ReprKind_Invalid:
+		switch n.Kind() {
+		case ipld.Kind_Invalid:
 			panic(fmt.Errorf("invalid node encountered at %q", p.Truncate(i)))
-		case ipld.ReprKind_Map:
+		case ipld.Kind_Map:
 			next, err := n.LookupByString(seg.String())
 			if err != nil {
 				return nil, fmt.Errorf("error traversing segment %q on node at %q: %s", seg, p.Truncate(i), err)
 			}
 			prev, n = n, next
-		case ipld.ReprKind_List:
+		case ipld.Kind_List:
 			intSeg, err := seg.Index()
 			if err != nil {
 				return nil, fmt.Errorf("error traversing segment %q on node at %q: the segment cannot be parsed as a number and the node is a list", seg, p.Truncate(i))
@@ -110,7 +110,7 @@ func (prog *Progress) get(n ipld.Node, p ipld.Path, trackProgress bool) (ipld.No
 			return nil, fmt.Errorf("cannot traverse node at %q: %s", p.Truncate(i), fmt.Errorf("cannot traverse terminals"))
 		}
 		// Dereference any links.
-		for n.ReprKind() == ipld.ReprKind_Link {
+		for n.Kind() == ipld.Kind_Link {
 			lnk, _ := n.AsLink()
 			// Assemble the LinkContext in case the Loader or NBChooser want it.
 			lnkCtx := ipld.LinkContext{
diff --git a/traversal/select_links.go b/traversal/select_links.go
index 7dd40ce4..1e1dd932 100644
--- a/traversal/select_links.go
+++ b/traversal/select_links.go
@@ -29,8 +29,8 @@ func SelectLinks(n ipld.Node) ([]ipld.Link, error) {
 }
 
 func accumulateLinks(a *[]ipld.Link, n ipld.Node) error {
-	switch n.ReprKind() {
-	case ipld.ReprKind_Map:
+	switch n.Kind() {
+	case ipld.Kind_Map:
 		for itr := n.MapIterator(); !itr.Done(); {
 			_, v, err := itr.Next()
 			if err != nil {
@@ -38,7 +38,7 @@ func accumulateLinks(a *[]ipld.Link, n ipld.Node) error {
 			}
 			accumulateLinks(a, v)
 		}
-	case ipld.ReprKind_List:
+	case ipld.Kind_List:
 		for itr := n.ListIterator(); !itr.Done(); {
 			_, v, err := itr.Next()
 			if err != nil {
@@ -46,7 +46,7 @@ func accumulateLinks(a *[]ipld.Link, n ipld.Node) error {
 			}
 			accumulateLinks(a, v)
 		}
-	case ipld.ReprKind_Link:
+	case ipld.Kind_Link:
 		lnk, _ := n.AsLink()
 		*a = append(*a, lnk)
 	}
diff --git a/traversal/selector/exploreAll.go b/traversal/selector/exploreAll.go
index eb8647a1..55cb0ea5 100644
--- a/traversal/selector/exploreAll.go
+++ b/traversal/selector/exploreAll.go
@@ -29,7 +29,7 @@ func (s ExploreAll) Decide(n ipld.Node) bool {
 
 // ParseExploreAll assembles a Selector from a ExploreAll selector node
 func (pc ParseContext) ParseExploreAll(n ipld.Node) (Selector, error) {
-	if n.ReprKind() != ipld.ReprKind_Map {
+	if n.Kind() != ipld.Kind_Map {
 		return nil, fmt.Errorf("selector spec parse rejected: selector body must be a map")
 	}
 	next, err := n.LookupByString(SelectorKey_Next)
diff --git a/traversal/selector/exploreFields.go b/traversal/selector/exploreFields.go
index f5579c7c..1705734a 100644
--- a/traversal/selector/exploreFields.go
+++ b/traversal/selector/exploreFields.go
@@ -41,14 +41,14 @@ func (s ExploreFields) Decide(n ipld.Node) bool {
 // ParseExploreFields assembles a Selector
 // from a ExploreFields selector node
 func (pc ParseContext) ParseExploreFields(n ipld.Node) (Selector, error) {
-	if n.ReprKind() != ipld.ReprKind_Map {
+	if n.Kind() != ipld.Kind_Map {
 		return nil, fmt.Errorf("selector spec parse rejected: selector body must be a map")
 	}
 	fields, err := n.LookupByString(SelectorKey_Fields)
 	if err != nil {
 		return nil, fmt.Errorf("selector spec parse rejected: fields in ExploreFields selector must be present")
 	}
-	if fields.ReprKind() != ipld.ReprKind_Map {
+	if fields.Kind() != ipld.Kind_Map {
 		return nil, fmt.Errorf("selector spec parse rejected: fields in ExploreFields selector must be a map")
 	}
 	x := ExploreFields{
diff --git a/traversal/selector/exploreIndex.go b/traversal/selector/exploreIndex.go
index 3e364324..81b40510 100644
--- a/traversal/selector/exploreIndex.go
+++ b/traversal/selector/exploreIndex.go
@@ -21,7 +21,7 @@ func (s ExploreIndex) Interests() []ipld.PathSegment {
 // Explore returns the node's selector if
 // the path matches the index for this selector or nil if not
 func (s ExploreIndex) Explore(n ipld.Node, p ipld.PathSegment) Selector {
-	if n.ReprKind() != ipld.ReprKind_List {
+	if n.Kind() != ipld.Kind_List {
 		return nil
 	}
 	expectedIndex, expectedErr := p.Index()
@@ -40,7 +40,7 @@ func (s ExploreIndex) Decide(n ipld.Node) bool {
 // ParseExploreIndex assembles a Selector
 // from a ExploreIndex selector node
 func (pc ParseContext) ParseExploreIndex(n ipld.Node) (Selector, error) {
-	if n.ReprKind() != ipld.ReprKind_Map {
+	if n.Kind() != ipld.Kind_Map {
 		return nil, fmt.Errorf("selector spec parse rejected: selector body must be a map")
 	}
 	indexNode, err := n.LookupByString(SelectorKey_Index)
diff --git a/traversal/selector/exploreRange.go b/traversal/selector/exploreRange.go
index 7130d9eb..17e33054 100644
--- a/traversal/selector/exploreRange.go
+++ b/traversal/selector/exploreRange.go
@@ -23,7 +23,7 @@ func (s ExploreRange) Interests() []ipld.PathSegment {
 // Explore returns the node's selector if
 // the path matches an index in the range of this selector
 func (s ExploreRange) Explore(n ipld.Node, p ipld.PathSegment) Selector {
-	if n.ReprKind() != ipld.ReprKind_List {
+	if n.Kind() != ipld.Kind_List {
 		return nil
 	}
 	index, err := p.Index()
@@ -44,7 +44,7 @@ func (s ExploreRange) Decide(n ipld.Node) bool {
 // ParseExploreRange assembles a Selector
 // from a ExploreRange selector node
 func (pc ParseContext) ParseExploreRange(n ipld.Node) (Selector, error) {
-	if n.ReprKind() != ipld.ReprKind_Map {
+	if n.Kind() != ipld.Kind_Map {
 		return nil, fmt.Errorf("selector spec parse rejected: selector body must be a map")
 	}
 	startNode, err := n.LookupByString(SelectorKey_Start)
diff --git a/traversal/selector/exploreRecursive.go b/traversal/selector/exploreRecursive.go
index 3640c3c5..00cf2669 100644
--- a/traversal/selector/exploreRecursive.go
+++ b/traversal/selector/exploreRecursive.go
@@ -168,7 +168,7 @@ func (erc *exploreRecursiveContext) Link(s Selector) bool {
 
 // ParseExploreRecursive assembles a Selector from a ExploreRecursive selector node
 func (pc ParseContext) ParseExploreRecursive(n ipld.Node) (Selector, error) {
-	if n.ReprKind() != ipld.ReprKind_Map {
+	if n.Kind() != ipld.Kind_Map {
 		return nil, fmt.Errorf("selector spec parse rejected: selector body must be a map")
 	}
 
@@ -196,7 +196,7 @@ func (pc ParseContext) ParseExploreRecursive(n ipld.Node) (Selector, error) {
 }
 
 func parseLimit(n ipld.Node) (RecursionLimit, error) {
-	if n.ReprKind() != ipld.ReprKind_Map {
+	if n.Kind() != ipld.Kind_Map {
 		return RecursionLimit{}, fmt.Errorf("selector spec parse rejected: limit in ExploreRecursive is a keyed union and thus must be a map")
 	}
 	if n.Length() != 1 {
diff --git a/traversal/selector/exploreRecursiveEdge.go b/traversal/selector/exploreRecursiveEdge.go
index 2ff62e5e..79eb8ce7 100644
--- a/traversal/selector/exploreRecursiveEdge.go
+++ b/traversal/selector/exploreRecursiveEdge.go
@@ -34,7 +34,7 @@ func (s ExploreRecursiveEdge) Decide(n ipld.Node) bool {
 // ParseExploreRecursiveEdge assembles a Selector
 // from a exploreRecursiveEdge selector node
 func (pc ParseContext) ParseExploreRecursiveEdge(n ipld.Node) (Selector, error) {
-	if n.ReprKind() != ipld.ReprKind_Map {
+	if n.Kind() != ipld.Kind_Map {
 		return nil, fmt.Errorf("selector spec parse rejected: selector body must be a map")
 	}
 	s := ExploreRecursiveEdge{}
diff --git a/traversal/selector/exploreUnion.go b/traversal/selector/exploreUnion.go
index 4261693f..3918fa73 100644
--- a/traversal/selector/exploreUnion.go
+++ b/traversal/selector/exploreUnion.go
@@ -74,7 +74,7 @@ func (s ExploreUnion) Decide(n ipld.Node) bool {
 // ParseExploreUnion assembles a Selector
 // from an ExploreUnion selector node
 func (pc ParseContext) ParseExploreUnion(n ipld.Node) (Selector, error) {
-	if n.ReprKind() != ipld.ReprKind_List {
+	if n.Kind() != ipld.Kind_List {
 		return nil, fmt.Errorf("selector spec parse rejected: explore union selector must be a list")
 	}
 	x := ExploreUnion{
diff --git a/traversal/selector/matcher.go b/traversal/selector/matcher.go
index b2305ef8..3c3aa1e2 100644
--- a/traversal/selector/matcher.go
+++ b/traversal/selector/matcher.go
@@ -39,7 +39,7 @@ func (s Matcher) Decide(n ipld.Node) bool {
 // from a matcher selector node
 // TODO: Parse labels and conditions
 func (pc ParseContext) ParseMatcher(n ipld.Node) (Selector, error) {
-	if n.ReprKind() != ipld.ReprKind_Map {
+	if n.Kind() != ipld.Kind_Map {
 		return nil, fmt.Errorf("selector spec parse rejected: selector body must be a map")
 	}
 	return Matcher{}, nil
diff --git a/traversal/selector/selector.go b/traversal/selector/selector.go
index b410cefa..319c359e 100644
--- a/traversal/selector/selector.go
+++ b/traversal/selector/selector.go
@@ -32,7 +32,7 @@ func ParseSelector(n ipld.Node) (Selector, error) {
 
 // ParseSelector creates a Selector from an IPLD Selector Node with the given context
 func (pc ParseContext) ParseSelector(n ipld.Node) (Selector, error) {
-	if n.ReprKind() != ipld.ReprKind_Map {
+	if n.Kind() != ipld.Kind_Map {
 		return nil, fmt.Errorf("selector spec parse rejected: selector is a keyed union and thus must be a map")
 	}
 	if n.Length() != 1 {
@@ -82,7 +82,7 @@ type SegmentIterator interface {
 
 // NewSegmentIterator generates a new iterator based on the node type
 func NewSegmentIterator(n ipld.Node) SegmentIterator {
-	if n.ReprKind() == ipld.ReprKind_List {
+	if n.Kind() == ipld.Kind_List {
 		return listSegmentIterator{n.ListIterator()}
 	}
 	return mapSegmentIterator{n.MapIterator()}
diff --git a/traversal/walk.go b/traversal/walk.go
index 27ec2174..cd07a7b4 100644
--- a/traversal/walk.go
+++ b/traversal/walk.go
@@ -94,9 +94,9 @@ func (prog Progress) walkAdv(n ipld.Node, s selector.Selector, fn AdvVisitFn) er
 			return err
 		}
 	}
-	nk := n.ReprKind()
+	nk := n.Kind()
 	switch nk {
-	case ipld.ReprKind_Map, ipld.ReprKind_List: // continue
+	case ipld.Kind_Map, ipld.Kind_List: // continue
 	default:
 		return nil
 	}
@@ -118,7 +118,7 @@ func (prog Progress) walkAdv_iterateAll(n ipld.Node, s selector.Selector, fn Adv
 		if sNext != nil {
 			progNext := prog
 			progNext.Path = prog.Path.AppendSegment(ps)
-			if v.ReprKind() == ipld.ReprKind_Link {
+			if v.Kind() == ipld.Kind_Link {
 				lnk, _ := v.AsLink()
 				progNext.LastBlock.Path = progNext.Path
 				progNext.LastBlock.Link = lnk
@@ -150,7 +150,7 @@ func (prog Progress) walkAdv_iterateSelective(n ipld.Node, attn []ipld.PathSegme
 		if sNext != nil {
 			progNext := prog
 			progNext.Path = prog.Path.AppendSegment(ps)
-			if v.ReprKind() == ipld.ReprKind_Link {
+			if v.Kind() == ipld.Kind_Link {
 				lnk, _ := v.AsLink()
 				progNext.LastBlock.Path = progNext.Path
 				progNext.LastBlock.Link = lnk
diff --git a/unit.go b/unit.go
index 94b7d70f..8cc4647f 100644
--- a/unit.go
+++ b/unit.go
@@ -4,20 +4,20 @@ var Null Node = nullNode{}
 
 type nullNode struct{}
 
-func (nullNode) ReprKind() ReprKind {
-	return ReprKind_Null
+func (nullNode) Kind() Kind {
+	return Kind_Null
 }
 func (nullNode) LookupByString(key string) (Node, error) {
-	return nil, ErrWrongKind{TypeName: "null", MethodName: "LookupByString", AppropriateKind: ReprKindSet_JustMap, ActualKind: ReprKind_Null}
+	return nil, ErrWrongKind{TypeName: "null", MethodName: "LookupByString", AppropriateKind: KindSet_JustMap, ActualKind: Kind_Null}
 }
 func (nullNode) LookupByNode(key Node) (Node, error) {
-	return nil, ErrWrongKind{TypeName: "null", MethodName: "LookupByNode", AppropriateKind: ReprKindSet_JustMap, ActualKind: ReprKind_Null}
+	return nil, ErrWrongKind{TypeName: "null", MethodName: "LookupByNode", AppropriateKind: KindSet_JustMap, ActualKind: Kind_Null}
 }
 func (nullNode) LookupByIndex(idx int64) (Node, error) {
-	return nil, ErrWrongKind{TypeName: "null", MethodName: "LookupByIndex", AppropriateKind: ReprKindSet_JustList, ActualKind: ReprKind_Null}
+	return nil, ErrWrongKind{TypeName: "null", MethodName: "LookupByIndex", AppropriateKind: KindSet_JustList, ActualKind: Kind_Null}
 }
 func (nullNode) LookupBySegment(seg PathSegment) (Node, error) {
-	return nil, ErrWrongKind{TypeName: "null", MethodName: "LookupBySegment", AppropriateKind: ReprKindSet_Recursive, ActualKind: ReprKind_Null}
+	return nil, ErrWrongKind{TypeName: "null", MethodName: "LookupBySegment", AppropriateKind: KindSet_Recursive, ActualKind: Kind_Null}
 }
 func (nullNode) MapIterator() MapIterator {
 	return nil
@@ -35,22 +35,22 @@ func (nullNode) IsNull() bool {
 	return true
 }
 func (nullNode) AsBool() (bool, error) {
-	return false, ErrWrongKind{TypeName: "null", MethodName: "AsBool", AppropriateKind: ReprKindSet_JustBool, ActualKind: ReprKind_Null}
+	return false, ErrWrongKind{TypeName: "null", MethodName: "AsBool", AppropriateKind: KindSet_JustBool, ActualKind: Kind_Null}
 }
 func (nullNode) AsInt() (int64, error) {
-	return 0, ErrWrongKind{TypeName: "null", MethodName: "AsInt", AppropriateKind: ReprKindSet_JustInt, ActualKind: ReprKind_Null}
+	return 0, ErrWrongKind{TypeName: "null", MethodName: "AsInt", AppropriateKind: KindSet_JustInt, ActualKind: Kind_Null}
 }
 func (nullNode) AsFloat() (float64, error) {
-	return 0, ErrWrongKind{TypeName: "null", MethodName: "AsFloat", AppropriateKind: ReprKindSet_JustFloat, ActualKind: ReprKind_Null}
+	return 0, ErrWrongKind{TypeName: "null", MethodName: "AsFloat", AppropriateKind: KindSet_JustFloat, ActualKind: Kind_Null}
 }
 func (nullNode) AsString() (string, error) {
-	return "", ErrWrongKind{TypeName: "null", MethodName: "AsString", AppropriateKind: ReprKindSet_JustString, ActualKind: ReprKind_Null}
+	return "", ErrWrongKind{TypeName: "null", MethodName: "AsString", AppropriateKind: KindSet_JustString, ActualKind: Kind_Null}
 }
 func (nullNode) AsBytes() ([]byte, error) {
-	return nil, ErrWrongKind{TypeName: "null", MethodName: "AsBytes", AppropriateKind: ReprKindSet_JustBytes, ActualKind: ReprKind_Null}
+	return nil, ErrWrongKind{TypeName: "null", MethodName: "AsBytes", AppropriateKind: KindSet_JustBytes, ActualKind: Kind_Null}
 }
 func (nullNode) AsLink() (Link, error) {
-	return nil, ErrWrongKind{TypeName: "null", MethodName: "AsLink", AppropriateKind: ReprKindSet_JustLink, ActualKind: ReprKind_Null}
+	return nil, ErrWrongKind{TypeName: "null", MethodName: "AsLink", AppropriateKind: KindSet_JustLink, ActualKind: Kind_Null}
 }
 func (nullNode) Prototype() NodePrototype {
 	return nullPrototype{}
@@ -66,20 +66,20 @@ var Absent Node = absentNode{}
 
 type absentNode struct{}
 
-func (absentNode) ReprKind() ReprKind {
-	return ReprKind_Null
+func (absentNode) Kind() Kind {
+	return Kind_Null
 }
 func (absentNode) LookupByString(key string) (Node, error) {
-	return nil, ErrWrongKind{TypeName: "absent", MethodName: "LookupByString", AppropriateKind: ReprKindSet_JustMap, ActualKind: ReprKind_Null}
+	return nil, ErrWrongKind{TypeName: "absent", MethodName: "LookupByString", AppropriateKind: KindSet_JustMap, ActualKind: Kind_Null}
 }
 func (absentNode) LookupByNode(key Node) (Node, error) {
-	return nil, ErrWrongKind{TypeName: "absent", MethodName: "LookupByNode", AppropriateKind: ReprKindSet_JustMap, ActualKind: ReprKind_Null}
+	return nil, ErrWrongKind{TypeName: "absent", MethodName: "LookupByNode", AppropriateKind: KindSet_JustMap, ActualKind: Kind_Null}
 }
 func (absentNode) LookupByIndex(idx int64) (Node, error) {
-	return nil, ErrWrongKind{TypeName: "absent", MethodName: "LookupByIndex", AppropriateKind: ReprKindSet_JustList, ActualKind: ReprKind_Null}
+	return nil, ErrWrongKind{TypeName: "absent", MethodName: "LookupByIndex", AppropriateKind: KindSet_JustList, ActualKind: Kind_Null}
 }
 func (absentNode) LookupBySegment(seg PathSegment) (Node, error) {
-	return nil, ErrWrongKind{TypeName: "absent", MethodName: "LookupBySegment", AppropriateKind: ReprKindSet_Recursive, ActualKind: ReprKind_Null}
+	return nil, ErrWrongKind{TypeName: "absent", MethodName: "LookupBySegment", AppropriateKind: KindSet_Recursive, ActualKind: Kind_Null}
 }
 func (absentNode) MapIterator() MapIterator {
 	return nil
@@ -97,22 +97,22 @@ func (absentNode) IsNull() bool {
 	return false
 }
 func (absentNode) AsBool() (bool, error) {
-	return false, ErrWrongKind{TypeName: "absent", MethodName: "AsBool", AppropriateKind: ReprKindSet_JustBool, ActualKind: ReprKind_Null}
+	return false, ErrWrongKind{TypeName: "absent", MethodName: "AsBool", AppropriateKind: KindSet_JustBool, ActualKind: Kind_Null}
 }
 func (absentNode) AsInt() (int64, error) {
-	return 0, ErrWrongKind{TypeName: "absent", MethodName: "AsInt", AppropriateKind: ReprKindSet_JustInt, ActualKind: ReprKind_Null}
+	return 0, ErrWrongKind{TypeName: "absent", MethodName: "AsInt", AppropriateKind: KindSet_JustInt, ActualKind: Kind_Null}
 }
 func (absentNode) AsFloat() (float64, error) {
-	return 0, ErrWrongKind{TypeName: "absent", MethodName: "AsFloat", AppropriateKind: ReprKindSet_JustFloat, ActualKind: ReprKind_Null}
+	return 0, ErrWrongKind{TypeName: "absent", MethodName: "AsFloat", AppropriateKind: KindSet_JustFloat, ActualKind: Kind_Null}
 }
 func (absentNode) AsString() (string, error) {
-	return "", ErrWrongKind{TypeName: "absent", MethodName: "AsString", AppropriateKind: ReprKindSet_JustString, ActualKind: ReprKind_Null}
+	return "", ErrWrongKind{TypeName: "absent", MethodName: "AsString", AppropriateKind: KindSet_JustString, ActualKind: Kind_Null}
 }
 func (absentNode) AsBytes() ([]byte, error) {
-	return nil, ErrWrongKind{TypeName: "absent", MethodName: "AsBytes", AppropriateKind: ReprKindSet_JustBytes, ActualKind: ReprKind_Null}
+	return nil, ErrWrongKind{TypeName: "absent", MethodName: "AsBytes", AppropriateKind: KindSet_JustBytes, ActualKind: Kind_Null}
 }
 func (absentNode) AsLink() (Link, error) {
-	return nil, ErrWrongKind{TypeName: "absent", MethodName: "AsLink", AppropriateKind: ReprKindSet_JustLink, ActualKind: ReprKind_Null}
+	return nil, ErrWrongKind{TypeName: "absent", MethodName: "AsLink", AppropriateKind: KindSet_JustLink, ActualKind: Kind_Null}
 }
 func (absentNode) Prototype() NodePrototype {
 	return absentPrototype{}