We have been using this technique for more than a year and it works perfectly. We call it "Java Notation Object", hehe and you should understand the limitations, which more or less you are currently fulfilling. Just a few changes...
The most important, yes, you should use @JsType(isNative=true,namespace=GLOBAL,name="Object"), so you are actually ignoring any kind of typing, so this is more a "scheme" of where to find things than an actual typed object. This is pretty important! This is pretty similar to JSON but in Java, and these classes are not actually Java classes, are just a scheme. All these limitations are the common intersection of the feature between Java and JS.
You can do some tricks to use collections but we end up removing all of them and using arrays instead. But, to make it easy to work with, we added some @JsOverlay to return or set the Collection. For example if you have "String[] roles" you can add "@JsOverlay getRoleSet() { return Stream.of(roles).collecto(toSet()); }". Overlays are ok bc there are just like extension method or static method, so no behavior is added to the object.
This work perfectly on both sides, but there is a small annoying difference between GWT and Java, in java new Foo() will initialize primitive types and in GWT (js) will not. So we never use constructor directly, in the kind of classes we always add a static factory method and we initialize any non-nullable field, even primitives! So in java you are actually creating the object of the specified type, but in JS you are just calling "new Object()", but it is ok, bc where are using a scheme, no a type. And we never use instanceof on these schemes! This will work on the Java side, but I strongly discourage, you should not need to do that.
Finally, we never use getter and setter, don't make sense, you "cannot use inheritance" (you can use with some ticks too, for example using some int or string field as the type indicator and using, for example, the visitor pattern to traverse, this is what actually people need to do in JS so, no magic just the common intersection of features between java and json), almost everything is like final and you must not add behavior, so it is much explicit and easier to just make all field public.
I think the first you should do is removing getters and setters, and add @JsType(native,Object) to all your types, this refactor can be done almost instantly in your IDE (inline method). Then stop using Collection might not be so easy to refactor. So you might continue using it either using overlays or creating a custom jsinterop-compatible type. In this case, I recommend to not to use the whole java.util API bc it will force you to export the whole API and use generateJsInteropExports. If you are really interested or need help there just ask, but just try out avoiding maps, and using arrays. Anyways, the "Map/List own interface" should work too, just neet to make it work.