         self[name + '_get'] = get_fn.apply self, relation_params
 
         # Create
+        #
         self[name + '_add'] = create_fn.apply self, relation_params
 
         # Update
+        #
         self[name + '_update'] = update_fn.apply self, relation_params
 
         # Destroy
+        #
         self[name + '_destroy'] = destroy_fn.apply self, relation_params
 
     # Set observable fields
+    #
     if options.observable?
       for index, name of options.observable
         Observable self, name
 
     # Set editable fields
+    #
     if options.editable?
       for index, name of options.editable
-        Editable self, name, (value, prop, delay = 250) =>
-          window.timeoutEditor = {} unless window.timeoutEditor?
-          clearTimeout(window.timeoutEditor[prop])
-          window.timeoutEditor[prop] = setTimeout(=>
-            edit_value = {}
-            edit_value[prop] = value
-            self.update edit_value
-          , delay)
+        Editable self, name, DelayedSave.apply(self, [options, self])
+
+    # Encrypted editable fields
+    #
+    if options.encrypted_editable?
+      for index, name of options.encrypted_editable
+        Editable self, name, EncryptedDelayedSave.apply(self, [options, self])
 
     # Set computed fields
+    #
     if options.computed?
       for name, fn of options.computed
         Computed self, name, fn
-
+    if options.purecomputed?
+      for name, fn of options.purecomputed
+        PureComputed self, name, fn
+    if options.computed_array?
+      for name, fn of options.computed_array
+        ComputedArray self, name, fn
+
+    # Add user defined functions
+    #
     if options.functions?
       for name, fn of options.functions
         self[name] = fn
 
-    self.update = (data, callback) =>
-      self.api().update(self.id, data).done callback
-
+    # Update self
+    #
+    self.update = (params, callback) =>
+      unless self.id?
+        console.error 'Trying to update nonexisting model object'
+        return false
+
+      self.api().update(self.id, params).done callback
+
+    # Destroy self
+    #
     self.destroy = (callback) =>
+      unless self.id?
+        console.error 'Trying to delete nonexisting model object'
+        return false
+
       self.api().destroy(self.id).done callback
 
+    # Save nonexisting instance of self against API and set self.id
+    #
+    self.create = (callback) =>
+      mapi.create(self.export()).done (data) =>
+        self.id = data.id
+
+    # Export all model data as an array
+    #
+    self.export = =>
+      data = {}
+      if options.editable?
+        for index, name of options.editable
+          data[name] = self[name]()
+
+      if options.encrypted_editable?
+        for index, name of options.encrypted_editable
+          data[name] = self[name]()
+
+      if options.belongs_to?
+        for name, has_data of options.belongs_to
+          data[name + '_id'] = self[name + '_id']
+
+      return data
+
     return self
 
-  model.get = (params, callbackOrObservable) ->
+  ###
+  # These are the collector functions and are not bound to a specific object but to the model
+  ###
+
+  # Get objects from API and save into specified observable or callback
+  #
+  model.get = (params = {}, callbackOrObservable) ->
     callback = (data) ->
       for m in data
         callbackOrObservable.push model(m)
 
     if typeof callbackOrObservable['push'] == 'undefined'
       if typeof callbackOrObservable != 'function'
-        console.log 'Collection.find 2nd parameter needs to be either a function or a pushable object (Array, ObservableArray).\nGiven:'
+        console.log 'model.get 2nd parameter needs to be either a function or a pushable object (Array, ObservableArray).\nGiven:'
         console.log callbackOrObservable
 
       callback = callbackOrObservable


  add_apis_to options.has_many, options.api if options.has_many?

  # Enhance data!
  model = (self = {}) ->
    self.api = -> mapi
    self.relationship_fields = (name, model) -> [name + '_id', name + 's', name, window[model]]

    if options.sortable? && options.sortable == true
      Sortable self
    if options.selectable? && options.selectable == true
      Selectable self
    
    # Set relations
    # Lonely
    if options.belongs_to?
      unless options.has_one?
        options.has_one = []
      options.has_one = Ham.merge options.belongs_to, options.has_one

    if options.has_one?
      for name, data of options.has_one
        Ham.merge data,
          model: name.capitalize()

        fn = window[data.model]
        if self[name]?
          Observable self, name, new fn(self[name])
        else
          LazyObservable self, name, lazy_single_get_fn, self.relationship_fields(name, data.model)

    # Harem relations
    if options.has_many?
      for name, data of options.has_many
        Ham.merge data,

        relation_params.push options

        # Get
        #
        if self[name + 's']?
          fn = window[data.model]
          
