public class MyConfig extends Config {

    public MyConfig() {
        super(Identifier.of(MOD_ID, "my_config"));
    }

    public double bareDouble = 5.0; // A double without validation. It will still have basic type-validation backing it internally.

    public boolean booleanThing = false; // most primitive types and a wide array of other types are supported by background validation. See Validation for details.

    public ValidatedDouble validatedDouble = new ValidatedDouble(5.0, 10.0, 0.0); //this field has defined validation, error correction, and will restrict user inputs to doubles between 0 and 10.

    public MySection mySection = new MySection(); // a section of the config with its own validated fields and other sections as applicable. This will appear in-game as a separate screen "layer" with a breadcrumb leading back to the parent screen.

    public static class MySection extends ConfigSection { // a Config Section. Self-serializable. Of course it doesn't have to be defined inside of it's parent class, but it may be convenient
        public MySection() {
            super();
        }

        public ValidatedBoolean sectionBoolean = ValidatedBoolean(true); //booleans can have defined validation, but it's not really necessary

        public ValidatedIdentifierMap<Double> sectionMap = ValidatedIdentifierMap( //validation exists for common collections too, maps, lists, sets, and so on
            new LinkedHashMap(), //empty default map
            ValidatedIdentifier.ofTag(Registries.ITEM.getId(Items.IRON_AXE), ItemTags.AXES), // the keys in this map can only be from the AXES tag
            new ValidatedDouble(1.0, 1.0, 0.0) //map values are double restricted between 0.0 and 1.0
        );
    }
}

class Configs {
    //instance of your config loaded from file and automatically registered to the SyncedConfigRegistry and ClientConfigRegistry using the getId() method
    //ConfigApiJava can come in handy to avoid pernicious compiler errors depending on your IDE and gradle setup.
    public static MyConfig myConfig = ConfigApiJava.registerAndLoadConfig(MyConfig::new);

    //adding the registerType, you can register a config as client-only. No syncing will occur. Useful for client-only mods.
    public static MyConfig myClientOnlyConfig = ConfigApiJava.registerAndLoadConfig(MyConfig::new, RegisterType.CLIENT);

    //adding the registerType, you can register a config as sync-only. Their won't be any client-side GUI functionality, so the config will only be editable from the file itself, but it will auto-sync with clients.
    public static MyConfig mySyncedOnlyConfig = ConfigApiJava.registerAndLoadConfig(MyConfig::new, RegisterType.SERVER);

    //Init function would be called in ModInitializer or some other entrypoint. Not strictly necessary if loading on-reference is ok.
    public static void init() {}
}

double myConfigDouble = Configs.myConfig.bareDouble; //plain fields are just plain fields. access them like normal!

boolean myConfigSectionValidated = Configs.myConfig.mySection.sectionBoolean.get(); //defined validation wraps your values in a Supplier.