 public extension CoreDataStack {
     /**
     For SQLite based stacks, this function will remove the SQLite store from disk and creates a fresh NSPersistentStore.
-    
-     - parameter resetCallback: A callback with a Success or an ErrorType value with the error
+
+    - parameter resetCallback: A callback with a Success or an ErrorType value with the error
     */
     public func resetSQLiteStore(resetCallback: CoreDataStackSQLiteResetCallback) {
         switch storeType {

public typealias CoreDataStackSQLiteResetCallback = ResetResult -> Void
public typealias CoreDataStackBatchMOCCallback = BatchContextResult -> Void

/**
Three layer CoreData stack comprised of:


        case .SQLite(let storeURL):
            let coordinator = persistentStoreCoordinator
            let mom = managedObjectModel

            guard let store = coordinator.persistentStoreForURL(storeURL) else {
                let error = CoreDataStackError.StoreNotFoundAtURL(url: storeURL)
                resetCallback(.Failure(error))
                break
            }

            let backgroundQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0)
            dispatch_async(backgroundQueue) {
                dispatch_group_notify(self.saveBubbleDispatchGroup, dispatch_get_main_queue()) {
                    do {
                        try coordinator.removePersistentStore(store)
                        try NSFileManager.defaultManager().removeItemAtURL(storeURL)

                        // Remove journal files if present
                        let _ = try? NSFileManager.defaultManager().removeItemAtURL(storeURL.URLByAppendingPathComponent("-shm"))
                        let _ = try? NSFileManager.defaultManager().removeItemAtURL(storeURL.URLByAppendingPathComponent("-wal"))

                        // Setup a new stack
                        NSPersistentStoreCoordinator.setupSQLiteBackedCoordinator(mom, storeFileURL: storeURL) { result in
                            switch result {
                            case .Success (let coordinator):
                                self.persistentStoreCoordinator = coordinator
                                resetCallback(.Success)
                            case .Failure (let error):
                                resetCallback(.Failure(error))
                            }
                        }
                    } catch let fileRemoveError {
                        resetCallback(.Failure(fileRemoveError))
                    }
                }
            }
        }
