     }
 }
 
-// MARK: - Condition
-
+/**
+ An generic ErrorType used by the AuthorizedFor condition.
+*/
 public enum CapabilityError<Capability: CapabilityType>: ErrorType {
+
+    /// If the capability is not available
     case NotAvailable
+
+    /// If authorization for the capability was not granted.
     case AuthorizationNotGranted((Capability.Status, Capability.Status.Requirement?))
 }
 
+/**
+ This is a generic OperationCondition which can be used to allow or
+ deny operations to execute depending on the authorization status of a
+ capability. 
+ 
+ By default, the condition will add an Authorize operation as a dependency
+ which means that potentially the user will be prompted to grant
+ authorization. Suppress this from happening with SilentCondition.
+*/
 public struct AuthorizedFor<Capability: CapabilityType>: OperationCondition {
 
     public let name: String

    }
}

public class Authorize<Capability: CapabilityType>: GetAuthorizationStatus<Capability> {

    public override init(_ capability: Capability, completion: Completion = { _ in }) {
        super.init(capability, completion: completion)
        name = "Authorize \(capability.name).\(capability.requirement)"
        addCondition(MutuallyExclusive<Capability>())
    }

    public override func execute() {
        capability.requestAuthorizationWithCompletion {
            super.execute()

    }
}

/**

 # Get Authorization Status Operation

 This is a generic operation which will get the current authorization
 status for any CapabilityType.

*/
public class GetAuthorizationStatus<Capability: CapabilityType>: Operation {

    /// the StatusResponse is a tuple for the capabilities availability and status
    public typealias StatusResponse = (Bool, Capability.Status)

    /// the Completion is a closure which receives a StatusResponse
    public typealias Completion = StatusResponse -> Void

    /**
     After the operation has executed, this property will be set
     either true or false.
     
     - returns: a Bool indicating whether or not the capability is available.
    */
    public var isAvailable: Bool? = .None

    /**
     After the operation has executed, this property will be set
     to the current status of the capability.

     - returns: a StatusResponse of the current status.
     */
    public var status: Capability.Status? = .None

    let capability: Capability
    let completion: Completion

    /**
     Initialize the operation with a CapabilityType and completion. A default
     completion is set which does nothing. The status is also available using
     properties.
     
     - parameter capability: the Capability.
     - parameter completion: the Completion closure.
    */
    public init(_ capability: Capability, completion: Completion = { _ in }) {
        self.capability = capability
        self.completion = completion
