let call = Call(path: "posts", method: HTTPMethod.GET, rootNode: "rootNode")
// the rootNode is used to query the json in the response in `rootNode(from json:)`

let call = Call(path: "posts")
let config = Configuration(baseURL: "http://jsonplaceholder.typicode.com"
let service =  Service<Post>(call, deprecatedService: DeprecatedService(configuration: config)

  let baseURL = "http://jsonplaceholder.typicode.com"

  // Optionally create your own FaroSession to handle for example security.
  FaroSingleton.setup(with: baseURL, session: FaroSession())

        service.collection { [weak self] (resultFunction) in
                DispatchQueue.main.async {
                    do {
                        let posts = try resultFunction() // Use the function to get the result or the error thrown
                          self?.label.text = "Performed call for \(posts)"
                    } catch {
                        // printError(error) // errors are printed by default so you could leave this out
                      }
              }
        }

        service.collection {
                DispatchQueue.main.async {
              let posts = try? $0() // Us anonymous closure arguments if you are comfortable with the syntax
              self?.label.text = "Performed call for posts"
              }
        }

        service.single {
            DispatchQueue.main.async {
                do {
                    let model = try $0()
                    print("🙏 sucessfully finished call")
                } catch {
                    print("👿 something went wrong with \(error)")
                }
            }
        }

        service.sendWithoutJSONInResponse {
            DispatchQueue.main.async {
                do {
                    try $0()
                    print("🙏 sucessfully finished call")
                } catch {
                    print("👿 something went wrong with \(error)")
                }
            }
        }

        // Do any Service call like above

        do {
            let _ = try resultFunction()
        } cacht FaroError.invalidAuthentication(call: let call):

            // Handle this specific error case

         catch {
           // Handle all other possible errors.
            print("👿 something went wrong with \(error)")
        }

class Zoo: JSONDeserializable {
    var uuid: String?
    var color: String?
    var animal: Animal?
    var date: Date?
    var animalArray: [Animal]?

    required init(_ raw: [String: Any]) throws {
        self.uuid |< raw["uuid"]
        self.color |< raw["color"]
        self.animal |< raw["animal"]
        self.animalArray |< raw["animalArray"]
        self.date |< (raw["date"], "yyyy-MM-dd")
    }
}

extension Zoo: JSONSerializable {
    var json: [String: Any] {
        get {
            var json = [String: Any]()
            json["uuid"] <| self.uuid
            json["color"] <| self.color
            json["animal"] <| self.animal
            json["animalArray"] <| self.animalArray
            json["date"] <| self.date
            return json
        }
    }
}

class Jail: JSONDeserializable {
    var cellNumber: String

    required init(_ raw: [String: Any]) throws {
        cellNumber = try create("cellNumber", from: raw)
    }

}

// Example image as Data
guard let jpeg = UIImageJPEGRepresentation(image, 0.7) else {
    print("👿 not a valid jpeg")
    return
}

// Create a multipart object and add it to the call
let multipart = MultipartFile(parameterName: "image", data: jpeg, mimeType: .jpeg)
let call = Call(path: "queries",
                method: .POST,
                parameter: [.multipart(multipart)])

// This assumes we have setup a singleton
let service = ServiceNoResponseData(call: call)
service.send {
  do {
    try $0()
  } catch {
    // handle error
  }
}

func setupFaroWithSecurity() {
        let baseURL = "http://jsonplaceholder.typicode.com"

        let sessionSessionDelegate = FaroURLSessionDelegate(allowUntrustedCertificates: false)
        let secureSession = FaroSecureURLSession(urlSessionDelegate: sessionSessionDelegate)
        FaroSingleton.setup(with: baseURL, session: secureSession)
// Example image as Data
guard let jpeg = UIImageJPEGRepresentation(image, 0.7) else {
    print("👿 not a valid jpeg")
    return
}

DeprecatedService(configuration: Configuration(baseURL: baseURL), faroSession: secureSession)