 }
 
 extension Capability {
+
+    /**
+     # Capability.Calendar
+     
+     For framework consumers - use with GetAuthorizationStatus, Authorize and
+     AuthorizedFor. For example
+     
+     Get the current authorization status for accessing the user's calendars:
+
+     ```swift
+     GetAuthorizationStatus(Capability.Calendar()) { available, status in
+         // etc
+     }
+     ```
+     
+     Lets say we have an operation which performs an action with the user's
+     calendars. We need to have permission to access their calendars first.
+     We can add an OperationCondition to such an operation, so that if
+     the user hasn't granted permission it will fail (we can check the errors),
+     or, if the permission hasn't been asked, it will ask for us automatically.
+     
+     ```swift
+
+     // Define the operation
+     let operation = ProcessCalendarsOperation()
+     
+     // Create & add condition
+     let condition = AuthorizedFor(Capability.Calendar())
+     operation.addCondition(condition)
+     
+     // Observe & look out for errors
+     operation.addObserver(BlockObserver { _, errors in
+        if !errors.isEmpty, 
+          let error = errors.first as? CapabilityError<Capability.Calendar> {
+             switch error {
+               case .AuthorizationNotGranted(status, requirement):
+                  print("Access to calendars was denied...")
+             }
+          }
+     })
+     
+     // Add the operation to our queue
+     queue.addOperation(operation)
+     ```
+    */
     public typealias Calendar = _EventsCapability<EKEventStore>
 }
 
-@available(*, unavailable, renamed="AuthorizedFor(Capability.Calendar(.Event))")
+@available(*, unavailable, renamed="AuthorizedFor(Capability.Calendar())")
 public typealias CalendarCondition = AuthorizedFor<Capability.Calendar>
 


extension EKAuthorizationStatus: AuthorizationStatusType {

    public func isRequirementMet(requirement: EKEntityType) -> Bool {
        if case .Authorized = self {
            return true

        super.init()
    }

    /// - returns: true, EventKit is always available
    public func isAvailable() -> Bool {
        return true
    }

    /**
     Get the current authorization status of EventKit from the Registrar.
     - parameter completion: a Status -> Void closure.
     */
    public func authorizationStatus(completion: EKAuthorizationStatus -> Void) {
        completion(registrar.opr_authorizationStatusForRequirement(requirement))
    }

    /**
     Request authorization to EventKit from the Registrar.
     - parameter completion: a dispatch_block_t
     */
    public func requestAuthorizationWithCompletion(completion: dispatch_block_t) {
        let status = registrar.opr_authorizationStatusForRequirement(requirement)
        switch status {
