if ok {
		return t.Val(fields)
	}
	return p.underlyingTypeProvider.NewValue(structType, fields)
}

// NewTypeProviderAndEnvOption creates the TypeProvider with a given TypeResolver,
// and also returns the CEL EnvOption to apply it to the env.
func NewTypeProviderAndEnvOption(resolver common.TypeResolver) (*TypeProvider, cel.EnvOption) {
	tp := &TypeProvider{typeResolver: resolver}

			expression:    "Object{spec: Object.spec{replicas: 3}}",
			expectedValue: map[string]any{"spec": map[string]any{"replicas": int64(3)}},
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			_, option := NewTypeProviderAndEnvOption(&mockTypeResolver{})
			env := mustCreateEnv(t, option)
			ast, issues := env.Compile(tc.expression)
			if issues != nil {
				t.Fatalf("unexpected issues during compilation: %v", issues)
			}

			expression:    "Object{spec: Object.spec{replicas: 3}} == Object{spec: Object.spec{replicas: 1 + 2}}",
			expectedValue: true,
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			_, option := mutation.NewTypeProviderAndEnvOption(&TypeResolver{})
			env := mustCreateEnv(t, option)
			ast, issues := env.Compile(tc.expression)
			if issues != nil {
				t.Fatalf("unexpected issues during compilation: %v", issues)
			}

			// has marco supports only the dot access syntax.
			expression:  `has({"foo": 1}.foo)`,
			expectedVal: celtypes.True,
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			_, option := NewTypeProviderAndEnvOption(&mockTypeResolverForOptional{
				mockTypeResolver: &mockTypeResolver{},
			})
			env := mustCreateEnvWithOptional(t, option)
			ast, issues := env.Compile(tc.expression)
			if issues != nil {