apache/beam · error

type is of kind %v

Error message

type is of kind %v

What it means

registerType recursively registers composite types (maps, arrays, slices, pointers). When registering a nested component (key or element) fails, the error is wrapped with "type is of kind %v" to indicate which parent kind the recursion came from.

Source

Thrown at sdks/go/pkg/beam/core/runtime/graphx/schema/schema.go:252

			return errors.Wrapf(err, "unable to convert LogicalType[%v] using provider for %v", t, lti)
		}
		if st == nil {
			continue
		}
		r.RegisterLogicalType(ToLogicalType(t.String(), t, st))
		r.addToMaps(st, t)
		return nil
	}

	switch t.Kind() {
	case reflect.Map:
		if err := r.registerType(t.Key(), seen); err != nil {
			return err
		}
		fallthrough
	case reflect.Array, reflect.Slice, reflect.Ptr:
		if err := r.registerType(t.Elem(), seen); err != nil {
			return errors.Wrapf(err, "type is of kind %v", t.Kind())
		}
		return nil
	case reflect.Interface, reflect.Func, reflect.Chan, reflect.Invalid, reflect.UnsafePointer, reflect.Uintptr:
		// Ignore these, as they can't be serialized.
		return nil
	case reflect.Complex64, reflect.Complex128:
		// TODO(BEAM-9615): Support complex number types.
		return nil
	case reflect.Struct: // What we expect here.
	default:
		rt, ok := reflectKindToTypeMap[t.Kind()]
		if !ok {
			// Kind is not listed, meaning it's an unlisted somehow, which means either the map
			// is missing something, or the above switch cases are missing something.
			return errors.Errorf("unlisted kind %v for type %v reached.", t.Kind(), t)
		}
		if t != rt {
			// It's only a logical type if it's not a built in primitive type, which is returned by the map.

View on GitHub (pinned to 12126d8942)

Solutions

1. Follow the wrapped error chain to the innermost cause and fix the child type that actually failed.
2. Register a custom coder for the offending nested type.
3. Simplify or restructure the nested type to schema-supported shapes.

Example fix

// before: failing nested element
type Wrapper struct { Items []*badElem }
// after
schema.RegisterCustomCoder(...) // or fix badElem's registration problem

// Validate nested element types before registration
if bad := firstUnsupported(t.Elem()); bad != nil {
    return fmt.Errorf("nested type %v unsupported", bad)
}

if err != nil {
    if strings.Contains(err.Error(), "type is of kind") {
        // inspect wrapped cause; fix the innermost type
    }
}

When it happens

Trigger: registerType on a map/array/slice/pointer type whose Key() or Elem() type itself fails registration (e.g. element with unsupported kind or bad embedded field).

Common situations: Registering deeply nested types like []*unexportedEmbedded or map[string]badType where the failure is in the child; long wrap chains in the error message show the path of the offending nested type.

Understand the failure class

Background: Schema validation failed / invalid input schema: payload rejected because its shape doesn't match the expected schema — this error's family across 28 libraries.

Related errors

• panicked: %v
• cannot make schema for type %v as it has an embedded field o
• unlisted kind %v for type %v reached.
• unable to convert map value type
• Unable to generate coder for schema {schema}

AI-assisted analysis of apache/beam@12126d8942 (2026-09-13). Data as JSON: /api/errors/c4234c141320ac25. Report an issue: GitHub.