syms = make(map[string]any, len(md.ptab))
	for _, ptab := range md.ptab {
		symName := resolveNameOff(unsafe.Pointer(md.types), ptab.name)
		t := toRType((*_type)(unsafe.Pointer(md.types))).typeOff(ptab.typ) // TODO can this stack of conversions be simpler?
		var val any
		valp := (*[2]unsafe.Pointer)(unsafe.Pointer(&val))
		(*valp)[0] = unsafe.Pointer(t)

		name := symName.Name()

)

// TypeRef is the implementation of TypeRef for an unstructured object.
// This is especially usefully when the schema is not known or available.
type TypeRef struct {
	celObjectType *types.Type
	celTypeType   *types.Type
}

func (r *TypeRef) HasTrait(trait int) bool {
	return common.ObjectTraits|trait != 0
}

// TypeName returns the name of this TypeRef.
func (r *TypeRef) TypeName() string {

// construction syntax.
type ObjectVal struct {
	typeRef TypeRef
	fields  map[string]ref.Val
}

// NewObjectVal creates an ObjectVal by its TypeRef and its fields.
func NewObjectVal(typeRef TypeRef, fields map[string]ref.Val) *ObjectVal {
	return &ObjectVal{
		typeRef: typeRef,
		fields:  fields,
	}
}

var _ ref.Val = (*ObjectVal)(nil)

struct Types0 {};

// Type lists of length 1, 2, 3, and so on.

template <typename T1>
struct Types1 {
  typedef T1 Head;
  typedef Types0 Tail;
};

$range i 2..n

$for i [[
$range j 1..i
$range k 2..i
template <$for j, [[typename T$j]]>
struct Types$i {
  typedef T1 Head;
  typedef Types$(i-1)<$for k, [[T$k]]> Tail;
};


]]

}  // namespace internal

	if name == "nonExisting" {
		return nil, false
	}
	return m.TypeRef.Field(name)
}

func (m *mockTypeResolverForOptional) Resolve(name string) (common.TypeRef, bool) {
	r, ok := m.mockTypeResolver.Resolve(name)
	if ok {
		return &mockTypeRefForOptional{TypeRef: r}, ok
	}
	return nil, false

		{"func(func(int, int))", reflect.TypeOf(func(func(int, int)) {}), false},
		{"int64", reflect.TypeOf(int64(1)), false},
		{"uint64", reflect.TypeOf(uint64(1)), false},
		{"*[4]int", reflect.TypeOf(&[4]int{}), true},
		{"chan int64", reflect.TypeOf(make(chan int64)), false},
		{"map[int]int", reflect.TypeOf(make(map[int]int)), true},
		{"string", reflect.TypeOf(""), true},
		{"[]int", reflect.TypeOf([]int{}), true},
	}

    @Test
    fun recognizesLambdaType() {
        assertEquals(typeOf<Int>(), customConfigureLambdas.getTypeConfiguredByLambda(typeOf<MyFunctionalInterface<Int>>()))
        assertTrue { customConfigureLambdas.isConfigureLambdaForType(typeOf<Int>(), typeOf<MyFunctionalInterface<Int>>()) }
        assertFalse { customConfigureLambdas.isConfigureLambdaForType(typeOf<String>(), typeOf<MyFunctionalInterface<Int>>()) }
    }

    @Test

	// This function returns false if the name does not refer to a known object type.
	Resolve(name string) (TypeRef, bool)
}

// TypeRef refers an object type that can be looked up for its fields.
type TypeRef interface {
	ref.Type

	// CELType wraps the TypeRef to be a type that is understood by CEL.
	CELType() *types.Type

	// Field finds the field by the field name, or false if the field is not known.

)

const object = common.RootTypeReferenceName

type TypeResolver struct {
}

// Resolve resolves the TypeRef for the given type name
// that starts with "Object".
// This is the unstructured version, which means the
// returned TypeRef does not refer to the schema.
func (r *TypeResolver) Resolve(name string) (common.TypeRef, bool) {
	if !strings.HasPrefix(name, object) {
		return nil, false
	}
	return NewTypeRef(name), true

#include <stdio.h>

#undef nil
#define nil ((void*)0)
#define nelem(x) (sizeof(x)/sizeof((x)[0]))

typedef uint32_t uint32;
typedef uint64_t uint64;
typedef uintptr_t uintptr;

/*
 * The beginning of the per-goroutine structure,
 * as defined in ../pkg/runtime/runtime.h.
 * Just enough to edit these two fields.
 */
typedef struct G G;
struct G
{
	uintptr stacklo;
	uintptr stackhi;
};

/*