/**
  * Generated by API Builder - https://www.apibuilder.io
  * Service version: 0.0.2-dev
  * User agent: apibuilder app.apibuilder.io/mard/mard2p-api/0.0.2-dev/play_2_9_scala_3_controllers
  */
package payp.mard2p.api.v0.controllers

import payp.mard2p.api.v0.models.json._
import io.apibuilder.common.v0.models.json._
import io.apibuilder.generator.v0.models.json._
import io.apibuilder.spec.v0.models.json._

trait AccountsController extends play.api.mvc.BaseController {

  sealed trait PostCreate extends Product with Serializable
  object PostCreate {
    final case class HTTP200(body: payp.mard2p.api.v0.models.Account) extends PostCreate
    case object HTTP409 extends PostCreate
    final case class Undocumented(result: play.api.mvc.Result) extends PostCreate
  }

  def postCreate(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      accountid: Long,
      ownerid: String,
      totalAmount: Double,
      sold: Double,
      debit: Double,
      currency: String
  ): scala.concurrent.Future[PostCreate]
  final def postCreate(
      accountid: Long,
      ownerid: String,
      totalAmount: Double,
      sold: Double,
      debit: Double,
      currency: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    postCreate(request, accountid, ownerid, totalAmount, sold, debit, currency)
      .map {
        case r: PostCreate.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case PostCreate.HTTP409         => Status(409)(play.api.mvc.Results.EmptyContent())
        case r: PostCreate.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait PutUpdateByAccountid extends Product with Serializable
  object PutUpdateByAccountid {
    final case class HTTP200(body: payp.mard2p.api.v0.models.Account) extends PutUpdateByAccountid
    case object HTTP409 extends PutUpdateByAccountid
    final case class Undocumented(result: play.api.mvc.Result) extends PutUpdateByAccountid
  }

  def putUpdateByAccountid(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      accountid: Long,
      ownerid: String,
      totalAmount: Double,
      currency: String,
      sold: Double,
      debit: Double
  ): scala.concurrent.Future[PutUpdateByAccountid]
  final def putUpdateByAccountid(
      accountid: Long,
      ownerid: String,
      totalAmount: Double,
      currency: String,
      sold: Double,
      debit: Double
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    putUpdateByAccountid(request, accountid, ownerid, totalAmount, currency, sold, debit)
      .map {
        case r: PutUpdateByAccountid.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case PutUpdateByAccountid.HTTP409         => Status(409)(play.api.mvc.Results.EmptyContent())
        case r: PutUpdateByAccountid.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait DeleteDeleteByAccountid extends Product with Serializable
  object DeleteDeleteByAccountid {
    case object HTTP204 extends DeleteDeleteByAccountid
    case object HTTP401 extends DeleteDeleteByAccountid
    case object HTTP404 extends DeleteDeleteByAccountid
    final case class Undocumented(result: play.api.mvc.Result) extends DeleteDeleteByAccountid
  }

  def deleteDeleteByAccountid(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      accountid: Long
  ): scala.concurrent.Future[DeleteDeleteByAccountid]
  final def deleteDeleteByAccountid(accountid: Long): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async {
    request =>
      deleteDeleteByAccountid(request, accountid)
        .map {
          case DeleteDeleteByAccountid.HTTP204         => Status(204)(play.api.mvc.Results.EmptyContent())
          case DeleteDeleteByAccountid.HTTP401         => Status(401)(play.api.mvc.Results.EmptyContent())
          case DeleteDeleteByAccountid.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: DeleteDeleteByAccountid.Undocumented => r.result
        }(defaultExecutionContext)
  }

  sealed trait GetByAccountid extends Product with Serializable
  object GetByAccountid {
    final case class HTTP200(body: payp.mard2p.api.v0.models.Account) extends GetByAccountid
    case object HTTP404 extends GetByAccountid
    final case class Undocumented(result: play.api.mvc.Result) extends GetByAccountid
  }

  def getByAccountid(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      accountid: Long,
      ownerid: String,
      totalAmount: Double,
      sold: Double,
      debit: Double,
      currency: String
  ): scala.concurrent.Future[GetByAccountid]
  final def getByAccountid(
      accountid: Long,
      ownerid: String,
      totalAmount: Double,
      sold: Double,
      debit: Double,
      currency: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getByAccountid(request, accountid, ownerid, totalAmount, sold, debit, currency)
      .map {
        case r: GetByAccountid.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetByAccountid.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: GetByAccountid.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetList extends Product with Serializable
  object GetList {
    final case class HTTP200(body: Seq[payp.mard2p.api.v0.models.Account]) extends GetList
    case object HTTP404 extends GetList
    final case class Undocumented(result: play.api.mvc.Result) extends GetList
  }

  def getList(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      accountid: Long,
      ownerid: String,
      totalAmount: Double,
      currency: String,
      sold: Double,
      debit: Double
  ): scala.concurrent.Future[GetList]
  final def getList(
      accountid: Long,
      ownerid: String,
      totalAmount: Double,
      currency: String,
      sold: Double,
      debit: Double
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getList(request, accountid, ownerid, totalAmount, currency, sold, debit)
      .map {
        case r: GetList.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetList.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: GetList.Undocumented => r.result
      }(defaultExecutionContext)
  }

}

trait DepositsController extends play.api.mvc.BaseController {

  sealed trait DeleteDeleteByDepid extends Product with Serializable
  object DeleteDeleteByDepid {
    case object HTTP204 extends DeleteDeleteByDepid
    case object HTTP401 extends DeleteDeleteByDepid
    case object HTTP404 extends DeleteDeleteByDepid
    final case class Undocumented(result: play.api.mvc.Result) extends DeleteDeleteByDepid
  }

  def deleteDeleteByDepid(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      depid: Long
  ): scala.concurrent.Future[DeleteDeleteByDepid]
  final def deleteDeleteByDepid(depid: Long): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    deleteDeleteByDepid(request, depid)
      .map {
        case DeleteDeleteByDepid.HTTP204         => Status(204)(play.api.mvc.Results.EmptyContent())
        case DeleteDeleteByDepid.HTTP401         => Status(401)(play.api.mvc.Results.EmptyContent())
        case DeleteDeleteByDepid.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: DeleteDeleteByDepid.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetByDepid extends Product with Serializable
  object GetByDepid {
    final case class HTTP200(body: payp.mard2p.api.v0.models.Payment) extends GetByDepid
    case object HTTP404 extends GetByDepid
    final case class Undocumented(result: play.api.mvc.Result) extends GetByDepid
  }

  def getByDepid(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      depid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Long,
      currency: String,
      paymentContext: String
  ): scala.concurrent.Future[GetByDepid]
  final def getByDepid(
      depid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Long,
      currency: String,
      paymentContext: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getByDepid(
      request,
      depid,
      paymentMethod,
      actorid,
      refAccountid,
      operatorid,
      amount,
      phone,
      pin,
      currency,
      paymentContext
    ).map {
        case r: GetByDepid.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetByDepid.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: GetByDepid.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetList extends Product with Serializable
  object GetList {
    final case class HTTP200(body: Seq[payp.mard2p.api.v0.models.Payment]) extends GetList
    case object HTTP404 extends GetList
    final case class Undocumented(result: play.api.mvc.Result) extends GetList
  }

  def getList(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      payid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Long,
      currency: String,
      paymentContext: String
  ): scala.concurrent.Future[GetList]
  final def getList(
      payid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Long,
      currency: String,
      paymentContext: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getList(
      request,
      payid,
      paymentMethod,
      actorid,
      refAccountid,
      operatorid,
      amount,
      phone,
      pin,
      currency,
      paymentContext
    ).map {
        case r: GetList.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetList.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: GetList.Undocumented => r.result
      }(defaultExecutionContext)
  }

}

trait PaymentsController extends play.api.mvc.BaseController {

  sealed trait PostCreate extends Product with Serializable
  object PostCreate {
    final case class HTTP200(body: payp.mard2p.api.v0.models.Payment) extends PostCreate
    case object HTTP409 extends PostCreate
    final case class Undocumented(result: play.api.mvc.Result) extends PostCreate
  }

  def postCreate(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      payid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      currency: String,
      phone: Long,
      pin: Int,
      paymentContext: String
  ): scala.concurrent.Future[PostCreate]
  final def postCreate(
      payid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      currency: String,
      phone: Long,
      pin: Int,
      paymentContext: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    postCreate(
      request,
      payid,
      paymentMethod,
      actorid,
      refAccountid,
      operatorid,
      amount,
      currency,
      phone,
      pin,
      paymentContext
    ).map {
        case r: PostCreate.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case PostCreate.HTTP409         => Status(409)(play.api.mvc.Results.EmptyContent())
        case r: PostCreate.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait PutUpdateByPayid extends Product with Serializable
  object PutUpdateByPayid {
    final case class HTTP200(body: payp.mard2p.api.v0.models.Payment) extends PutUpdateByPayid
    case object HTTP409 extends PutUpdateByPayid
    final case class Undocumented(result: play.api.mvc.Result) extends PutUpdateByPayid
  }

  def putUpdateByPayid(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      payid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Int,
      currency: String,
      paymentContext: String
  ): scala.concurrent.Future[PutUpdateByPayid]
  final def putUpdateByPayid(
      payid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Int,
      currency: String,
      paymentContext: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    putUpdateByPayid(
      request,
      payid,
      paymentMethod,
      actorid,
      refAccountid,
      operatorid,
      amount,
      phone,
      pin,
      currency,
      paymentContext
    ).map {
        case r: PutUpdateByPayid.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case PutUpdateByPayid.HTTP409         => Status(409)(play.api.mvc.Results.EmptyContent())
        case r: PutUpdateByPayid.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait DeleteDeleteByPayid extends Product with Serializable
  object DeleteDeleteByPayid {
    case object HTTP204 extends DeleteDeleteByPayid
    case object HTTP401 extends DeleteDeleteByPayid
    case object HTTP404 extends DeleteDeleteByPayid
    final case class Undocumented(result: play.api.mvc.Result) extends DeleteDeleteByPayid
  }

  def deleteDeleteByPayid(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      payid: Long
  ): scala.concurrent.Future[DeleteDeleteByPayid]
  final def deleteDeleteByPayid(payid: Long): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    deleteDeleteByPayid(request, payid)
      .map {
        case DeleteDeleteByPayid.HTTP204         => Status(204)(play.api.mvc.Results.EmptyContent())
        case DeleteDeleteByPayid.HTTP401         => Status(401)(play.api.mvc.Results.EmptyContent())
        case DeleteDeleteByPayid.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: DeleteDeleteByPayid.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetByPayid extends Product with Serializable
  object GetByPayid {
    final case class HTTP200(body: payp.mard2p.api.v0.models.Payment) extends GetByPayid
    case object HTTP404 extends GetByPayid
    final case class Undocumented(result: play.api.mvc.Result) extends GetByPayid
  }

  def getByPayid(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      payid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Long,
      currency: String,
      paymentContext: String
  ): scala.concurrent.Future[GetByPayid]
  final def getByPayid(
      payid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Long,
      currency: String,
      paymentContext: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getByPayid(
      request,
      payid,
      paymentMethod,
      actorid,
      refAccountid,
      operatorid,
      amount,
      phone,
      pin,
      currency,
      paymentContext
    ).map {
        case r: GetByPayid.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetByPayid.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: GetByPayid.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetByRefAccountid extends Product with Serializable
  object GetByRefAccountid {
    final case class HTTP200(body: payp.mard2p.api.v0.models.Payment) extends GetByRefAccountid
    case object HTTP404 extends GetByRefAccountid
    final case class Undocumented(result: play.api.mvc.Result) extends GetByRefAccountid
  }

  def getByRefAccountid(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      refAccountid: Long,
      payid: Long,
      paymentMethod: String,
      actorid: String,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Int,
      currency: String,
      paymentContext: String
  ): scala.concurrent.Future[GetByRefAccountid]
  final def getByRefAccountid(
      refAccountid: Long,
      payid: Long,
      paymentMethod: String,
      actorid: String,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Int,
      currency: String,
      paymentContext: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getByRefAccountid(
      request,
      refAccountid,
      payid,
      paymentMethod,
      actorid,
      operatorid,
      amount,
      phone,
      pin,
      currency,
      paymentContext
    ).map {
        case r: GetByRefAccountid.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetByRefAccountid.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: GetByRefAccountid.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetList extends Product with Serializable
  object GetList {
    final case class HTTP200(body: Seq[payp.mard2p.api.v0.models.Payment]) extends GetList
    case object HTTP404 extends GetList
    final case class Undocumented(result: play.api.mvc.Result) extends GetList
  }

  def getList(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      payid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Long,
      currency: String,
      paymentContext: String
  ): scala.concurrent.Future[GetList]
  final def getList(
      payid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Long,
      currency: String,
      paymentContext: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getList(
      request,
      payid,
      paymentMethod,
      actorid,
      refAccountid,
      operatorid,
      amount,
      phone,
      pin,
      currency,
      paymentContext
    ).map {
        case r: GetList.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetList.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: GetList.Undocumented => r.result
      }(defaultExecutionContext)
  }

}

trait TransfersController extends play.api.mvc.BaseController {

  sealed trait PostCreate extends Product with Serializable
  object PostCreate {
    final case class HTTP200(body: payp.mard2p.api.v0.models.Transfer) extends PostCreate
    case object HTTP409 extends PostCreate
    final case class Undocumented(result: play.api.mvc.Result) extends PostCreate
  }

  def postCreate(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      transferid: Long,
      senderid: String,
      amount: Double,
      currency: String,
      refAccountidReceiver: Long,
      refAccountidSender: Long
  ): scala.concurrent.Future[PostCreate]
  final def postCreate(
      transferid: Long,
      senderid: String,
      amount: Double,
      currency: String,
      refAccountidReceiver: Long,
      refAccountidSender: Long
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    postCreate(request, transferid, senderid, amount, currency, refAccountidReceiver, refAccountidSender)
      .map {
        case r: PostCreate.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case PostCreate.HTTP409         => Status(409)(play.api.mvc.Results.EmptyContent())
        case r: PostCreate.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait PutUpdateByTransferid extends Product with Serializable
  object PutUpdateByTransferid {
    final case class HTTP200(body: payp.mard2p.api.v0.models.Transfer) extends PutUpdateByTransferid
    case object HTTP409 extends PutUpdateByTransferid
    final case class Undocumented(result: play.api.mvc.Result) extends PutUpdateByTransferid
  }

  def putUpdateByTransferid(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      transferid: Long,
      senderid: String,
      amount: Double,
      currency: String,
      refAccountidReceiver: Long,
      refAccountidSender: Long
  ): scala.concurrent.Future[PutUpdateByTransferid]
  final def putUpdateByTransferid(
      transferid: Long,
      senderid: String,
      amount: Double,
      currency: String,
      refAccountidReceiver: Long,
      refAccountidSender: Long
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    putUpdateByTransferid(request, transferid, senderid, amount, currency, refAccountidReceiver, refAccountidSender)
      .map {
        case r: PutUpdateByTransferid.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case PutUpdateByTransferid.HTTP409         => Status(409)(play.api.mvc.Results.EmptyContent())
        case r: PutUpdateByTransferid.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait DeleteDeleteByTransferid extends Product with Serializable
  object DeleteDeleteByTransferid {
    case object HTTP204 extends DeleteDeleteByTransferid
    case object HTTP401 extends DeleteDeleteByTransferid
    case object HTTP404 extends DeleteDeleteByTransferid
    final case class Undocumented(result: play.api.mvc.Result) extends DeleteDeleteByTransferid
  }

  def deleteDeleteByTransferid(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      transferid: Long
  ): scala.concurrent.Future[DeleteDeleteByTransferid]
  final def deleteDeleteByTransferid(transferid: Long): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async {
    request =>
      deleteDeleteByTransferid(request, transferid)
        .map {
          case DeleteDeleteByTransferid.HTTP204         => Status(204)(play.api.mvc.Results.EmptyContent())
          case DeleteDeleteByTransferid.HTTP401         => Status(401)(play.api.mvc.Results.EmptyContent())
          case DeleteDeleteByTransferid.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: DeleteDeleteByTransferid.Undocumented => r.result
        }(defaultExecutionContext)
  }

  sealed trait GetByTransferid extends Product with Serializable
  object GetByTransferid {
    final case class HTTP200(body: payp.mard2p.api.v0.models.Account) extends GetByTransferid
    case object HTTP404 extends GetByTransferid
    final case class Undocumented(result: play.api.mvc.Result) extends GetByTransferid
  }

  def getByTransferid(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      transferid: Long,
      senderid: String,
      amount: Double,
      currency: String,
      refAccountidReceiver: Long,
      refAccountidSender: Long
  ): scala.concurrent.Future[GetByTransferid]
  final def getByTransferid(
      transferid: Long,
      senderid: String,
      amount: Double,
      currency: String,
      refAccountidReceiver: Long,
      refAccountidSender: Long
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getByTransferid(request, transferid, senderid, amount, currency, refAccountidReceiver, refAccountidSender)
      .map {
        case r: GetByTransferid.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetByTransferid.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: GetByTransferid.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetList extends Product with Serializable
  object GetList {
    final case class HTTP200(body: Seq[payp.mard2p.api.v0.models.Account]) extends GetList
    case object HTTP404 extends GetList
    final case class Undocumented(result: play.api.mvc.Result) extends GetList
  }

  def getList(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      transferid: Long,
      senderid: String,
      amount: Double,
      currency: String,
      refAccountidReceiver: Long,
      refAccountidSender: Long
  ): scala.concurrent.Future[GetList]
  final def getList(
      transferid: Long,
      senderid: String,
      amount: Double,
      currency: String,
      refAccountidReceiver: Long,
      refAccountidSender: Long
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getList(request, transferid, senderid, amount, currency, refAccountidReceiver, refAccountidSender)
      .map {
        case r: GetList.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetList.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: GetList.Undocumented => r.result
      }(defaultExecutionContext)
  }

}

trait ValidationsController extends play.api.mvc.BaseController {

  sealed trait Post extends Product with Serializable
  object Post {
    final case class HTTP200(body: payp.mard2p.api.v0.models.Validation) extends Post
    final case class Undocumented(result: play.api.mvc.Result) extends Post
  }

  def post(request: play.api.mvc.Request[String], body: String): scala.concurrent.Future[Post]
  final def post(): play.api.mvc.Action[String] = Action.async(parse.json[String]) { request =>
    post(request, request.body)
      .map {
        case r: Post.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case r: Post.Undocumented => r.result
      }(defaultExecutionContext)
  }

}

trait WithdrawsController extends play.api.mvc.BaseController {

  sealed trait DeleteDeleteByWdwid extends Product with Serializable
  object DeleteDeleteByWdwid {
    case object HTTP204 extends DeleteDeleteByWdwid
    case object HTTP401 extends DeleteDeleteByWdwid
    case object HTTP404 extends DeleteDeleteByWdwid
    final case class Undocumented(result: play.api.mvc.Result) extends DeleteDeleteByWdwid
  }

  def deleteDeleteByWdwid(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      wdwid: Long
  ): scala.concurrent.Future[DeleteDeleteByWdwid]
  final def deleteDeleteByWdwid(wdwid: Long): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    deleteDeleteByWdwid(request, wdwid)
      .map {
        case DeleteDeleteByWdwid.HTTP204         => Status(204)(play.api.mvc.Results.EmptyContent())
        case DeleteDeleteByWdwid.HTTP401         => Status(401)(play.api.mvc.Results.EmptyContent())
        case DeleteDeleteByWdwid.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: DeleteDeleteByWdwid.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetByWdwid extends Product with Serializable
  object GetByWdwid {
    final case class HTTP200(body: payp.mard2p.api.v0.models.Payment) extends GetByWdwid
    case object HTTP404 extends GetByWdwid
    final case class Undocumented(result: play.api.mvc.Result) extends GetByWdwid
  }

  def getByWdwid(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      wdwid: Long,
      depid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Long,
      currency: String,
      paymentContext: String
  ): scala.concurrent.Future[GetByWdwid]
  final def getByWdwid(
      wdwid: Long,
      depid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Long,
      currency: String,
      paymentContext: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getByWdwid(
      request,
      wdwid,
      depid,
      paymentMethod,
      actorid,
      refAccountid,
      operatorid,
      amount,
      phone,
      pin,
      currency,
      paymentContext
    ).map {
        case r: GetByWdwid.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetByWdwid.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: GetByWdwid.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetList extends Product with Serializable
  object GetList {
    final case class HTTP200(body: Seq[payp.mard2p.api.v0.models.Payment]) extends GetList
    case object HTTP404 extends GetList
    final case class Undocumented(result: play.api.mvc.Result) extends GetList
  }

  def getList(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      payid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Long,
      currency: String,
      paymentContext: String
  ): scala.concurrent.Future[GetList]
  final def getList(
      payid: Long,
      paymentMethod: String,
      actorid: String,
      refAccountid: Long,
      operatorid: String,
      amount: Double,
      phone: Long,
      pin: Long,
      currency: String,
      paymentContext: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getList(
      request,
      payid,
      paymentMethod,
      actorid,
      refAccountid,
      operatorid,
      amount,
      phone,
      pin,
      currency,
      paymentContext
    ).map {
        case r: GetList.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetList.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: GetList.Undocumented => r.result
      }(defaultExecutionContext)
  }

}