rebuilt

samples/client/petstore/async-scala/src/main/scala/io/swagger/client/SwaggerClient.scala

@@ -1,18 +1,27 @@
 package io.swagger.client
 
+import io.swagger.client.api._
+
+import io.swagger.client._
+
 import java.io.Closeable
 
 class SwaggerClient(config: SwaggerConfig) extends Closeable {
-  val locator = config.locator
-  val name = config.name
-  val user = new UserApi(client, config)
-  val pet = new PetApi(client, config)
-  val store = new StoreApi(client, config)
-  private[this] val client = transportClient
+val locator = config.locator
+val name = config.name
 
-  def close() {
-    client.close()
-  }
+private[this] val client = transportClient
 
-  protected def transportClient: TransportClient = new RestClient(config)
+protected def transportClient: TransportClient = new RestClient(config)
+
+    val user = new UserApi(client, config)
+
+    val pet = new PetApi(client, config)
+
+    val store = new StoreApi(client, config)
+
+
+def close() {
+client.close()
+}
 }

samples/client/petstore/async-scala/src/main/scala/io/swagger/client/api/PetApi.scala

@@ -1,190 +1,193 @@
 package io.swagger.client.api
 
+import io.swagger.client.model.Pet
 import java.io.File
+import io.swagger.client._
+import scala.concurrent.{ Future, Await }
+import scala.concurrent.duration._
+import collection.mutable
 
-import scala.collection.mutable
-import scala.concurrent.Future
+    class PetApi(client: TransportClient, config: SwaggerConfig) extends ApiClient(client, config) {
 
-class PetApi(client: TransportClient, config: SwaggerConfig) extends ApiClient(client, config) {
+    
+        def updatePet(body: Pet)(implicit reader: ClientResponseReader[Unit], writer: RequestWriter[Pet]): Future[Unit] = {
+        // create path and map variables
+        val path = (addFmt("/pet"))
 
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
 
-  def updatePet(body: Pet)(implicit reader: ClientResponseReader[Unit], writer: RequestWriter[Pet]): Future[Unit] = {
-    // create path and map variables
-    val path = (addFmt("/pet"))
+        
 
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
+        
 
+        
 
+        val resFuture = client.submit("PUT", path, queryParams.toMap, headerParams.toMap, writer.write(body))
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
 
+    
+        def addPet(body: Pet)(implicit reader: ClientResponseReader[Unit], writer: RequestWriter[Pet]): Future[Unit] = {
+        // create path and map variables
+        val path = (addFmt("/pet"))
 
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
 
+        
 
+        
+
+        
+
+        val resFuture = client.submit("POST", path, queryParams.toMap, headerParams.toMap, writer.write(body))
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
+        def findPetsByStatus(status: List[String] = available)(implicit reader: ClientResponseReader[List[Pet]]): Future[List[Pet]] = {
+        // create path and map variables
+        val path = (addFmt("/pet/findByStatus"))
+
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
+
+        
+
+        
+            if(status != null)   queryParams += "status" -> status.toString
+
+        
+
+        val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
+        def findPetsByTags(tags: List[String])(implicit reader: ClientResponseReader[List[Pet]]): Future[List[Pet]] = {
+        // create path and map variables
+        val path = (addFmt("/pet/findByTags"))
+
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
+
+        
+
+        
+            if(tags != null)   queryParams += "tags" -> tags.toString
+
+        
+
+        val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
+        def getPetById(petId: Long)(implicit reader: ClientResponseReader[Pet]): Future[Pet] = {
+        // create path and map variables
+        val path = (addFmt("/pet/{petId}")
+            replaceAll ("\\{" + "petId" + "\\}",petId.toString))
+
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
+
+        
+
+        
+
+        
+
+        val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
+        def updatePetWithForm(petId: String,
+        name: String,
+        status: String)(implicit reader: ClientResponseReader[Unit]): Future[Unit] = {
+        // create path and map variables
+        val path = (addFmt("/pet/{petId}")
+            replaceAll ("\\{" + "petId" + "\\}",petId.toString))
+
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
+
+        
+
+        
+
+        
+
+        val resFuture = client.submit("POST", path, queryParams.toMap, headerParams.toMap, "")
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
+        def deletePet(apiKey: String,
+        petId: Long)(implicit reader: ClientResponseReader[Unit]): Future[Unit] = {
+        // create path and map variables
+        val path = (addFmt("/pet/{petId}")
+            replaceAll ("\\{" + "petId" + "\\}",petId.toString))
+
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
+
+        
+
+        
+
+        headerParams += "api_key" -> apiKey.toString
+
+        val resFuture = client.submit("DELETE", path, queryParams.toMap, headerParams.toMap, "")
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
+        def uploadFile(petId: Long,
+        additionalMetadata: String,
+        file: File)(implicit reader: ClientResponseReader[Unit]): Future[Unit] = {
+        // create path and map variables
+        val path = (addFmt("/pet/{petId}/uploadImage")
+            replaceAll ("\\{" + "petId" + "\\}",petId.toString))
+
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
+
+        
+
+        
+
+        
+
+        val resFuture = client.submit("POST", path, queryParams.toMap, headerParams.toMap, "")
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
 
-    val resFuture = client.submit("PUT", path, queryParams.toMap, headerParams.toMap, writer.write(body))
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
     }
-  }
-
-
-  def addPet(body: Pet)(implicit reader: ClientResponseReader[Unit], writer: RequestWriter[Pet]): Future[Unit] = {
-    // create path and map variables
-    val path = (addFmt("/pet"))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-
-
-
-    val resFuture = client.submit("POST", path, queryParams.toMap, headerParams.toMap, writer.write(body))
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-  def findPetsByStatus(status: List[String])(implicit reader: ClientResponseReader[List[Pet]]): Future[List[Pet]] = {
-    // create path and map variables
-    val path = (addFmt("/pet/findByStatus"))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-    if (status != null) queryParams += "status" -> status.toString
-
-
-
-    val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-  def findPetsByTags(tags: List[String])(implicit reader: ClientResponseReader[List[Pet]]): Future[List[Pet]] = {
-    // create path and map variables
-    val path = (addFmt("/pet/findByTags"))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-    if (tags != null) queryParams += "tags" -> tags.toString
-
-
-
-    val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-  def getPetById(petId: Long)(implicit reader: ClientResponseReader[Pet]): Future[Pet] = {
-    // create path and map variables
-    val path = (addFmt("/pet/{petId}")
-      replaceAll("\\{" + "petId" + "\\}", petId.toString))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-
-
-
-    val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-  def updatePetWithForm(petId: String,
-                        name: String,
-                        status: String)(implicit reader: ClientResponseReader[Unit]): Future[Unit] = {
-    // create path and map variables
-    val path = (addFmt("/pet/{petId}")
-      replaceAll("\\{" + "petId" + "\\}", petId.toString))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-
-
-
-    val resFuture = client.submit("POST", path, queryParams.toMap, headerParams.toMap, "")
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-  def deletePet(api_key: String,
-                petId: Long)(implicit reader: ClientResponseReader[Unit]): Future[Unit] = {
-    // create path and map variables
-    val path = (addFmt("/pet/{petId}")
-      replaceAll("\\{" + "petId" + "\\}", petId.toString))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-
-    headerParams += "api_key" -> api_key.toString
-
-    val resFuture = client.submit("DELETE", path, queryParams.toMap, headerParams.toMap, "")
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-  def uploadFile(petId: Long,
-                 additionalMetadata: String,
-                 file: File)(implicit reader: ClientResponseReader[Unit]): Future[Unit] = {
-    // create path and map variables
-    val path = (addFmt("/pet/{petId}/uploadImage")
-      replaceAll("\\{" + "petId" + "\\}", petId.toString))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-
-
-
-    val resFuture = client.submit("POST", path, queryParams.toMap, headerParams.toMap, "")
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-}

samples/client/petstore/async-scala/src/main/scala/io/swagger/client/api/StoreApi.scala

@@ -1,95 +1,99 @@
 package io.swagger.client.api
 
-import scala.collection.mutable
-import scala.concurrent.Future
+import io.swagger.client.model.Order
+import io.swagger.client._
+import scala.concurrent.{ Future, Await }
+import scala.concurrent.duration._
+import collection.mutable
 
-class StoreApi(client: TransportClient, config: SwaggerConfig) extends ApiClient(client, config) {
+    class StoreApi(client: TransportClient, config: SwaggerConfig) extends ApiClient(client, config) {
 
+    
+        def getInventory()(implicit reader: ClientResponseReader[Map[String, Integer]]): Future[Map[String, Integer]] = {
+        // create path and map variables
+        val path = (addFmt("/store/inventory"))
 
-  def getInventory()(implicit reader: ClientResponseReader[Map[String, Integer]]): Future[Map[String, Integer]] = {
-    // create path and map variables
-    val path = (addFmt("/store/inventory"))
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
 
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
+        
 
+        
 
+        
 
+        val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
 
+    
+        def placeOrder(body: Order)(implicit reader: ClientResponseReader[Order], writer: RequestWriter[Order]): Future[Order] = {
+        // create path and map variables
+        val path = (addFmt("/store/order"))
 
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
 
+        
+
+        
+
+        
+
+        val resFuture = client.submit("POST", path, queryParams.toMap, headerParams.toMap, writer.write(body))
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
+        def getOrderById(orderId: String)(implicit reader: ClientResponseReader[Order]): Future[Order] = {
+        // create path and map variables
+        val path = (addFmt("/store/order/{orderId}")
+            replaceAll ("\\{" + "orderId" + "\\}",orderId.toString))
+
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
+
+        
+
+        
+
+        
+
+        val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
+        def deleteOrder(orderId: String)(implicit reader: ClientResponseReader[Unit]): Future[Unit] = {
+        // create path and map variables
+        val path = (addFmt("/store/order/{orderId}")
+            replaceAll ("\\{" + "orderId" + "\\}",orderId.toString))
+
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
+
+        
+
+        
+
+        
+
+        val resFuture = client.submit("DELETE", path, queryParams.toMap, headerParams.toMap, "")
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
 
-    val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
     }
-  }
-
-
-  def placeOrder(body: Order)(implicit reader: ClientResponseReader[Order], writer: RequestWriter[Order]): Future[Order] = {
-    // create path and map variables
-    val path = (addFmt("/store/order"))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-
-
-
-    val resFuture = client.submit("POST", path, queryParams.toMap, headerParams.toMap, writer.write(body))
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-  def getOrderById(orderId: String)(implicit reader: ClientResponseReader[Order]): Future[Order] = {
-    // create path and map variables
-    val path = (addFmt("/store/order/{orderId}")
-      replaceAll("\\{" + "orderId" + "\\}", orderId.toString))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-
-
-
-    val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-  def deleteOrder(orderId: String)(implicit reader: ClientResponseReader[Unit]): Future[Unit] = {
-    // create path and map variables
-    val path = (addFmt("/store/order/{orderId}")
-      replaceAll("\\{" + "orderId" + "\\}", orderId.toString))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-
-
-
-    val resFuture = client.submit("DELETE", path, queryParams.toMap, headerParams.toMap, "")
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-}

samples/client/petstore/async-scala/src/main/scala/io/swagger/client/api/UserApi.scala

@@ -1,184 +1,188 @@
 package io.swagger.client.api
 
-import scala.collection.mutable
-import scala.concurrent.Future
+import io.swagger.client.model.User
+import io.swagger.client._
+import scala.concurrent.{ Future, Await }
+import scala.concurrent.duration._
+import collection.mutable
 
-class UserApi(client: TransportClient, config: SwaggerConfig) extends ApiClient(client, config) {
+    class UserApi(client: TransportClient, config: SwaggerConfig) extends ApiClient(client, config) {
 
+    
+        def createUser(body: User)(implicit reader: ClientResponseReader[Unit], writer: RequestWriter[User]): Future[Unit] = {
+        // create path and map variables
+        val path = (addFmt("/user"))
 
-  def createUser(body: User)(implicit reader: ClientResponseReader[Unit], writer: RequestWriter[User]): Future[Unit] = {
-    // create path and map variables
-    val path = (addFmt("/user"))
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
 
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
+        
 
+        
 
+        
 
+        val resFuture = client.submit("POST", path, queryParams.toMap, headerParams.toMap, writer.write(body))
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
 
+    
+        def createUsersWithArrayInput(body: List[User])(implicit reader: ClientResponseReader[Unit], writer: RequestWriter[List[User]]): Future[Unit] = {
+        // create path and map variables
+        val path = (addFmt("/user/createWithArray"))
 
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
 
+        
+
+        
+
+        
+
+        val resFuture = client.submit("POST", path, queryParams.toMap, headerParams.toMap, writer.write(body))
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
+        def createUsersWithListInput(body: List[User])(implicit reader: ClientResponseReader[Unit], writer: RequestWriter[List[User]]): Future[Unit] = {
+        // create path and map variables
+        val path = (addFmt("/user/createWithList"))
+
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
+
+        
+
+        
+
+        
+
+        val resFuture = client.submit("POST", path, queryParams.toMap, headerParams.toMap, writer.write(body))
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
+        def loginUser(username: String,
+        password: String)(implicit reader: ClientResponseReader[String]): Future[String] = {
+        // create path and map variables
+        val path = (addFmt("/user/login"))
+
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
+
+        
+
+        
+            if(username != null)   queryParams += "username" -> username.toString
+            if(password != null)   queryParams += "password" -> password.toString
+
+        
+
+        val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
+        def logoutUser()(implicit reader: ClientResponseReader[Unit]): Future[Unit] = {
+        // create path and map variables
+        val path = (addFmt("/user/logout"))
+
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
+
+        
+
+        
+
+        
+
+        val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
+        def getUserByName(username: String)(implicit reader: ClientResponseReader[User]): Future[User] = {
+        // create path and map variables
+        val path = (addFmt("/user/{username}")
+            replaceAll ("\\{" + "username" + "\\}",username.toString))
+
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
+
+        
+
+        
+
+        
+
+        val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
+        def updateUser(username: String,
+        body: User)(implicit reader: ClientResponseReader[Unit], writer: RequestWriter[User]): Future[Unit] = {
+        // create path and map variables
+        val path = (addFmt("/user/{username}")
+            replaceAll ("\\{" + "username" + "\\}",username.toString))
+
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
+
+        
+
+        
+
+        
+
+        val resFuture = client.submit("PUT", path, queryParams.toMap, headerParams.toMap, writer.write(body))
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
+        def deleteUser(username: String)(implicit reader: ClientResponseReader[Unit]): Future[Unit] = {
+        // create path and map variables
+        val path = (addFmt("/user/{username}")
+            replaceAll ("\\{" + "username" + "\\}",username.toString))
+
+        // query params
+        val queryParams = new mutable.HashMap[String, String]
+        val headerParams = new mutable.HashMap[String, String]
+
+        
+
+        
+
+        
+
+        val resFuture = client.submit("DELETE", path, queryParams.toMap, headerParams.toMap, "")
+        resFuture flatMap { resp =>
+        process(reader.read(resp))
+        }
+        }
+
+    
 
-    val resFuture = client.submit("POST", path, queryParams.toMap, headerParams.toMap, writer.write(body))
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
     }
-  }
-
-
-  def createUsersWithArrayInput(body: List[User])(implicit reader: ClientResponseReader[Unit], writer: RequestWriter[List[User]]): Future[Unit] = {
-    // create path and map variables
-    val path = (addFmt("/user/createWithArray"))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-
-
-
-    val resFuture = client.submit("POST", path, queryParams.toMap, headerParams.toMap, writer.write(body))
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-  def createUsersWithListInput(body: List[User])(implicit reader: ClientResponseReader[Unit], writer: RequestWriter[List[User]]): Future[Unit] = {
-    // create path and map variables
-    val path = (addFmt("/user/createWithList"))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-
-
-
-    val resFuture = client.submit("POST", path, queryParams.toMap, headerParams.toMap, writer.write(body))
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-  def loginUser(username: String,
-                password: String)(implicit reader: ClientResponseReader[String]): Future[String] = {
-    // create path and map variables
-    val path = (addFmt("/user/login"))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-    if (username != null) queryParams += "username" -> username.toString
-    if (password != null) queryParams += "password" -> password.toString
-
-
-
-    val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-  def logoutUser()(implicit reader: ClientResponseReader[Unit]): Future[Unit] = {
-    // create path and map variables
-    val path = (addFmt("/user/logout"))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-
-
-
-    val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-  def getUserByName(username: String)(implicit reader: ClientResponseReader[User]): Future[User] = {
-    // create path and map variables
-    val path = (addFmt("/user/{username}")
-      replaceAll("\\{" + "username" + "\\}", username.toString))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-
-
-
-    val resFuture = client.submit("GET", path, queryParams.toMap, headerParams.toMap, "")
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-  def updateUser(username: String,
-                 body: User)(implicit reader: ClientResponseReader[Unit], writer: RequestWriter[User]): Future[Unit] = {
-    // create path and map variables
-    val path = (addFmt("/user/{username}")
-      replaceAll("\\{" + "username" + "\\}", username.toString))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-
-
-
-    val resFuture = client.submit("PUT", path, queryParams.toMap, headerParams.toMap, writer.write(body))
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-  def deleteUser(username: String)(implicit reader: ClientResponseReader[Unit]): Future[Unit] = {
-    // create path and map variables
-    val path = (addFmt("/user/{username}")
-      replaceAll("\\{" + "username" + "\\}", username.toString))
-
-    // query params
-    val queryParams = new mutable.HashMap[String, String]
-    val headerParams = new mutable.HashMap[String, String]
-
-
-
-
-
-
-
-    val resFuture = client.submit("DELETE", path, queryParams.toMap, headerParams.toMap, "")
-    resFuture flatMap { resp =>
-      process(reader.read(resp))
-    }
-  }
-
-
-}

samples/client/petstore/async-scala/src/main/scala/io/swagger/client/model/Category.scala

@@ -1,8 +1,12 @@
 package io.swagger.client.model
 
+import org.joda.time.DateTime
 
-case class Category(
-                     id: Long,
-                     name: String
 
-                     )
+    
+        case class Category (
+        id: Long,
+        name: String
+        
+        )
+    

samples/client/petstore/async-scala/src/main/scala/io/swagger/client/model/Order.scala

@@ -1,12 +1,16 @@
 package io.swagger.client.model
 
+import org.joda.time.DateTime
 
-case class Order(
-                  id: Long,
-                  petId: Long,
-                  quantity: Integer,
-                  shipDate: DateTime,
-                  status: String, // Order Status
-                  complete: Boolean
 
-                  )
+    
+        case class Order (
+        id: Long,
+        petId: Long,
+        quantity: Integer,
+        shipDate: DateTime,
+        status: String,  // Order Status
+        complete: Boolean
+        
+        )
+    

samples/client/petstore/async-scala/src/main/scala/io/swagger/client/model/Pet.scala

@@ -1,12 +1,16 @@
 package io.swagger.client.model
 
+import org.joda.time.DateTime
 
-case class Pet(
-                id: Long,
-                category: Category,
-                name: String,
-                photoUrls: List[String],
-                tags: List[Tag],
-                status: String // pet status in the store
 
-                )
+    
+        case class Pet (
+        id: Long,
+        category: Category,
+        name: String,
+        photoUrls: List[String],
+        tags: List[Tag],
+        status: String  // pet status in the store
+        
+        )
+    

samples/client/petstore/async-scala/src/main/scala/io/swagger/client/model/Tag.scala

@@ -1,8 +1,12 @@
 package io.swagger.client.model
 
+import org.joda.time.DateTime
 
-case class Tag(
-                id: Long,
-                name: String
 
-                )
+    
+        case class Tag (
+        id: Long,
+        name: String
+        
+        )
+    

samples/client/petstore/async-scala/src/main/scala/io/swagger/client/model/User.scala

@@ -1,14 +1,18 @@
 package io.swagger.client.model
 
+import org.joda.time.DateTime
 
-case class User(
-                 id: Long,
-                 username: String,
-                 firstName: String,
-                 lastName: String,
-                 email: String,
-                 password: String,
-                 phone: String,
-                 userStatus: Integer // User Status
 
-                 )
+    
+        case class User (
+        id: Long,
+        username: String,
+        firstName: String,
+        lastName: String,
+        email: String,
+        password: String,
+        phone: String,
+        userStatus: Integer  // User Status
+        
+        )
+