     
     class func keyString(type: PermissionType) -> String {
         switch type {
-        case .AssetLibrary:
+        case .AssetsLibrary:
             return "asset_library_key"
         case .Camera:
             return "camera_key"

    class func permissionType(keyString : String) -> PermissionType? {
        switch keyString {
        case "asset_library_key":
            return .AssetLibrary
        case "camera_key":
            return .Camera
        case "calendars_key":

    
    // MARK: - Permissions Methods
    
    private func statusForAssetsLibrary() -> StatusType {
        switch ALAssetsLibrary.authorizationStatus() {
        case .Authorized:    return .Authorized
        case .Denied:        return .Denied
        case .NotDetermined: return .NotDetermined
        case .Restricted:    return .Restricted
        }
    }
    
    private func askAssetsLibrary(completion: ((RequestStatusCallback) -> ())) {
        var stop : UnsafeMutablePointer<Bool> = nil
        ALAssetsLibrary().enumerateGroupsWithTypes(ALAssetsGroupAll,
            usingBlock: { group, stop in
                if stop != nil {
                    stop.memory = true
                    completion(RequestStatusCallback.JustAuthorized)
                }
            }, failureBlock: { error in
                completion(RequestStatusCallback.Denied)
        })
    }
    
    
    private func statusForCamera() -> StatusType {
        switch AVCaptureDevice.authorizationStatusForMediaType(AVMediaTypeVideo) {
        case .Authorized:    return .Authorized
        case .Denied:        return .Denied
        case .NotDetermined: return .NotDetermined
        case .Restricted:    return .Restricted
        }
    }
    
    private func askCamera(completion: ((RequestStatusCallback) -> ())) {
        dispatch_async(dispatch_get_main_queue(), {
            AVCaptureDevice.requestAccessForMediaType(AVMediaTypeVideo, completionHandler: { success in
                let status: RequestStatusCallback = success ? .JustAuthorized : .Denied
                completion(status)
            })
        })
    }
    
    
    private func statusForCalendar() -> StatusType {
        switch EKEventStore.authorizationStatusForEntityType(EKEntityTypeEvent) {
        case .Authorized:    return .Authorized
        case .Denied:        return .Denied
        case .NotDetermined: return .NotDetermined
        case .Restricted:    return .Restricted
        }
    }
    
    private func askCalendar(completion: ((RequestStatusCallback) -> ())) {
        EKEventStore().requestAccessToEntityType(EKEntityTypeEvent, completion: { granted, error in
            let status: RequestStatusCallback = granted ? .JustAuthorized : .Denied
            completion(status)
        })
    }
    
    
    private func statusForContacts() -> StatusType {
        switch ABAddressBookGetAuthorizationStatus() {
        case .Authorized:    return .Authorized
        case .Denied:        return .Denied
        case .NotDetermined: return .NotDetermined
        case .Restricted:    return .Restricted
        }
    }
    
    
    private func askContacts(completion: ((RequestStatusCallback) -> ())) {
        ABAddressBookRequestAccessWithCompletion(nil) { granted, error in
            let status: RequestStatusCallback = granted ? .JustAuthorized : .Denied
            completion(status)
        }
    }
    
    
    private func statusForMicrophone() -> StatusType {
        switch AVAudioSession.sharedInstance().recordPermission() {
        case AVAudioSessionRecordPermission.Denied:       return .Denied
        case AVAudioSessionRecordPermission.Undetermined: return .NotDetermined
        case AVAudioSessionRecordPermission.Granted:      return .Authorized
        default: return .Restricted
        }
    }
    
    private func askMicrophone(completion: ((RequestStatusCallback) -> ())) {
        AVAudioSession.sharedInstance().requestRecordPermission { granted in
            let status: RequestStatusCallback = granted ? .JustAuthorized : .Denied
            completion(status)
        }
    }
    
    
    private func statusForNotifications() -> StatusType {
        let settings = UIApplication.sharedApplication().currentUserNotificationSettings()
        if settings.types != UIUserNotificationType.None {
            return .Authorized
