TwitterMediaClient

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

val chunkSize: Int

def clone(): AnyRef

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

lazy val consumerTokenKey: String

lazy val consumerTokenSecret: String

def createMediaDescription(media_id: Long, description: String): Future[Unit]

This endpoint can be used to provide additional information about the uploaded media_id.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit val executionContext: ExecutionContext

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

implicit def header2AddHeader(header: HttpHeader): RequestTransformer

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

final def notify(): Unit

final def notifyAll(): Unit

lazy val oauthProvider: OAuth2Provider

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

def statusMedia(media_id: Long): Future[MediaDetails]

Returns the status of a media upload for pulling purposes.

val statusStreamingTwitterUrl: String

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

def toBase64(data: Array[Byte]): String

def toHmacSha1(base: String, secret: String): String

def toSha1(base: String): String

def toString(): String

val twitterVersion: String

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

def uploadMediaFromFile(file: File, additional_owners: Seq[Long] = Seq.empty): Future[MediaDetails]

Uploads media asynchronously from a file.

def uploadMediaFromInputStream(inputStream: InputStream, size: Long, media_type: MediaType, filename: Option[String] = None, additional_owners: Seq[Long] = Seq.empty): Future[MediaDetails]

Uploads media asynchronously from an input stream.

def uploadMediaFromPath(filePath: String, additional_owners: Seq[Long] = Seq.empty): Future[MediaDetails]

Uploads media asynchronously from an absolute file path.

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]