public let response: Any? // Response object
public let loading: Bool // Sounds obvious ^^
public let error: Error? // Error object if one has happened

public let data: Data? // Data being a templated type you stated at init
public let localEnabled: Bool // Have you enabled a local source at init ?
public let localLoading: Bool // Is your local source still loading the data ?
public let remoteEnabled: Bool // Have you enabled a remote source at init ?
public let remoteLoading: Bool // Is your remote source still loading the data ?
public let refreshLoading: Bool // Used for refreshing the whole struct
public let error: Error? // Has any error happened during the fetch ? (that's the last happened)

public let paginationEnabled: Bool // Pagination can be switched off if not used
public let paginationLoading: Bool // Is a new page being loaded ?
public let currentPage: Int
public let totalPages: Int // can usually be fetched from the server reponse headers
public let totalItems: Int // can usually be fetched from the server reponse headers

public let data: T?
public let itemsCount: Int? // Total count of items server-side
public let pagesCount: Int? // Number of pages available to request

let data = try Mapper<T>(context: context).mapArray(JSONString: jsonString)
let totalString = response.allHeaderFields["pagination-total-count"] as? String ?? "0"
let total = Int(totalString) ?? 0
return Paged(data: data, itemsCount: total, pagesCount: total / perPage + 1)

public protocol PagedUITableView: UITableView {
  func loadMore() // Called when a new page needs to be loaded

  func refreshData() // Used to reload the whole tableView on pullToRefresh
}

enum ProfileInput {
  case addUserTapped
}

enum ProfileOutput {
  case userAdded
}

class ProfileViewModel: CleanViewModel<ProfileInput, ProfileOutput> {

  let userInteractor: UserInteractor // Clean Architecture :)

  let userState = DataState<User>.relay(remoteEnabled: true)
  let addState = ActionState.relay(remoteEnabled: true)

  var user: User? {
    return userState.value.data as? User
  }

  override init() {
    userInteractor = UserInteractor() // Clean Architecture :)
    super.init()

    // Load process works with loadRemote & loadLocal, applies to all kinds of State
    // Here launched on init, but can also be triggered in the perform, doesn't matter
    userInteractor
      .fetchUser() // This is basically a RxSwift.Observable
      .loadRemote(with: userState) // This loads data into the state
      .disposed(by: self)
  }
	
  override func perform(_ input: ProfileInput) {
    switch input {
      case .addUserTapped:
        // Load process with only success handled, works only for ActionState
        // this one's disposal is handled in background
        //
        // You can also use the executeAction with only addState as parameter and handle both 	
        // success and error by subscribing to addState in your ViewController.
        userInteractor
          .addUser() // Again, a RxSwift.Observable
          .executeAction(with: addState, 
                         viewModel: self, 
                         success: .userAdded)
    }
  }
}

class ProfileViewController: UIViewController {
  @IBOutlet weak var addButton: UIButton!

  let viewModel = ProfileViewModel()
  var disposeBag = DisposeBag()

  override func viewDidLoad() {
    super.viewDidLoad()

    viewModel
      .userState
      .subscribe(onNext: { [unowned self] state in
        if state.isGlobalLoading {
          return // Data is still loading
        }
        if let user = viewModel.user {
          self.updateView(forUser: user) // Data was fetched and mapped successfully
        } else {
          // Could not fetch data
        }
      })
      .disposed(by: self.disposeBag)
		
    viewModel
      .subscribe(onOutput: { output in
        switch output {
          case .userAdded:
            print("User has been added successfully")
          }
      })
      .disposed(by: self.disposeBag)

    addButton
      .rx.tap.mapTo(ProfileInput.addUserTapped)
      .bind(to: self.viewModel)
      .disposed(by: self.disposeBag)
  }
}

enum MessagesInput {
  case refreshData
  case loadMore
}

enum MessagesOutput {
}

class MessagesViewModel: CleanViewModel<MessagesInput, MessagesOutput> {

  let messagesInteractor: MessagesInteractor // Clean Architecture :)

  lazy var pagedController = PagedCollectionController<Message> { [unowned self] page in
    return self.messagesInteractor.getMessages(forPage: page)
  }

  var messagesState: BehaviorRelay<CollectionState<Message>> {
    return pagedController.relay
  }

  var messages: [Message] {
    return messagesState.value.data ?? []
  }

  override init() {
    messagesInteractor = MessagesInteractor() // Clean Architecture :)
    super.init()
  }
	
  override func perform(_ input: ProfileInput) {
    switch input {
      case .loadMore:
        pagedController.loadMore()
      case .refreshData:
        pagedController.refreshData()
    }
  }
}

class MessagesViewController: UIViewController {
  @IBOutlet weak var tableView: PagedUITableView!

  let viewModel = MessagesViewModel()
  var disposeBag = DisposeBag()

  override func viewDidLoad() {
    super.viewDidLoad()

    self.tableView.dataSource = self

    self.viewModel
      .messagesState
      .bindToPagedTableView(self.tableView)
      .disposed(by: self.disposeBag)

    self.viewModel.perform(.refreshData)
  }
}

extension ProfileViewController: PagedUITableViewDataSource {
  // don't forget the required function to conform to UITableViewDataSource
  // such as for example:
  func numberOfSections(in tableView: UITableView) {
    return viewModel.messages
  }

  // and add the two extras from PagedUITableViewDataSource
  func loadMore() {
    self.viewModel.perform(.loadMore)
  }

  func refreshData() {
    self.viewModel.perform(.refreshData)
  }
}