Howto distinguish between not-provided and null when deserializing JSON

We send JSON strings from our front end as input to our java code. The Java side turns that into beans using Gson. Now my front end guy approached me with these requirements:

• sometimes he wants to pass a new value, that the backend simply writes into the database
• sometimes he wants to pass no value, which tells the backend to not do anything about this value
• sometimes he wants to pass a null, which tells the backend to reset to some "default value" (known to the backend, but the front end doesn't care about it)
• it should also work with strings, numbers, boolean, ...

We came up with this idea:

import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;
import java.lang.reflect.Type;
import java.util.Objects;
import org.junit.Test;
import com.google.gson.*;

class ResetableValue<T> {
    private static enum Content {
        VALUE, RESET, NOT_PROVIDED
    };
    private final T value;
    private final Content content;

    public ResetableValue(T value) {
        this(value, Content.VALUE);
    }
    private ResetableValue(T value, Content content) {
        this.value = value;
        this.content = content;
    }
    static <T> ResetableValue<T> asReset() {
        return new ResetableValue<>(null, Content.RESET);
    }
    static <T> ResetableValue<T> asNotProvided() {
        return new ResetableValue<>(null, Content.NOT_PROVIDED);
    }
    T getValue() {
        if (content != Content.VALUE) {
            throw new IllegalStateException("can't provide value for " + content);
        }
        return value;
    }
    boolean isReset() {
        return content == Content.RESET;
    }
    boolean isNotProvided() {
        return content == Content.NOT_PROVIDED;
    }
    @Override
    public String toString() {
        if (content == Content.VALUE) {
            return Objects.toString(value);
        }
        return content.toString();
    }
}

class ResetableValueDeserializer implements JsonDeserializer<ResetableValue<String>> {
    public ResetableValue<String> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
        throws JsonParseException {
        return new ResetableValue<String>(json.getAsJsonPrimitive().getAsString());
    }
}
class ExampleBean {
    private ResetableValue<String> property = ResetableValue.asNotProvided();
    public ResetableValue<String> getProperty() {
        if (property == null) {
            return ResetableValue.asReset();
        }
        return property;
    }
    @Override
    public String toString() {
        return "property: " + Objects.toString(property);
    }
}

public class GsonStuffTest {
    Gson gson = new GsonBuilder().registerTypeAdapter(ResetableValue.class, new ResetableValueDeserializer()).create();

    @Test
    public void testValue() {
        String serializedContent = "{\"property\":\"foo\"}";
        ExampleBean bean = gson.fromJson(serializedContent, ExampleBean.class);
        assertThat(bean.getProperty().getValue(), is("foo"));
    }
    @Test
    public void testIsNotProvided() {
        String serializedContent = "{}";
        ExampleBean bean = gson.fromJson(serializedContent, ExampleBean.class);
        assertThat(bean.getProperty().isNotProvided(), is(true));
    }
    @Test
    public void testIsReset() {
        String serializedContent = "{\"property\":null}";
        ExampleBean bean = gson.fromJson(serializedContent, ExampleBean.class);
        assertThat(bean.getProperty().isReset(), is(true));
    }
}

Please note: the idea is of course to have multiple different fields of that type ResetableValue in a bean. And then one field might care a value, one is omitted, another is set to to null.

Question(s):

• The above example "works" - but I really dislike the fact that I have to handle the "reset" case within the getProperty() method of my bean. As that means: it is not enough to have a custom deserializer, I also need to put that special check into any getter method. So: are there more elegant solutions to this? Is there a way to have Gson distinguish between "a property is not showing up" vs. "a property is set to null"?
• The above example claims to be generic; but obviously the deserializer code only works for string properties. Is there a way to make this "really generic"?

I guess a different way to express my question is: is there something like "Optionals" support when deserializing JSON into beans using Gson?