     /// TaskQueue delegate object
     weak open var delegate: TaskQueueDelegate?
     
+    /// Boolean indicating if queue is actively scheduling tasks execution
+    var isSuspended: Bool {
+        get { return operationQueue.isSuspended }
+        
+        set(suspended) {
+            operationQueue.isSuspended = suspended
+        }
+    }
+    
+    /// Returns all active tasks in the queue
+    var tasks: [Operation] {
+        return operationQueue.operations
+    }
+    
+    /// Specifies service level that is used in executing tasks
+    /// in the current queue.
+    var qos: QualityOfService {
+        get { return operationQueue.qualityOfService }
+        set(newQos) {
+            operationQueue.qualityOfService = newQos
+        }
+    }
+    
+    /// Queue name identifier
+    var name: String?
+    
+    /// The maximum number of tasks that can be executed at the same time
+    /// concurrently.
+    var maxConcurrentTaskCount: Int {
+        get { return operationQueue.maxConcurrentOperationCount }
+        set(newCount) {
+            operationQueue.maxConcurrentOperationCount = newCount
+        }
+    }
+    
     // MARK: Init methods
     
     /// Creates instance of `TaskQueue`
     public init() {
         self.operationQueue = OperationQueue()
+        operationQueue.isSuspended = true
     }
     
     /**

     - Parameter task: Task<T> to be added
     */
    open func add<T>(task: Task<T>) {
        let finishObserver = FinishBlockObserver { [weak self] in
            if let queue = self {
                queue.delegate?.didFinish(task: task, inQueue: queue)
            }
        }
        
        if !task.contains(observer: FinishBlockObserver.self) {
            task.add(observer: finishObserver)
        }
        
        // Evaluate condition dependencies and add them to the queue

    
    /// Underlying `Foundation.OperationQueue` instance used for executing
    /// `Foundation.Operation` operations
    internal let operationQueue: OperationQueue
    
    /**
     Returns queue associated with application main queue.
