Skip to content

Instantly share code, notes, and snippets.

@mironal

mironal/0_HowToUse.swift

Last active July 5, 2022 09:14
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save mironal/eec8eeb1bb256c27e4dccea261d47e7e to your computer and use it in GitHub Desktop.
Save mironal/eec8eeb1bb256c27e4dccea261d47e7e to your computer and use it in GitHub Desktop.
Download ZIP
TwitterAPIKit+RxSwift.generated.swift (The RxSwift extension for TwitterAPIKit)
Raw
0_HowToUse.swift
struct TwitterResponse<Data: Decodable>: Decodable {
let data: Data
}
struct Status: Decodable {
let id: String
let text: String
}
let client = TwitterAPIClient(/* auth */)
client.v2.tweet.rx.getTweet(.init(id: "id"), responseType: TwitterResponse<Status>.self)
.map { $0.data.text }
.subscribe()
.disposed(by: disposeBag)
Raw
1_TwitterAPIKit+RxSwift.generated.swift
// Generated using Sourcery 1.8.1 — https://github.com/krzysztofzablocki/Sourcery
// DO NOT EDIT
#if canImport(RxSwift)
import Foundation
import TwitterAPIKit
import RxSwift
// MARK: - TwitterAuthAPI
extension OAuth10aAPI: ReactiveCompatible {}
extension Reactive where Base: OAuth10aAPI {
// Ignore: postOAuthRequestTokenData(_:) -> TwitterAPISessionDataTask
public func postOAuthRequestToken(_ request: PostOAuthRequestTokenRequestV1) -> Single<(response: TwitterOAuthTokenV1, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postOAuthRequestToken(request).responseObject { response in
let result = response.result
.map { obj in return (response: obj, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
// Ignore: makeOAuthAuthorizeURL(_:) -> URL?
// Ignore: makeOAuthAuthenticateURL(_:) -> URL?
// Ignore: postOAuthAccessTokenData(_:) -> TwitterAPISessionDataTask
public func postOAuthAccessToken(_ request: PostOAuthAccessTokenRequestV1) -> Single<(response: TwitterOAuthAccessTokenV1, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postOAuthAccessToken(request).responseObject { response in
let result = response.result
.map { obj in return (response: obj, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postInvalidateAccessToken<Response: Decodable>(_ request: PostOAuthInvalidateTokenRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postInvalidateAccessToken(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension OAuth20API: ReactiveCompatible {}
extension Reactive where Base: OAuth20API {
// Ignore: postOAuth2BearerTokenData(_:) -> TwitterAPISessionDataTask
public func postOAuth2BearerToken(_ request: PostOAuth2TokenRequestV1) -> Single<(response: TwitterOAuth2BearerToken, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postOAuth2BearerToken(request).responseObject { response in
let result = response.result
.map { obj in return (response: obj, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postInvalidateOAuth2BearerToken<Response: Decodable>(_ request: PostOAuth2InvalidateTokenRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postInvalidateOAuth2BearerToken(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
// Ignore: makeOAuth2AuthorizeURL(_:) -> URL?
// Ignore: postOAuth2AccessTokenData(_:) -> TwitterAPISessionDataTask
public func postOAuth2AccessToken(_ request: PostOAuth2AccessTokenRequestV2) -> Single<(response: TwitterOAuth2AccessToken, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postOAuth2AccessToken(request).responseObject { response in
let result = response.result
.map { obj in return (response: obj, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
// Ignore: postOAuth2RefreshTokenData(_:) -> TwitterAPISessionDataTask
public func postOAuth2RefreshToken(_ request: PostOAuth2RefreshTokenRequestV2) -> Single<(response: TwitterOAuth2AccessToken, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postOAuth2RefreshToken(request).responseObject { response in
let result = response.result
.map { obj in return (response: obj, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
// Ignore: postOAuth2RevokeToken(_:) -> TwitterAPISessionDataTask
}
// MARK: - TwitterAPIv1
extension AccountAPIv1: ReactiveCompatible {}
extension Reactive where Base: AccountAPIv1 {
public func getAccountSetting<Response: Decodable>(_ request: GetAccountSettingsRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getAccountSetting(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getAccountVerify<Response: Decodable>(_ request: GetAccountVerifyCredentialsRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getAccountVerify(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postRemoveProfileBanner<Response: Decodable>(_ request: PostAccountRemoveProfileBannerRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postRemoveProfileBanner(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postAccountSettings<Response: Decodable>(_ request: PostAccountSettingsRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postAccountSettings(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postAccountProfile<Response: Decodable>(_ request: PostAccountUpdateProfileRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postAccountProfile(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
// Ignore: postProfileBanner(_:) -> TwitterAPISessionDataTask
public func postProfileImage<Response: Decodable>(_ request: PostAccountUpdateProfileImageRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postProfileImage(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension ApplicationAPIv1: ReactiveCompatible {}
extension Reactive where Base: ApplicationAPIv1 {
public func getRateLimit<Response: Decodable>(_ request: GetApplicationRateLimitStatusRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getRateLimit(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension BlockAndMuteAPIv1: ReactiveCompatible {}
extension Reactive where Base: BlockAndMuteAPIv1 {
public func getBlockIDs<Response: Decodable>(_ request: GetBlocksIDsRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getBlockIDs(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getBlockUsers<Response: Decodable>(_ request: GetBlocksListRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getBlockUsers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getMuteIDs<Response: Decodable>(_ request: GetMutesUsersIDsRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getMuteIDs(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getMuteUsers<Response: Decodable>(_ request: GetMutesUsersListRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getMuteUsers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postBlockUser<Response: Decodable>(_ request: PostBlocksCreateRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postBlockUser(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postUnblockUser<Response: Decodable>(_ request: PostBlocksDestroyRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postUnblockUser(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postMuteUser<Response: Decodable>(_ request: PostMutesUsersCreateRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postMuteUser(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postUnmuteUser<Response: Decodable>(_ request: PostMutesUsersDestroyRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postUnmuteUser(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postReportSpam<Response: Decodable>(_ request: PostUsersReportSpamRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postReportSpam(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension CollectionAPIv1: ReactiveCompatible {}
extension Reactive where Base: CollectionAPIv1 {
public func getCollectionEntries<Response: Decodable>(_ request: GetCollectionsEntriesRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getCollectionEntries(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getCollections<Response: Decodable>(_ request: GetCollectionsListRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getCollections(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getCollection<Response: Decodable>(_ request: GetCollectionsShowRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getCollection(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postCreateCollection<Response: Decodable>(_ request: PostCollectionsCreateRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postCreateCollection(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postDestroyCollection<Response: Decodable>(_ request: PostCollectionsDestroyRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postDestroyCollection(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postCollectionAddEntry<Response: Decodable>(_ request: PostCollectionsEntriesAddRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postCollectionAddEntry(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postCollectionCurate<Response: Decodable>(_ request: PostCollectionsEntriesCurateRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postCollectionCurate(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postCollectionMoveEntry<Response: Decodable>(_ request: PostCollectionsEntriesMoveRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postCollectionMoveEntry(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postCollectionRemoveEntry<Response: Decodable>(_ request: PostCollectionsEntriesRemoveRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postCollectionRemoveEntry(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postCollectionUpdate<Response: Decodable>(_ request: PostCollectionsUpdateRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postCollectionUpdate(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension DirectMessageAPIv1: ReactiveCompatible {}
extension Reactive where Base: DirectMessageAPIv1 {
public func postDirectMessage<Response: Decodable>(_ request: PostDirectMessageRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postDirectMessage(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
// Ignore: deleteDirectMessage(_:) -> TwitterAPISessionDataTask
public func getDirectMessage<Response: Decodable>(_ request: GetDirectMessageRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getDirectMessage(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getDirectMessageList<Response: Decodable>(_ request: GetDirectMessageListRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getDirectMessageList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
// Ignore: postDirectMessageMarkRead(_:) -> TwitterAPISessionDataTask
// Ignore: postDirectMessageTypingIndicator(_:) -> TwitterAPISessionDataTask
}
extension FavoriteAPIv1: ReactiveCompatible {}
extension Reactive where Base: FavoriteAPIv1 {
public func postFavorite<Response: Decodable>(_ request: PostFavoriteRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postFavorite(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postUnFavorite<Response: Decodable>(_ request: PostUnFavoriteRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postUnFavorite(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getFavorites<Response: Decodable>(_ request: GetFavoritesRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getFavorites(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension FriendshipsAPIv1: ReactiveCompatible {}
extension Reactive where Base: FriendshipsAPIv1 {
public func getFollowerIDs<Response: Decodable>(_ request: GetFollowersIDsRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getFollowerIDs(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getFollowers<Response: Decodable>(_ request: GetFollowersListRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getFollowers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getFriendIDs<Response: Decodable>(_ request: GetFriendsIDsRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getFriendIDs(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getFriends<Response: Decodable>(_ request: GetFriendsListRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getFriends(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getFriendshipsIncoming<Response: Decodable>(_ request: GetFriendshipsIncomingRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getFriendshipsIncoming(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getFriendshipsLookup<Response: Decodable>(_ request: GetFriendshipsLookupRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getFriendshipsLookup(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getFriendshipsNoRetweetsIDs<Response: Decodable>(_ request: GetFriendshipsNoRetweetsIDsRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getFriendshipsNoRetweetsIDs(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getFriendshipsOutgoing<Response: Decodable>(_ request: GetFriendshipsOutgoingRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getFriendshipsOutgoing(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getFriendships<Response: Decodable>(_ request: GetFriendshipsShowRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getFriendships(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postFollowUser<Response: Decodable>(_ request: PostFriendshipsCreateRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postFollowUser(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postUnfollowUser<Response: Decodable>(_ request: PostFriendshipsDestroyRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postUnfollowUser(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postFriendshipsUpdate<Response: Decodable>(_ request: PostFriendshipsUpdateRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postFriendshipsUpdate(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension GeoAPIv1: ReactiveCompatible {}
extension Reactive where Base: GeoAPIv1 {
public func getReverseGeocode<Response: Decodable>(_ request: GetGeoReverseGeocodeRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getReverseGeocode(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getGeoPlace<Response: Decodable>(_ request: GetGeoPlaceIDRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getGeoPlace(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func searchGeo<Response: Decodable>(_ request: GetGeoSearchRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.searchGeo(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension HelpAPIv1: ReactiveCompatible {}
extension Reactive where Base: HelpAPIv1 {
public func getSupportedLanguages<Response: Decodable>(_ request: GetHelpLanguagesRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getSupportedLanguages(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension ListAPIv1: ReactiveCompatible {}
extension Reactive where Base: ListAPIv1 {
public func getLists<Response: Decodable>(_ request: GetListsListRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getLists(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getListMembers<Response: Decodable>(_ request: GetListsMembersRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getListMembers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getListMember<Response: Decodable>(_ request: GetListsMembersShowRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getListMember(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getListMemberships<Response: Decodable>(_ request: GetListsMembershipsRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getListMemberships(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getListOwnerships<Response: Decodable>(_ request: GetListsOwnershipsRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getListOwnerships(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getList<Response: Decodable>(_ request: GetListsShowRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getListStatuses<Response: Decodable>(_ request: GetListsStatusesRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getListStatuses(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getListSubscribers<Response: Decodable>(_ request: GetListsSubscribersRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getListSubscribers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getListSubscriber<Response: Decodable>(_ request: GetListsSubscribersShowRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getListSubscriber(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getListSubscriptions<Response: Decodable>(_ request: GetListsSubscriptionsRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getListSubscriptions(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postCreateList<Response: Decodable>(_ request: PostListsCreateRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postCreateList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postDestroyList<Response: Decodable>(_ request: PostListsDestroyRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postDestroyList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postAddListMember<Response: Decodable>(_ request: PostListsMembersCreateRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postAddListMember(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postAddListMembers<Response: Decodable>(_ request: PostListsMembersCreateAllRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postAddListMembers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postRemoveListMember<Response: Decodable>(_ request: PostListsMembersDestroyRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postRemoveListMember(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postRemoveListMembers<Response: Decodable>(_ request: PostListsMembersDestroyAllRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postRemoveListMembers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postSubscribeList<Response: Decodable>(_ request: PostListsSubscribersCreateRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postSubscribeList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postUnsubscribeList<Response: Decodable>(_ request: PostListsSubscribersDestroyRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postUnsubscribeList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postUpdateList<Response: Decodable>(_ request: PostListsUpdateRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postUpdateList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension MediaAPIv1: ReactiveCompatible {}
extension Reactive where Base: MediaAPIv1 {
public func getUploadMediaStatus<Response: Decodable>(_ request: GetUploadMediaStatusRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getUploadMediaStatus(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func uploadMediaInit<Response: Decodable>(_ request: UploadMediaInitRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.uploadMediaInit(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func uploadMediaAppend<Response: Decodable>(_ request: UploadMediaAppendRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.uploadMediaAppend(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
// Ignore: uploadMediaAppendSplitChunks(_:maxBytes:) -> [TwitterAPISessionSpecializedTask<String /* mediaID */>]
public func uploadMediaFinalize<Response: Decodable>(_ request: UploadMediaFinalizeRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.uploadMediaFinalize(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
// Ignore: uploadMedia(_:completionHandler:) -> Void
// Ignore: waitMediaProcessing(mediaID:initialWaitSec:completionHandler:) -> Void
// Ignore: waitMediaProcessing(mediaID:completionHandler:) -> Void
// Ignore: createMediaMetadata(_:) -> TwitterAPISessionDataTask
// Ignore: createSubtitle(_:) -> TwitterAPISessionDataTask
// Ignore: deleteSubtitle(_:) -> TwitterAPISessionDataTask
}
extension RetweetAPIv1: ReactiveCompatible {}
extension Reactive where Base: RetweetAPIv1 {
public func postRetweet<Response: Decodable>(_ request: PostRetweetRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postRetweet(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postUnRetweet<Response: Decodable>(_ request: PostUnRetweetRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postUnRetweet(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getRetweets<Response: Decodable>(_ request: GetRetweetsRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getRetweets(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getRetweetsOfMe<Response: Decodable>(_ request: GetRetweetsOfMeRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getRetweetsOfMe(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getRetweeters<Response: Decodable>(_ request: GetRetweetersRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getRetweeters(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension SearchAPIv1: ReactiveCompatible {}
extension Reactive where Base: SearchAPIv1 {
public func searchTweets<Response: Decodable>(_ request: GetSearchTweetsRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.searchTweets(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getSavedSearches<Response: Decodable>(_ request: GetSavedSearchesListRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getSavedSearches(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postCreateSavedSearch<Response: Decodable>(_ request: PostSavedSearchesCreateRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postCreateSavedSearch(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postDestroySavedSearch<Response: Decodable>(_ request: PostSavedSearchesCreateRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postDestroySavedSearch(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension TimelineAPIv1: ReactiveCompatible {}
extension Reactive where Base: TimelineAPIv1 {
public func getHomeTimeline<Response: Decodable>(_ request: GetStatusesHomeTimelineRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getHomeTimeline(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getMentionsTimeline<Response: Decodable>(_ request: GetStatusesMentionsTimelineRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getMentionsTimeline(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getUserTimeline<Response: Decodable>(_ request: GetStatusesUserTimelineRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getUserTimeline(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension TrendAPIv1: ReactiveCompatible {}
extension Reactive where Base: TrendAPIv1 {
public func getTrendsAvailable<Response: Decodable>(_ request: GetTrendsAvailableRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getTrendsAvailable(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getTrendsClosest<Response: Decodable>(_ request: GetTrendsClosestRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getTrendsClosest(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getTrends<Response: Decodable>(_ request: GetTrendsPlaceRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getTrends(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension TweetAPIv1: ReactiveCompatible {}
extension Reactive where Base: TweetAPIv1 {
public func postUpdateStatus<Response: Decodable>(_ request: PostStatusesUpdateRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postUpdateStatus(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postDestroyStatus<Response: Decodable>(_ request: PostStatusesDestroyRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postDestroyStatus(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getShowStatus<Response: Decodable>(_ request: GetStatusesShowRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getShowStatus(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getLookupStatuses<Response: Decodable>(_ request: GetStatusesLookupRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getLookupStatuses(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension UserAPIv1: ReactiveCompatible {}
extension Reactive where Base: UserAPIv1 {
public func getUsers<Response: Decodable>(_ request: GetUsersLookupRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getUsers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getUser<Response: Decodable>(_ request: GetUsersShowRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getUser(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func searchUser<Response: Decodable>(_ request: GetUsersShowRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.searchUser(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getUserProfileBanner<Response: Decodable>(_ request: GetUsersProfileBannerRequestV1, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getUserProfileBanner(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
// MARK: - TwitterAPIv2
extension BlockAndMuteAPIv2: ReactiveCompatible {}
extension Reactive where Base: BlockAndMuteAPIv2 {
public func getBlockUsers<Response: Decodable>(_ request: GetUsersBlockingRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getBlockUsers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func blockUser<Response: Decodable>(_ request: PostUsersBlockingRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.blockUser(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func unblockUser<Response: Decodable>(_ request: DeleteUsersBlockingRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.unblockUser(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getMuteUsers<Response: Decodable>(_ request: GetUsersMutingRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getMuteUsers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func muteUser<Response: Decodable>(_ request: PostUsersMutingRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.muteUser(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func unmuteUser<Response: Decodable>(_ request: DeleteUsersMutingRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.unmuteUser(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension BookmarksAPIv2: ReactiveCompatible {}
extension Reactive where Base: BookmarksAPIv2 {
public func getBookmarks<Response: Decodable>(_ request: GetUsersBookmarksRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getBookmarks(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func createBookmark<Response: Decodable>(_ request: PostUsersBookmarksRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.createBookmark(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func deleteBookmark<Response: Decodable>(_ request: DeleteUsersBookmarksRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.deleteBookmark(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension ComplianceAPIv2: ReactiveCompatible {}
extension Reactive where Base: ComplianceAPIv2 {
public func getComplianceJob<Response: Decodable>(_ request: GetComplianceJobRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getComplianceJob(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getComplianceJobj<Response: Decodable>(_ request: GetComplianceJobsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getComplianceJobj(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func createComplianceJob<Response: Decodable>(_ request: PostComplianceJobsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.createComplianceJob(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension FriendshipsAPIv2: ReactiveCompatible {}
extension Reactive where Base: FriendshipsAPIv2 {
public func getFollowing<Response: Decodable>(_ request: GetUsersFollowingRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getFollowing(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getFollowers<Response: Decodable>(_ request: GetUsersFollowersRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getFollowers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func follow<Response: Decodable>(_ request: PostUsersFollowingRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.follow(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func unfollow<Response: Decodable>(_ request: DeleteUsersFollowingRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.unfollow(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension LikeAPIv2: ReactiveCompatible {}
extension Reactive where Base: LikeAPIv2 {
public func getLikingUsers<Response: Decodable>(_ request: GetTweetsLikingUsersRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getLikingUsers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getLikedTweets<Response: Decodable>(_ request: GetUsersLikedTweetsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getLikedTweets(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postLike<Response: Decodable>(_ request: PostUsersLikesRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postLike(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func deleteLike<Response: Decodable>(_ request: DeleteUsersLikesRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.deleteLike(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension ListAPIv2: ReactiveCompatible {}
extension Reactive where Base: ListAPIv2 {
public func getListTweets<Response: Decodable>(_ request: GetListsTweetsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getListTweets(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getList<Response: Decodable>(_ request: GetListRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getLists<Response: Decodable>(_ request: GetUsersOwnedListsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getLists(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func followList<Response: Decodable>(_ request: PostUsersFollowedListsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.followList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func unfollowList<Response: Decodable>(_ request: DeleteUsersFollowedListsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.unfollowList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func listFollowers<Response: Decodable>(_ request: GetListsFollowersRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.listFollowers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func followedLists<Response: Decodable>(_ request: GetUsersFollowedListsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.followedLists(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func addListMember<Response: Decodable>(_ request: PostListsMembersRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.addListMember(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func removeListMember<Response: Decodable>(_ request: DeleteListsMembersRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.removeListMember(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getListMemberships<Response: Decodable>(_ request: GetUsersListMembershipsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getListMemberships(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getListMembers<Response: Decodable>(_ request: GetListsMembersRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getListMembers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func createList<Response: Decodable>(_ request: PostListsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.createList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func updateList<Response: Decodable>(_ request: PutListRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.updateList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func deleteList<Response: Decodable>(_ request: DeleteListRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.deleteList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func pinnedList<Response: Decodable>(_ request: GetUsersPinnedListsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.pinnedList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func pinList<Response: Decodable>(_ request: PostUsersPinnedListsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.pinList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func unpinList<Response: Decodable>(_ request: DeleteUsersPinnedListsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.unpinList(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension RetweetAPIv2: ReactiveCompatible {}
extension Reactive where Base: RetweetAPIv2 {
public func getRetweetedBy<Response: Decodable>(_ request: GetTweetsRetweetedByRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getRetweetedBy(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postRetweet<Response: Decodable>(_ request: PostUsersRetweetsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postRetweet(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func deleteRetweet<Response: Decodable>(_ request: DeleteUsersRetweetsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.deleteRetweet(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension SearchAPIv2: ReactiveCompatible {}
extension Reactive where Base: SearchAPIv2 {
public func searchTweetsRecent<Response: Decodable>(_ request: GetTweetsSearchRecentRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.searchTweetsRecent(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func searchTweetsAll<Response: Decodable>(_ request: GetTweetsSearchAllRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.searchTweetsAll(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension SpacesAPIv2: ReactiveCompatible {}
extension Reactive where Base: SpacesAPIv2 {
public func getSpace<Response: Decodable>(_ request: GetSpaceRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getSpace(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getSpaces<Response: Decodable>(_ request: GetSpacesRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getSpaces(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getSpacesByCreators<Response: Decodable>(_ request: GetSpacesByCreatorIDsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getSpacesByCreators(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getSpacesBuyers<Response: Decodable>(_ request: GetSpacesBuyersRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getSpacesBuyers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getSPacesTweets<Response: Decodable>(_ request: GetSpacesTweetsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getSPacesTweets(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func searchSpaces<Response: Decodable>(_ request: GetSpacesSearchRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.searchSpaces(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension StreamAPIv2: ReactiveCompatible {}
extension Reactive where Base: StreamAPIv2 {
// Ignore: sampleStream(_:) -> TwitterAPISessionStreamTask
public func getSearchStreamRules<Response: Decodable>(_ request: GetTweetsSearchStreamRulesRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getSearchStreamRules(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postSearchStreamRules<Response: Decodable>(_ request: PostTweetsSearchStreamRulesRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postSearchStreamRules(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
// Ignore: searchStream(_:) -> TwitterAPISessionStreamTask
}
extension TimelineAPIv2: ReactiveCompatible {}
extension Reactive where Base: TimelineAPIv2 {
public func getUserTweets<Response: Decodable>(_ request: GetUsersTweetsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getUserTweets(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getUserMensions<Response: Decodable>(_ request: GetUsersMentionsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getUserMensions(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getUserReverseChronological<Response: Decodable>(_ request: GetUsersTimelinesReverseChronologicalRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getUserReverseChronological(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension TweetAPIv2: ReactiveCompatible {}
extension Reactive where Base: TweetAPIv2 {
public func getTweets<Response: Decodable>(_ request: GetTweetsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getTweets(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getTweet<Response: Decodable>(_ request: GetTweetRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getTweet(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getQuoteTweets<Response: Decodable>(_ request: GetTweetsQuoteTweetsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getQuoteTweets(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func deleteTweet<Response: Decodable>(_ request: DeleteTweetRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.deleteTweet(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func postTweet<Response: Decodable>(_ request: PostTweetsRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.postTweet(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func hideReply<Response: Decodable>(_ request: PutTweetsHiddenRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.hideReply(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension TweetCountAPIv2: ReactiveCompatible {}
extension Reactive where Base: TweetCountAPIv2 {
public func getTweetCountRecent<Response: Decodable>(_ request: GetTweetsCountsRecentRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getTweetCountRecent(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getTweetCountAll<Response: Decodable>(_ request: GetTweetsCountsAllRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getTweetCountAll(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
extension UserAPIv2: ReactiveCompatible {}
extension Reactive where Base: UserAPIv2 {
public func getUser<Response: Decodable>(_ request: GetUserRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getUser(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getUsers<Response: Decodable>(_ request: GetUsersRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getUsers(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getUserByUsername<Response: Decodable>(_ request: GetUsersByUsernameRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getUserByUsername(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getUsersByUsernames<Response: Decodable>(_ request: GetUsersByRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getUsersByUsernames(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
public func getMe<Response: Decodable>(_ request: GetUsersMeRequestV2, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.getMe(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
}
#endif
Raw
3_gen-rxswift-extensions.stencil
#if canImport(RxSwift)
import Foundation
import TwitterAPIKit
import RxSwift
{% set Classes "TwitterAuthAPI,TwitterAPIv1,TwitterAPIv2"|split:"," %}
{% for apiClass in Classes %}
// MARK: - {{apiClass}}
{% for property in type[apiClass].variables where property.readAccess == "public" %}
extension {{property.typeName}}: ReactiveCompatible {}
extension Reactive where Base: {{property.typeName}} {
{% for method in property.type.methods where method.accessLevel == "public" %}
{% if method.returnTypeName.name == "TwitterAPISessionJSONTask" %}
public func {{method.callName}}<Response: Decodable>({% for argument in method.parameters %}{{argument.asSource}}{{ ', ' if not forloop.last }}{% endfor %}, responseType: Response.Type, decoder: JSONDecoder = TwitterAPIClient.defaultJSONDecoder) -> Single<(response: Response, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.{{method.callName}}(request).responseDecodable(type: responseType, decoder: decoder) { response in
let result = response.result
.map { decoded in return (response: decoded, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
{% elif method.returnTypeName.name|hasPrefix:"TwitterAPISessionSpecializedTask" %}
public func {{method.callName}}({% for argument in method.parameters %}{{argument.asSource}}{{ ', ' if not forloop.last }}{% endfor %}) -> Single<(response: {{method.returnTypeName.generic.typeParameters[0].typeName}}, rateLimit: TwitterAPIKit.TwitterRateLimit?)> {
return .create { single in
let task = base.{{method.callName}}(request).responseObject { response in
let result = response.result
.map { obj in return (response: obj, rateLimit: response.rateLimit) }
.mapError { return $0 as Error }
single(result)
}
return Disposables.create {
task.cancel()
}
}
}
{% else %}
// Ignore: {{method.selectorName}} -> {{method.returnTypeName}}
{% endif %}
{% endfor %}
}
{% endfor %}
{% endfor %}
#endif
{# Run: sourcery --sources Sources/TwitterAPIKit/ --templates ./gen-rxswift-extensions.stencil --output Sources/TwitterAPIKit/TwitterAPIKit+RxSwift.generated.swift #}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment