Work with nested attributes

@DynamoDbBean
public class Person {
    Integer id;
    String firstName;
    String lastName;
    Integer age;
    Map<String, Address> addresses;
    List<PhoneNumber> phoneNumbers;

    List<String> hobbies;

    @DynamoDbPartitionKey
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Map<String, Address> getAddresses() {
        return addresses;
    }

    public void setAddresses(Map<String, Address> addresses) {
        this.addresses = addresses;
    }

    public List<PhoneNumber> getPhoneNumbers() {
        return phoneNumbers;
    }

    public void setPhoneNumbers(List<PhoneNumber> phoneNumbers) {
        this.phoneNumbers = phoneNumbers;
    }

    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", age=" + age +
                ", addresses=" + addresses +
                ", phoneNumbers=" + phoneNumbers +
                ", hobbies=" + hobbies +
                '}';
    }
}

@DynamoDbBean
public class Address {
    private String street;
    private String city;
    private String state;
    private String zipCode;

    public Address() {
    }

    public String getStreet() {
        return this.street;
    }

    public String getCity() {
        return this.city;
    }

    public String getState() {
        return this.state;
    }

    public String getZipCode() {
        return this.zipCode;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public void setState(String state) {
        this.state = state;
    }

    public void setZipCode(String zipCode) {
        this.zipCode = zipCode;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Address address = (Address) o;
        return Objects.equals(street, address.street) && Objects.equals(city, address.city) && Objects.equals(state, address.state) && Objects.equals(zipCode, address.zipCode);
    }

    @Override
    public int hashCode() {
        return Objects.hash(street, city, state, zipCode);
    }

    @Override
    public String toString() {
        return "Address{" +
                "street='" + street + '\'' +
                ", city='" + city + '\'' +
                ", state='" + state + '\'' +
                ", zipCode='" + zipCode + '\'' +
                '}';
    }
}

@DynamoDbBean
public class PhoneNumber {
    String type;
    String number;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    @Override
    public String toString() {
        return "PhoneNumber{" +
                "type='" + type + '\'' +
                ", number='" + number + '\'' +
                '}';
    }
}

    // Abstract table schema that cannot be used to work with a DynamoDB table,
    // but can be used as a nested schema.
    public static final TableSchema<Address> TABLE_SCHEMA_ADDRESS = TableSchema.builder(Address.class)
            .newItemSupplier(Address::new)
            .addAttribute(String.class, a -> a.name("street")
                    .getter(Address::getStreet)
                    .setter(Address::setStreet))
            .addAttribute(String.class, a -> a.name("city")
                    .getter(Address::getCity)
                    .setter(Address::setCity))
            .addAttribute(String.class, a -> a.name("zipcode")
                    .getter(Address::getZipCode)
                    .setter(Address::setZipCode))
            .addAttribute(String.class, a -> a.name("state")
                    .getter(Address::getState)
                    .setter(Address::setState))
            .build();

    // Abstract table schema that cannot be used to work with a DynamoDB table,
    // but can be used as a nested schema.
    public static final TableSchema<PhoneNumber> TABLE_SCHEMA_PHONENUMBER = TableSchema.builder(PhoneNumber.class)
            .newItemSupplier(PhoneNumber::new)
            .addAttribute(String.class, a -> a.name("type")
                    .getter(PhoneNumber::getType)
                    .setter(PhoneNumber::setType))
            .addAttribute(String.class, a -> a.name("number")
                    .getter(PhoneNumber::getNumber)
                    .setter(PhoneNumber::setNumber))
            .build();

    // A static table schema that can be used with a DynamoDB table.
    // The table schema contains two nested schemas that are used to perform mapping to/from DynamoDB.
    public static final TableSchema<Person> PERSON_TABLE_SCHEMA =
            TableSchema.builder(Person.class)
                    .newItemSupplier(Person::new)
                    .addAttribute(Integer.class, a -> a.name("id")
                            .getter(Person::getId)
                            .setter(Person::setId)
                            .addTag(StaticAttributeTags.primaryPartitionKey()))
                    .addAttribute(String.class, a -> a.name("firstName")
                            .getter(Person::getFirstName)
                            .setter(Person::setFirstName))
                    .addAttribute(String.class, a -> a.name("lastName")
                            .getter(Person::getLastName)
                            .setter(Person::setLastName))
                    .addAttribute(Integer.class, a -> a.name("age")
                            .getter(Person::getAge)
                            .setter(Person::setAge))
                    .addAttribute(EnhancedType.listOf(String.class), a -> a.name("hobbies")
                            .getter(Person::getHobbies)
                            .setter(Person::setHobbies))
                    .addAttribute(EnhancedType.mapOf(
                            EnhancedType.of(String.class),
                            // 1. Use mapping functionality of the Address table schema.
                            EnhancedType.documentOf(Address.class, TABLE_SCHEMA_ADDRESS)), a -> a.name("addresses")
                            .getter(Person::getAddresses)
                            .setter(Person::setAddresses))
                    .addAttribute(EnhancedType.listOf(
                            // 2. Use mapping functionality of the PhoneNumber table schema.
                            EnhancedType.documentOf(PhoneNumber.class, TABLE_SCHEMA_PHONENUMBER)), a -> a.name("phoneNumbers")
                            .getter(Person::getPhoneNumbers)
                            .setter(Person::setPhoneNumbers))
                    .build();