class User : WRPObject

class User : WRPObject {

    // Properties
   var name : String!
   var email : String?
   var userId : Int = 0
   var active : Bool = true
   var createdAt : NSDate!
   var latitude : Double = 0
   var longitude : Double = 0

   // Relationships
   var messages : [Message] = []
}

func propertyMap() -> [WRPProperty] {
     return [
        // Bind remote string "name" to the same local "name", must exist
        WPRProperty(remote: "name", type: .String, optional: false),

        // Bind remote string "email_address" to local "email", optional
        WPRProperty(remote: "email_address", bindTo: "email", type: .String),

        // Bind remote Bool "active" to local "active"
        WPRProperty(remote: "active", type: .Bool),

        // Bind remote NSDate "created_at" to local "createdAt", must exist, specific date format
        WPRProperty(remote: "created_at", bindTo: "createdAt", type: .Date, optional: false, format: "yyyy-MM-dd")
     ]
}

func propertyMap() -> [WRPProperty] {
     return [
         ...
         // When the data for objects are deeper than on first level, you can use dot notation to flatten it:
         // { "_geoloc" : { "lat" : 50, "lon" : 50 }} can be mapped as
         WPRProperty(remote: "_geoloc.lat", bindTo: "latitude", type: .Double),
         WPRProperty(remote: "_geoloc.lon", bindTo: "longitude", type: .Double),

         // Warp can also bind one property from multiple sources,  which is excellent when you have, for example, 
         // multiple databases, each with different key. Specify primary key
         // if there is chance that more of them can show at once and one has priority:
         WPRProperty(remotes: ["id", "objectId", "object_id"], primaryRemote: "objectId", bindTo: "userId", type: .Int),
     ]
}

func relationMap() -> [WRPRelation] {
     return [
        // We create relationship for messages:
        // Bind remote "messages" to local "messages". Each message has property "user",
        // which we mark as the inverse. We can have multiple messages, therefore .ToMany relationship is used. Each message has only one user,
        // therefore .ToOne is used in inverse.
        WPRRelation(remote: "messages", bindTo: "messages", inverseBindTo: "user", modelClass: Message.self, optional: true, relationType: .ToMany, inverseRelationType: .ToOne)
     ]
}

User {
   Configured properties
   messages : [
      message1 : Message,
      message2 : Message,
      message3 : Message
   ]
}

// Fetch data from server using Alamofire, AFNetworking, Moya or any other
Alamofire.request(.GET, "/user", parameters: ["id": "my-user-id"])
         .responseJSON { response in

             if let JSON = response.result.value {
                 // This produces FULLY configured user, including messages
                 // print(user.messages.count) > '3'
                 let user = User(fromJSON: JSON)
             }
         }

// Create user
let user = User(fromDictionary: dict)

// Serialize it back
let dictionary = user.toDictionary()

// Serialize it, but exclude keys that are not interesting.
// Following with exclude messages on serialization
let dictionary = user.toDictionaryWithout(["messages"])

// You can also ONLY include keys that you want to have
let dictionary = user.toDictionaryWith(["email", "name"])

// You can also use WPRSerializationOption.IncludeNullProperties to serialize <null> where optionals are nil