TwitterFriendshipClient

abstract val accessToken: AccessToken

abstract val consumerToken: ConsumerToken

implicit abstract def system: ActorSystem

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val Delete: OAuthRequestBuilder

val Get: OAuthRequestBuilder

val Head: OAuthRequestBuilder

val Options: OAuthRequestBuilder

val Patch: OAuthRequestBuilder

val Post: OAuthRequestBuilder

val Put: OAuthRequestBuilder

lazy val accessTokenKey: String

lazy val accessTokenSecret: String

def addCredentials(credentials: HttpCredentials): RequestTransformer

def addHeader(headerName: String, headerValue: String): RequestTransformer

def addHeader(header: HttpHeader): RequestTransformer

def addHeaders(first: HttpHeader, more: HttpHeader*): RequestTransformer

val apiTwitterUrl: String

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def connection(implicit request: HttpRequest): Flow[HttpRequest, HttpResponse, Future[OutgoingConnection]]

lazy val consumerTokenKey: String

lazy val consumerTokenSecret: String

def disableDeviceNotificationsForUser(screen_name: String): Future[Relationship]

Allows one to disable device notifications from the specified user.

def disableDeviceNotificationsForUserId(user_id: Long): Future[Relationship]

Allows one to disable device notifications from the specified user id.

def disableRetweetsNotificationsForUser(screen_name: String): Future[Relationship]

Allows one to disable retweets from the specified user.

def disableRetweetsNotificationsForUserId(user_id: Long): Future[Relationship]

Allows one to disable retweets from the specified user id.

def enableDeviceNotificationsForUser(screen_name: String): Future[Relationship]

Allows one to enable device notifications from the specified user.

def enableDeviceNotificationsForUserId(user_id: Long): Future[Relationship]

Allows one to enable device notifications from the specified user id.

def enableRetweetsNotificationsForUser(screen_name: String): Future[Relationship]

Allows one to enable retweets from the specified user.

def enableRetweetsNotificationsForUserId(user_id: Long): Future[Relationship]

Allows one to enable retweets from the specified user id.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit val executionContext: ExecutionContext

def finalize(): Unit

def followUser(screen_name: String, notify: Boolean = true): Future[User]

Allows the authenticating users to follow the specified user.

def followUserId(user_id: Long, notify: Boolean = true): Future[User]

Allows the authenticating users to follow the specified user id.

final def getClass(): Class[_]

def hashCode(): Int

implicit def header2AddHeader(header: HttpHeader): RequestTransformer

def incomingFriendshipIds(cursor: Long = 1): Future[UserIds]

Returns a collection of numeric IDs for every user who has a pending request to follow the authenticating user.

def incomingFriendshipStringifiedIds(cursor: Long = 1): Future[UserStringifiedIds]

Returns a collection of numeric stringified IDs for every user who has a pending request to follow the authenticating user.

final def isInstanceOf[T0]: Boolean

implicit lazy val json4sFormats: Formats

implicit def json4sMarshaller[A <: AnyRef](implicit serialization: Serialization, formats: Formats, shouldWritePretty: ShouldWritePretty): ToEntityMarshaller[A]

implicit def json4sUnmarshaller[A](implicit arg0: Manifest[A], serialization: Serialization, formats: Formats): FromEntityUnmarshaller[A]

implicit val log: LoggingAdapter

def logRequest(logFun: (HttpRequest) ⇒ Unit): (HttpRequest) ⇒ HttpRequest

def logRequest(log: LoggingAdapter, level: LogLevel): (HttpRequest) ⇒ HttpRequest

def logRequest(implicit request: HttpRequest): HttpRequest

def logRequestResponse(requestStartTime: Long)(implicit request: HttpRequest): (HttpResponse) ⇒ HttpResponse

def logValue[T](logFun: (T) ⇒ Unit): (T) ⇒ T

def logValue[T](log: LoggingAdapter, level: LogLevel): (T) ⇒ T

def mapHeaders(f: (Seq[HttpHeader]) ⇒ Seq[HttpHeader]): RequestTransformer

implicit val materializer: ActorMaterializer

val mediaTwitterUrl: String

final def ne(arg0: AnyRef): Boolean

def noRetweetsUserIds(): Future[Seq[Long]]

Returns a collection of user ids that the currently authenticated user does not want to receive retweets from.

def noRetweetsUserStringifiedIds(): Future[Seq[String]]

Returns a collection of user stringified ids that the currently authenticated user does not want to receive retweets from.

final def notify(): Unit

final def notifyAll(): Unit

lazy val oauthProvider: OAuth2Provider

def outgoingFriendshipIds(cursor: Long = 1): Future[UserIds]

Returns a collection of numeric IDs for every protected user for whom the authenticating user has a pending follow request.

def outgoingFriendshipStringifiedIds(cursor: Long = 1): Future[UserStringifiedIds]

Returns a collection of numeric stringified IDs for every protected user for whom the authenticating user has a pending follow request.

def relationshipBetweenUserIds(source_id: Long, target_id: Long): Future[Relationship]

Returns detailed information about the relationship between two arbitrary users ids.

def relationshipBetweenUsers(source_screen_name: String, target_screen_name: String): Future[Relationship]

Returns detailed information about the relationship between two arbitrary users.

def relationshipsWithUserIds(user_ids: Long*): Future[Seq[LookupRelationship]]

Returns the relationships of the authenticating user of up to 100 user ids.

def relationshipsWithUsers(screen_names: String*): Future[Seq[LookupRelationship]]

Returns the relationships of the authenticating user of up to 100 user screen names.

def removeHeader(clazz: Class[_]): RequestTransformer

def removeHeader[T <: HttpHeader](implicit arg0: ClassTag[T]): RequestTransformer

def removeHeader(headerName: String): RequestTransformer

def removeHeaders(names: String*): RequestTransformer

def sendAndReceive[T](request: HttpRequest, f: (HttpResponse) ⇒ Future[T]): Future[T]

def sendReceiveAs[T](httpRequest: HttpRequest)(implicit arg0: Manifest[T]): Future[T]

implicit val serialization: Serialization.type

val siteStreamingTwitterUrl: String

val statusStreamingTwitterUrl: String

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

val twitterVersion: String

def unfollowUser(screen_name: String): Future[User]

Allows the authenticating users to unfollow the specified user.

def unfollowUserId(user_id: Long): Future[User]

Allows the authenticating users to unfollow the specified user id.

def unmarshal[T](requestStartTime: Long, f: (HttpResponse) ⇒ Future[T])(implicit request: HttpRequest, response: HttpResponse): Future[T]

val userStreamingTwitterUrl: String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

val withLogRequest: Boolean

val withLogRequestResponse: Boolean

def withOAuthHeader: (HttpRequest) ⇒ Future[HttpRequest]

def withSimpleOAuthHeader: (HttpRequest) ⇒ Future[HttpRequest]

def getIncomingFriendshipIds(cursor: Long = 1): Future[UserIds]

def getIncomingFriendshipStringifiedIds(cursor: Long = 1): Future[UserStringifiedIds]

def getNoRetweetsUserIds(): Future[Seq[Long]]

def getNoRetweetsUserStringifiedIds(): Future[Seq[String]]

def getOutgoingFriendshipIds(cursor: Long = 1): Future[UserIds]

def getOutgoingFriendshipStringifiedIds(cursor: Long = 1): Future[UserStringifiedIds]

def getRelationshipBetweenUserIds(source_id: Long, target_id: Long): Future[Relationship]

def getRelationshipBetweenUsers(source_screen_name: String, target_screen_name: String): Future[Relationship]

def getRelationshipsWithUserIds(user_ids: Long*): Future[Seq[LookupRelationship]]

def getRelationshipsWithUsers(screen_names: String*): Future[Seq[LookupRelationship]]