     public class func find(call: ApiCall = ApiCall(), callback: (ModelType?) -> Void) {
         call.provideDefaults(ModelType)
 
-        api().GET(call.resource!, parameters: [:]) { data, error in
-            if data[call.namespace!] != nil {
-                let modelData = data[call.namespace!]
+        perform(
+            .GET,
+            path: call.resource!,
+            parameters: [:],
+            namespace: ModelType.apiNamespace()
+        ) { dictionaryResponse, arrayResponse, errors in
+            if let modelData = dictionaryResponse {
                 let model = self.fromApi(modelData)
                 callback(model)
             } else {


    public class func findArray(call: ApiCall, callback: ([ModelType]) -> Void) {
        call.provideDefaults(ModelType)
        call.namespace = call.namespace!.pluralize()

        api().GET(call.resource!, parameters: [:]) { data, error in
            if let arrayData = data[call.namespace!].array {
                var ret: [ModelType] = []

                for modelData in arrayData {
                    let model = self.fromApi(modelData)
                    ret.append(model)
                }

                callback(ret)
            } else {
                callback([])
            }
        }
    }

    public class func post(parameters: [String:AnyObject], callback: (ModelType?) -> Void) {
        api().POST(ModelType.apiResource().create, parameters: parameters) { (data, error) in
            var namespace = ModelType.apiNamespace()

            if data[namespace] != nil {
                let modelData = data[namespace]

                let model = self.fromApi(modelData)
                callback(model)
            } else {

            self.model.updateFromDictionaryWithMapping(formParameters as! [String:AnyObject], mapping: ModelType.fromJSONMapping())
        }
    }
    
    public func updateFromResponse(responseData: [String:AnyObject]?) {
        if let responseData = responseData {
            model.modifyStoredObject {
                self.model.updateFromDictionaryWithMapping(responseData, mapping: ModelType.fromJSONMapping())
            }
        }
    }

    public class func fromApi(apiResponse: [String:AnyObject]) -> ModelType {
        let newModel = ModelType(completelyBogusInitializerDoesNothing: true)
        newModel.updateFromDictionaryWithMapping(apiResponse, mapping: ModelType.fromJSONMapping())
        return newModel
    }

