 				let semaphore = DispatchSemaphore(value: 0)
 				let progress = mcSession.sendResource(at: localURL, withName: resourceRequest.resourceName, toPeer: peer) { error in
 					if let error = error {
-						receipt.eventObserver.observe(.transferFailed(resourceRequest, peer, error))
+						receipt.eventObserver.observe(.failed(resourceRequest, peer, error))
 					} else {
-						receipt.eventObserver.observe(.transferFinished(resourceRequest, peer, localURL))
+						receipt.eventObserver.observe(.finished(resourceRequest, peer, localURL))
 					}
 					semaphore.signal()
 				}
 				receipt.disposable += { progress?.cancel() }
-				receipt.eventObserver.observe(.transferStarted(resourceRequest, peer, progress))
+				receipt.eventObserver.observe(.started(resourceRequest, peer, progress))
 				semaphore.wait()
 			}
 			receipt.disposable += { item.cancel() }

		self.request = request
		self.peers = peers
	}
}

extension ResourceRequestReceipt: ResourceEventProducerProtocol {
	public func addEventObserver(on queue: DispatchQueue, action: @escaping (ResourceEvent<Request>) -> Void) -> Disposable {
		let observer = DispatchObserver(queue: queue, action: action)
		let disposable = eventObserver.add(observer)
		self.disposable += disposable
		return disposable
	}
}

extension ResourceRequestReceipt: Disposable {
	public var isDisposed: Bool {
		return disposable.isDisposed
	}

		return receipt
	}

	public func submit(resourceAt localURL: URL, to peers: [MCPeerID]) throws -> ResourceTransferOperation<ResourceRequest> {
		let request = ResourceRequest()
		return try submit(request, withResourceAt: localURL, to: peers)
	}
}

extension Session {
	public func addResponder<T: ResourceRequestProtocol>(for resourceRequestType: T.Type, on queue: DispatchQueue, action: @escaping (_ event: ResourceTransferEvent<T>, _ send: @escaping (_ response: T.Response) throws -> Void) -> Void) -> Disposable {
		let disposable = CompositeDisposable()

		let responseQueue = DispatchQueue(label: "com.junpluse.Tuka.Session.ResourceRequestResponderQueue")
		let responder = RequestResponder<T, MCPeerID>(queue: responseQueue) { request, peer, send in
			let sessionEventDisposable = CompositeDisposable()

			let sendAndDispose: (T.Response) throws -> Void = { response in
