     ///
     @objc public func getObject(objectID: String, attributesToRetrieve: [String]?, completionHandler: CompletionHandler) -> NSOperation {
         let operation = NSBlockOperation() {
-            let (content, error) = self.getObject(objectID, attributesToRetrieve: attributesToRetrieve)
+            let (content, error) = self.getObjectSync(objectID, attributesToRetrieve: attributesToRetrieve)
             self.callCompletionHandler(completionHandler, content: content, error: error)
         }
         client.searchQueue.addOperation(operation)
         return operation
     }
     
-    private func getObject(objectID: String, attributesToRetrieve: [String]?) -> (content: [String: AnyObject]?, error: NSError?) {
+    /// Get an object from this index (synchronous version).
+    ///
+    /// - parameter objectID: Identifier of the object to retrieve.
+    /// - returns: A mutually exclusive (content, error) pair.
+    ///
+    private func getObjectSync(objectID: String, attributesToRetrieve: [String]?) -> APIResponse {
         var content: [String: AnyObject]?
         var error: NSError?
         let query = Query()

    /// Run multiple queries on this index.
    ///
    /// - parameter queries: The queries to run.
    /// - parameter completionHandler: Completion handler to be notified of the request's outcome.
    /// - returns: A cancellable operation.
    ///
    @objc public func multipleQueries(queries: [Query], strategy: String?, completionHandler: CompletionHandler) -> NSOperation {
        let emulator = MultipleQueryEmulator(indexName: self.name, querier: { (query: Query) in
            let searchResults = self.localIndex.search(query.build())
            return OfflineClient.parseSearchResults(searchResults)
        })
        let operation = NSBlockOperation() {
            let (content, error) = emulator.multipleQueries(queries, strategy: strategy)
            self.callCompletionHandler(completionHandler, content: content, error: error)
        }
        client.searchQueue.addOperation(operation)
        return operation
    }
    
    /// Run multiple queries on this index.
    ///
    /// - parameter queries: The queries to run.
    /// - parameter strategy: The strategy to use.
    /// - parameter completionHandler: Completion handler to be notified of the request's outcome.
    /// - returns: A cancellable operation.
    ///
    public func multipleQueries(queries: [Query], strategy: Client.MultipleQueriesStrategy? = nil, completionHandler: CompletionHandler) -> NSOperation {
        return self.multipleQueries(queries, strategy: strategy?.rawValue, completionHandler: completionHandler)
    }
    
    // MARK: - Utils
    
    /// Call a completion handler on the main queue.

    ///
    @objc public func browseFrom(cursor: String, completionHandler: CompletionHandler) -> NSOperation {
        let operation = NSBlockOperation() {
            let (content, error) = self.browseFromSync(cursor)
            self.callCompletionHandler(completionHandler, content: content, error: error)
        }
        client.searchQueue.addOperation(operation)
        return operation
    }

    /// Browse the index from a cursor (synchronous version).
    /// This method should be called after an initial call to `browse()`. It returns a cursor, unless the end of the
    /// index has been reached.
    ///
    /// - parameter cursor: The cursor of the next page to retrieve
    /// - parameter completionHandler: Completion handler to be notified of the request's outcome.
    /// - returns: A cancellable operation.
    ///
    private func browseFromSync(cursor: String) -> APIResponse {
        let searchResults = self.localIndex.browse(Query(parameters: ["cursor": cursor]).build())
        return OfflineClient.parseSearchResults(searchResults)
    }

    // MARK: - Helpers
    
    /// Delete all objects matching a query (helper).
