/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.0.1
 * User agent: apibuilder app.apibuilder.io/edsancha/medallia-api/0.0.1/http4s_0_20
 */
package com.edsancha.medallia.api.v0.models {

  package object json {
    import io.circe.Decoder._
    import io.circe.Encoder._
    import scala.language.implicitConversions // See below - Make Scala 2.11 Either monadic
    import scala.util.Try
    import io.circe.{Json, JsonObject, Encoder, Decoder, DecodingFailure}
    import io.circe.syntax._
    import com.edsancha.medallia.api.v0.models.json._
    import com.edsancha.survey.models.v0.models.json._

    // Make Scala 2.11 Either monadic
    private[v0] implicit def eitherOps[A,B](e: Either[A,B]) = cats.implicits.catsSyntaxEither(e)

    private[v0] implicit val decodeUUID: Decoder[_root_.java.util.UUID] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.util.UUID.fromString(str)))

    private[v0] implicit val encodeUUID: Encoder[_root_.java.util.UUID] =
      Encoder.encodeString.contramap[_root_.java.util.UUID](uuid => uuid.toString)

    private[v0] implicit val decodeInstant: Decoder[_root_.java.time.Instant] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.time.OffsetDateTime.parse(str).toInstant))

    private[v0] implicit val encodeInstant: Encoder[_root_.java.time.Instant] =
      Encoder.encodeString.contramap[_root_.java.time.Instant](_.toString)

    private[v0] implicit val decodeLocalDate: Decoder[_root_.java.time.LocalDate] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.time.LocalDate.parse(str)))

    private[v0] implicit val encodeLocalDate: Encoder[_root_.java.time.LocalDate] =
      Encoder.encodeString.contramap[_root_.java.time.LocalDate](_.toString)

    implicit val jsonDecoderMedalliaApiCompareString: Decoder[com.edsancha.medallia.api.v0.models.CompareString] =
      Decoder.decodeString.map(com.edsancha.medallia.api.v0.models.CompareString(_))

    implicit val jsonEncoderMedalliaApiCompareString: Encoder[com.edsancha.medallia.api.v0.models.CompareString] =
      Encoder.encodeString.contramap[com.edsancha.medallia.api.v0.models.CompareString](_.toString)

    implicit val jsonDecoderMedalliaApiFormType: Decoder[com.edsancha.medallia.api.v0.models.FormType] =
      Decoder.decodeString.map(com.edsancha.medallia.api.v0.models.FormType(_))

    implicit val jsonEncoderMedalliaApiFormType: Encoder[com.edsancha.medallia.api.v0.models.FormType] =
      Encoder.encodeString.contramap[com.edsancha.medallia.api.v0.models.FormType](_.toString)

    implicit val jsonDecoderMedalliaApiRatingViewType: Decoder[com.edsancha.medallia.api.v0.models.RatingViewType] =
      Decoder.decodeString.map(com.edsancha.medallia.api.v0.models.RatingViewType(_))

    implicit val jsonEncoderMedalliaApiRatingViewType: Encoder[com.edsancha.medallia.api.v0.models.RatingViewType] =
      Encoder.encodeString.contramap[com.edsancha.medallia.api.v0.models.RatingViewType](_.toString)

    implicit def decodeMedalliaApiAccessTokenWrapper: Decoder[AccessTokenWrapper] = Decoder.instance { c =>
     for {
        accessToken <- c.downField("accessToken").as[String]
      } yield {
        AccessTokenWrapper(
          accessToken = accessToken
        )
      }
    }

    implicit def encodeMedalliaApiAccessTokenWrapper: Encoder[AccessTokenWrapper] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("accessToken" -> t.accessToken.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiComponentCheckbox: Decoder[ComponentCheckbox] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        required <- c.downField("required").as[Boolean]
        label <- c.downField("label").as[String]
        options <- c.downField("options").as[Seq[String]]
        description <- c.downField("description").as[Option[String]]
      } yield {
        ComponentCheckbox(
          index = index,
          id = id,
          uniqueName = uniqueName,
          required = required,
          label = label,
          options = options,
          description = description
        )
      }
    }

    implicit def encodeMedalliaApiComponentCheckbox: Encoder[ComponentCheckbox] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("required" -> t.required.asJson),
        Some("label" -> t.label.asJson),
        Some("options" -> t.options.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiComponentDropdown: Decoder[ComponentDropdown] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        required <- c.downField("required").as[Boolean]
        placeholder <- c.downField("placeholder").as[String]
        label <- c.downField("label").as[String]
        options <- c.downField("options").as[Seq[String]]
        description <- c.downField("description").as[Option[String]]
      } yield {
        ComponentDropdown(
          index = index,
          id = id,
          uniqueName = uniqueName,
          required = required,
          placeholder = placeholder,
          label = label,
          options = options,
          description = description
        )
      }
    }

    implicit def encodeMedalliaApiComponentDropdown: Encoder[ComponentDropdown] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("required" -> t.required.asJson),
        Some("placeholder" -> t.placeholder.asJson),
        Some("label" -> t.label.asJson),
        Some("options" -> t.options.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiComponentGrading: Decoder[ComponentGrading] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        required <- c.downField("required").as[Boolean]
        label <- c.downField("label").as[String]
        ratingViewType <- c.downField("ratingViewType").as[com.edsancha.medallia.api.v0.models.RatingViewType]
        description <- c.downField("description").as[Option[String]]
      } yield {
        ComponentGrading(
          index = index,
          id = id,
          uniqueName = uniqueName,
          required = required,
          label = label,
          ratingViewType = ratingViewType,
          description = description
        )
      }
    }

    implicit def encodeMedalliaApiComponentGrading: Encoder[ComponentGrading] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("required" -> t.required.asJson),
        Some("label" -> t.label.asJson),
        Some("ratingViewType" -> t.ratingViewType.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiComponentGrading0to10: Decoder[ComponentGrading0to10] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        required <- c.downField("required").as[Boolean]
        label <- c.downField("label").as[String]
        ratingViewType <- c.downField("ratingViewType").as[com.edsancha.medallia.api.v0.models.RatingViewType]
        description <- c.downField("description").as[Option[String]]
      } yield {
        ComponentGrading0to10(
          index = index,
          id = id,
          uniqueName = uniqueName,
          required = required,
          label = label,
          ratingViewType = ratingViewType,
          description = description
        )
      }
    }

    implicit def encodeMedalliaApiComponentGrading0to10: Encoder[ComponentGrading0to10] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("required" -> t.required.asJson),
        Some("label" -> t.label.asJson),
        Some("ratingViewType" -> t.ratingViewType.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiComponentGrading1to10: Decoder[ComponentGrading1to10] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        required <- c.downField("required").as[Boolean]
        label <- c.downField("label").as[String]
        ratingViewType <- c.downField("ratingViewType").as[com.edsancha.medallia.api.v0.models.RatingViewType]
        description <- c.downField("description").as[Option[String]]
      } yield {
        ComponentGrading1to10(
          index = index,
          id = id,
          uniqueName = uniqueName,
          required = required,
          label = label,
          ratingViewType = ratingViewType,
          description = description
        )
      }
    }

    implicit def encodeMedalliaApiComponentGrading1to10: Encoder[ComponentGrading1to10] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("required" -> t.required.asJson),
        Some("label" -> t.label.asJson),
        Some("ratingViewType" -> t.ratingViewType.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiComponentImage: Decoder[ComponentImage] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        imageObject <- c.downField("imageObject").as[Option[com.edsancha.medallia.api.v0.models.Image]]
        uploadedResource <- c.downField("uploadedResource").as[Option[com.edsancha.medallia.api.v0.models.Image]]
      } yield {
        ComponentImage(
          index = index,
          id = id,
          uniqueName = uniqueName,
          imageObject = imageObject,
          uploadedResource = uploadedResource
        )
      }
    }

    implicit def encodeMedalliaApiComponentImage: Encoder[ComponentImage] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        t.imageObject.map(t => "imageObject" -> t.asJson),
        t.uploadedResource.map(t => "uploadedResource" -> t.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiComponentLabel: Decoder[ComponentLabel] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        labelContent <- c.downField("labelContent").as[Option[String]]
        numOfLines <- c.downField("num_of_lines").as[Int]
      } yield {
        ComponentLabel(
          index = index,
          id = id,
          uniqueName = uniqueName,
          labelContent = labelContent,
          numOfLines = numOfLines
        )
      }
    }

    implicit def encodeMedalliaApiComponentLabel: Encoder[ComponentLabel] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        t.labelContent.map(t => "labelContent" -> t.asJson),
        Some("num_of_lines" -> t.numOfLines.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiComponentNps: Decoder[ComponentNps] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        required <- c.downField("required").as[Boolean]
        label <- c.downField("label").as[String]
        description <- c.downField("description").as[Option[String]]
        ratingViewType <- c.downField("ratingViewType").as[com.edsancha.medallia.api.v0.models.RatingViewType]
      } yield {
        ComponentNps(
          index = index,
          id = id,
          uniqueName = uniqueName,
          required = required,
          label = label,
          description = description,
          ratingViewType = ratingViewType
        )
      }
    }

    implicit def encodeMedalliaApiComponentNps: Encoder[ComponentNps] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("required" -> t.required.asJson),
        Some("label" -> t.label.asJson),
        t.description.map(t => "description" -> t.asJson),
        Some("ratingViewType" -> t.ratingViewType.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiComponentRadioSelector: Decoder[ComponentRadioSelector] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        required <- c.downField("required").as[Boolean]
        label <- c.downField("label").as[String]
        options <- c.downField("options").as[Seq[String]]
        description <- c.downField("description").as[Option[String]]
      } yield {
        ComponentRadioSelector(
          index = index,
          id = id,
          uniqueName = uniqueName,
          required = required,
          label = label,
          options = options,
          description = description
        )
      }
    }

    implicit def encodeMedalliaApiComponentRadioSelector: Encoder[ComponentRadioSelector] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("required" -> t.required.asJson),
        Some("label" -> t.label.asJson),
        Some("options" -> t.options.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiComponentTextArea: Decoder[ComponentTextArea] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        required <- c.downField("required").as[Boolean]
        placeholder <- c.downField("placeholder").as[String]
        label <- c.downField("label").as[String]
        numOfLines <- c.downField("num_of_lines").as[Int]
        description <- c.downField("description").as[Option[String]]
      } yield {
        ComponentTextArea(
          index = index,
          id = id,
          uniqueName = uniqueName,
          required = required,
          placeholder = placeholder,
          label = label,
          numOfLines = numOfLines,
          description = description
        )
      }
    }

    implicit def encodeMedalliaApiComponentTextArea: Encoder[ComponentTextArea] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("required" -> t.required.asJson),
        Some("placeholder" -> t.placeholder.asJson),
        Some("label" -> t.label.asJson),
        Some("num_of_lines" -> t.numOfLines.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiComponentTextInput: Decoder[ComponentTextInput] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        required <- c.downField("required").as[Boolean]
        placeholder <- c.downField("placeholder").as[String]
        label <- c.downField("label").as[String]
        maxChars <- c.downField("max_chars").as[Int]
        description <- c.downField("description").as[Option[String]]
      } yield {
        ComponentTextInput(
          index = index,
          id = id,
          uniqueName = uniqueName,
          required = required,
          placeholder = placeholder,
          label = label,
          maxChars = maxChars,
          description = description
        )
      }
    }

    implicit def encodeMedalliaApiComponentTextInput: Encoder[ComponentTextInput] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("required" -> t.required.asJson),
        Some("placeholder" -> t.placeholder.asJson),
        Some("label" -> t.label.asJson),
        Some("max_chars" -> t.maxChars.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiConfiguration: Decoder[Configuration] = Decoder.instance { c =>
     for {
        propertyId <- c.downField("propertyId").as[Int]
        feedbackSubmitUrl <- c.downField("feedbackSubmitUrl").as[String]
        forms <- c.downField("forms").as[Seq[com.edsancha.medallia.api.v0.models.Form]]
      } yield {
        Configuration(
          propertyId = propertyId,
          feedbackSubmitUrl = feedbackSubmitUrl,
          forms = forms
        )
      }
    }

    implicit def encodeMedalliaApiConfiguration: Encoder[Configuration] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("propertyId" -> t.propertyId.asJson),
        Some("feedbackSubmitUrl" -> t.feedbackSubmitUrl.asJson),
        Some("forms" -> t.forms.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiDynamicData: Decoder[DynamicData] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        required <- c.downField("required").as[Boolean]
        component <- c.downField("component").as[String]
        uniqueName <- c.downField("unique_name").as[String]
        placeholder <- c.downField("placeholder").as[String]
        label <- c.downField("label").as[String]
        description <- c.downField("description").as[Option[String]]
        options <- c.downField("options").as[Option[Seq[String]]]
        imageObject <- c.downField("imageObject").as[Option[com.edsancha.medallia.api.v0.models.Image]]
      } yield {
        DynamicData(
          index = index,
          id = id,
          required = required,
          component = component,
          uniqueName = uniqueName,
          placeholder = placeholder,
          label = label,
          description = description,
          options = options,
          imageObject = imageObject
        )
      }
    }

    implicit def encodeMedalliaApiDynamicData: Encoder[DynamicData] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("required" -> t.required.asJson),
        Some("component" -> t.component.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("placeholder" -> t.placeholder.asJson),
        Some("label" -> t.label.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.options.map(t => "options" -> t.asJson),
        t.imageObject.map(t => "imageObject" -> t.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiFeedback: Decoder[Feedback] = Decoder.instance { c =>
     for {
        formId <- c.downField("formId").as[Int]
        dynamicData <- c.downField("dynamicData").as[com.edsancha.medallia.api.v0.models.FeedbackData]
      } yield {
        Feedback(
          formId = formId,
          dynamicData = dynamicData
        )
      }
    }

    implicit def encodeMedalliaApiFeedback: Encoder[Feedback] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("formId" -> t.formId.asJson),
        Some("dynamicData" -> t.dynamicData.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiFeedbackCheckbox: Decoder[FeedbackCheckbox] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        value <- c.downField("value").as[Seq[Int]]
        __type__ <- c.downField("type").as[String]
      } yield {
        FeedbackCheckbox(
          index = index,
          id = id,
          uniqueName = uniqueName,
          value = value,
          `type` = __type__
        )
      }
    }

    implicit def encodeMedalliaApiFeedbackCheckbox: Encoder[FeedbackCheckbox] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("value" -> t.value.asJson),
        Some("type" -> t.`type`.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiFeedbackData: Decoder[FeedbackData] = Decoder.instance { c =>
     for {
        customParams <- c.downField("customParams").as[Option[_root_.io.circe.Json]]
        pages <- c.downField("pages").as[Seq[com.edsancha.medallia.api.v0.models.FeedbackPage]]
      } yield {
        FeedbackData(
          customParams = customParams,
          pages = pages
        )
      }
    }

    implicit def encodeMedalliaApiFeedbackData: Encoder[FeedbackData] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.customParams.map(t => "customParams" -> t.asJson),
        Some("pages" -> t.pages.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiFeedbackDropdown: Decoder[FeedbackDropdown] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        value <- c.downField("value").as[Int]
        __type__ <- c.downField("type").as[String]
      } yield {
        FeedbackDropdown(
          index = index,
          id = id,
          uniqueName = uniqueName,
          value = value,
          `type` = __type__
        )
      }
    }

    implicit def encodeMedalliaApiFeedbackDropdown: Encoder[FeedbackDropdown] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("value" -> t.value.asJson),
        Some("type" -> t.`type`.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiFeedbackGrading: Decoder[FeedbackGrading] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        value <- c.downField("value").as[Int]
        __type__ <- c.downField("type").as[String]
      } yield {
        FeedbackGrading(
          index = index,
          id = id,
          uniqueName = uniqueName,
          value = value,
          `type` = __type__
        )
      }
    }

    implicit def encodeMedalliaApiFeedbackGrading: Encoder[FeedbackGrading] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("value" -> t.value.asJson),
        Some("type" -> t.`type`.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiFeedbackGrading0to10: Decoder[FeedbackGrading0to10] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        value <- c.downField("value").as[Int]
        __type__ <- c.downField("type").as[String]
      } yield {
        FeedbackGrading0to10(
          index = index,
          id = id,
          uniqueName = uniqueName,
          value = value,
          `type` = __type__
        )
      }
    }

    implicit def encodeMedalliaApiFeedbackGrading0to10: Encoder[FeedbackGrading0to10] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("value" -> t.value.asJson),
        Some("type" -> t.`type`.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiFeedbackGrading1to10: Decoder[FeedbackGrading1to10] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        value <- c.downField("value").as[Int]
        __type__ <- c.downField("type").as[String]
      } yield {
        FeedbackGrading1to10(
          index = index,
          id = id,
          uniqueName = uniqueName,
          value = value,
          `type` = __type__
        )
      }
    }

    implicit def encodeMedalliaApiFeedbackGrading1to10: Encoder[FeedbackGrading1to10] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("value" -> t.value.asJson),
        Some("type" -> t.`type`.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiFeedbackNps: Decoder[FeedbackNps] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        value <- c.downField("value").as[Int]
        __type__ <- c.downField("type").as[String]
      } yield {
        FeedbackNps(
          index = index,
          id = id,
          uniqueName = uniqueName,
          value = value,
          `type` = __type__
        )
      }
    }

    implicit def encodeMedalliaApiFeedbackNps: Encoder[FeedbackNps] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("value" -> t.value.asJson),
        Some("type" -> t.`type`.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiFeedbackPage: Decoder[FeedbackPage] = Decoder.instance { c =>
     for {
        components <- c.downField("components").as[Seq[com.edsancha.medallia.api.v0.models.FeedbackUnion]]
      } yield {
        FeedbackPage(
          components = components
        )
      }
    }

    implicit def encodeMedalliaApiFeedbackPage: Encoder[FeedbackPage] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("components" -> t.components.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiFeedbackRadioSelector: Decoder[FeedbackRadioSelector] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        value <- c.downField("value").as[Int]
        __type__ <- c.downField("type").as[String]
      } yield {
        FeedbackRadioSelector(
          index = index,
          id = id,
          uniqueName = uniqueName,
          value = value,
          `type` = __type__
        )
      }
    }

    implicit def encodeMedalliaApiFeedbackRadioSelector: Encoder[FeedbackRadioSelector] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("value" -> t.value.asJson),
        Some("type" -> t.`type`.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiFeedbackTextArea: Decoder[FeedbackTextArea] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        value <- c.downField("value").as[String]
        __type__ <- c.downField("type").as[String]
      } yield {
        FeedbackTextArea(
          index = index,
          id = id,
          uniqueName = uniqueName,
          value = value,
          `type` = __type__
        )
      }
    }

    implicit def encodeMedalliaApiFeedbackTextArea: Encoder[FeedbackTextArea] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("value" -> t.value.asJson),
        Some("type" -> t.`type`.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiFeedbackTextInput: Decoder[FeedbackTextInput] = Decoder.instance { c =>
     for {
        index <- c.downField("index").as[Int]
        id <- c.downField("id").as[Int]
        uniqueName <- c.downField("unique_name").as[String]
        value <- c.downField("value").as[String]
        __type__ <- c.downField("type").as[String]
      } yield {
        FeedbackTextInput(
          index = index,
          id = id,
          uniqueName = uniqueName,
          value = value,
          `type` = __type__
        )
      }
    }

    implicit def encodeMedalliaApiFeedbackTextInput: Encoder[FeedbackTextInput] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("index" -> t.index.asJson),
        Some("id" -> t.id.asJson),
        Some("unique_name" -> t.uniqueName.asJson),
        Some("value" -> t.value.asJson),
        Some("type" -> t.`type`.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiForm: Decoder[Form] = Decoder.instance { c =>
     for {
        formId <- c.downField("formId").as[Int]
        name <- c.downField("name").as[String]
        title <- c.downField("title").as[String]
        formType <- c.downField("formType").as[com.edsancha.medallia.api.v0.models.FormType]
        inviteData <- c.downField("inviteData").as[Option[com.edsancha.medallia.api.v0.models.InviteData]]
        triggerData <- c.downField("triggerData").as[Option[com.edsancha.medallia.api.v0.models.TriggerData]]
        formJson <- c.downField("formJson").as[com.edsancha.medallia.api.v0.models.FormJson]
      } yield {
        Form(
          formId = formId,
          name = name,
          title = title,
          formType = formType,
          inviteData = inviteData,
          triggerData = triggerData,
          formJson = formJson
        )
      }
    }

    implicit def encodeMedalliaApiForm: Encoder[Form] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("formId" -> t.formId.asJson),
        Some("name" -> t.name.asJson),
        Some("title" -> t.title.asJson),
        Some("formType" -> t.formType.asJson),
        t.inviteData.map(t => "inviteData" -> t.asJson),
        t.triggerData.map(t => "triggerData" -> t.asJson),
        Some("formJson" -> t.formJson.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiFormJson: Decoder[FormJson] = Decoder.instance { c =>
     for {
        pages <- c.downField("pages").as[Seq[com.edsancha.medallia.api.v0.models.Page]]
      } yield {
        FormJson(
          pages = pages
        )
      }
    }

    implicit def encodeMedalliaApiFormJson: Encoder[FormJson] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("pages" -> t.pages.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiImage: Decoder[Image] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        url <- c.downField("url").as[String]
      } yield {
        Image(
          name = name,
          url = url
        )
      }
    }

    implicit def encodeMedalliaApiImage: Encoder[Image] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("url" -> t.url.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiInviteData: Decoder[InviteData] = Decoder.instance { c =>
     for {
        invitationHeadline <- c.downField("invitationHeadline").as[String]
        invitationText <- c.downField("invitationText").as[String]
        provideButtonText <- c.downField("provideButtonText").as[String]
        declineButtonText <- c.downField("declineButtonText").as[String]
        laterButtonText <- c.downField("laterButtonText").as[String]
      } yield {
        InviteData(
          invitationHeadline = invitationHeadline,
          invitationText = invitationText,
          provideButtonText = provideButtonText,
          declineButtonText = declineButtonText,
          laterButtonText = laterButtonText
        )
      }
    }

    implicit def encodeMedalliaApiInviteData: Encoder[InviteData] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("invitationHeadline" -> t.invitationHeadline.asJson),
        Some("invitationText" -> t.invitationText.asJson),
        Some("provideButtonText" -> t.provideButtonText.asJson),
        Some("declineButtonText" -> t.declineButtonText.asJson),
        Some("laterButtonText" -> t.laterButtonText.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiNumberOfAppSession: Decoder[NumberOfAppSession] = Decoder.instance { c =>
     for {
        number <- c.downField("number").as[String]
        compareString <- c.downField("compareString").as[com.edsancha.medallia.api.v0.models.CompareString]
      } yield {
        NumberOfAppSession(
          number = number,
          compareString = compareString
        )
      }
    }

    implicit def encodeMedalliaApiNumberOfAppSession: Encoder[NumberOfAppSession] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("number" -> t.number.asJson),
        Some("compareString" -> t.compareString.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiNumberOfDays: Decoder[NumberOfDays] = Decoder.instance { c =>
     for {
        days <- c.downField("days").as[String]
      } yield {
        NumberOfDays(
          days = days
        )
      }
    }

    implicit def encodeMedalliaApiNumberOfDays: Encoder[NumberOfDays] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("days" -> t.days.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiPage: Decoder[Page] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        index <- c.downField("index").as[Int]
        dynamicData <- c.downField("dynamicData").as[Seq[com.edsancha.medallia.api.v0.models.ComponentUnion]]
      } yield {
        Page(
          name = name,
          index = index,
          dynamicData = dynamicData
        )
      }
    }

    implicit def encodeMedalliaApiPage: Encoder[Page] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("index" -> t.index.asJson),
        Some("dynamicData" -> t.dynamicData.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiPercentageOfSessions: Decoder[PercentageOfSessions] = Decoder.instance { c =>
     for {
        prec <- c.downField("prec").as[String]
      } yield {
        PercentageOfSessions(
          prec = prec
        )
      }
    }

    implicit def encodeMedalliaApiPercentageOfSessions: Encoder[PercentageOfSessions] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("prec" -> t.prec.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiTimeInForeground: Decoder[TimeInForeground] = Decoder.instance { c =>
     for {
        time <- c.downField("time").as[String]
        compareString <- c.downField("compareString").as[com.edsancha.medallia.api.v0.models.CompareString]
      } yield {
        TimeInForeground(
          time = time,
          compareString = compareString
        )
      }
    }

    implicit def encodeMedalliaApiTimeInForeground: Encoder[TimeInForeground] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("time" -> t.time.asJson),
        Some("compareString" -> t.compareString.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiTriggerData: Decoder[TriggerData] = Decoder.instance { c =>
     for {
        numberOfAppSession <- c.downField("numberOfAppSession").as[Option[com.edsancha.medallia.api.v0.models.NumberOfAppSession]]
        timeInForeground <- c.downField("timeInForeground").as[Option[com.edsancha.medallia.api.v0.models.TimeInForeground]]
        mobileappVersion <- c.downField("mobileappVersion").as[Option[Seq[String]]]
        submitted <- c.downField("submitted").as[Option[com.edsancha.medallia.api.v0.models.NumberOfDays]]
        declined <- c.downField("declined").as[Option[com.edsancha.medallia.api.v0.models.NumberOfDays]]
        mobileosVersion <- c.downField("mobileosVersion").as[Option[Seq[String]]]
        percentageOfSessions <- c.downField("percentageOfSessions").as[Option[com.edsancha.medallia.api.v0.models.PercentageOfSessions]]
        genericRule <- c.downField("genericRule").as[Option[String]]
      } yield {
        TriggerData(
          numberOfAppSession = numberOfAppSession,
          timeInForeground = timeInForeground,
          mobileappVersion = mobileappVersion,
          submitted = submitted,
          declined = declined,
          mobileosVersion = mobileosVersion,
          percentageOfSessions = percentageOfSessions,
          genericRule = genericRule
        )
      }
    }

    implicit def encodeMedalliaApiTriggerData: Encoder[TriggerData] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.numberOfAppSession.map(t => "numberOfAppSession" -> t.asJson),
        t.timeInForeground.map(t => "timeInForeground" -> t.asJson),
        t.mobileappVersion.map(t => "mobileappVersion" -> t.asJson),
        t.submitted.map(t => "submitted" -> t.asJson),
        t.declined.map(t => "declined" -> t.asJson),
        t.mobileosVersion.map(t => "mobileosVersion" -> t.asJson),
        t.percentageOfSessions.map(t => "percentageOfSessions" -> t.asJson),
        t.genericRule.map(t => "genericRule" -> t.asJson)
      ).flatten)
    }

    implicit def decodeMedalliaApiComponentUnion: Decoder[ComponentUnion] = Decoder.instance { c =>
      c.get[Option[String]]("component") match {
        case Right(Some(s)) if s == "label" => c.as[com.edsancha.medallia.api.v0.models.ComponentLabel]
        case Right(Some(s)) if s == "image" => c.as[com.edsancha.medallia.api.v0.models.ComponentImage]
        case Right(Some(s)) if s == "nps" => c.as[com.edsancha.medallia.api.v0.models.ComponentNps]
        case Right(Some(s)) if s == "textArea" => c.as[com.edsancha.medallia.api.v0.models.ComponentTextArea]
        case Right(Some(s)) if s == "textInput" => c.as[com.edsancha.medallia.api.v0.models.ComponentTextInput]
        case Right(Some(s)) if s == "radio" => c.as[com.edsancha.medallia.api.v0.models.ComponentRadioSelector]
        case Right(Some(s)) if s == "checkbox" => c.as[com.edsancha.medallia.api.v0.models.ComponentCheckbox]
        case Right(Some(s)) if s == "select" => c.as[com.edsancha.medallia.api.v0.models.ComponentDropdown]
        case Right(Some(s)) if s == "grading" => c.as[com.edsancha.medallia.api.v0.models.ComponentGrading]
        case Right(Some(s)) if s == "grading0to10" => c.as[com.edsancha.medallia.api.v0.models.ComponentGrading0to10]
        case Right(Some(s)) if s == "grading1to10" => c.as[com.edsancha.medallia.api.v0.models.ComponentGrading1to10]
        case Right(Some(s)) => Right(com.edsancha.medallia.api.v0.models.ComponentUnionUndefinedType(s))
        case _ => Left(DecodingFailure("Union[ComponentUnion] requires a discriminator named 'component' - this field was not found in the Json", c.history))
      }
    }

    implicit def encodeMedalliaApiComponentUnion: Encoder[ComponentUnion] = Encoder.instance {
      case t: com.edsancha.medallia.api.v0.models.ComponentLabel => t.asJson.mapObject(obj => ("component", Json.fromString("label")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.ComponentImage => t.asJson.mapObject(obj => ("component", Json.fromString("image")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.ComponentNps => t.asJson.mapObject(obj => ("component", Json.fromString("nps")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.ComponentTextArea => t.asJson.mapObject(obj => ("component", Json.fromString("textArea")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.ComponentTextInput => t.asJson.mapObject(obj => ("component", Json.fromString("textInput")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.ComponentRadioSelector => t.asJson.mapObject(obj => ("component", Json.fromString("radio")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.ComponentCheckbox => t.asJson.mapObject(obj => ("component", Json.fromString("checkbox")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.ComponentDropdown => t.asJson.mapObject(obj => ("component", Json.fromString("select")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.ComponentGrading => t.asJson.mapObject(obj => ("component", Json.fromString("grading")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.ComponentGrading0to10 => t.asJson.mapObject(obj => ("component", Json.fromString("grading0to10")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.ComponentGrading1to10 => t.asJson.mapObject(obj => ("component", Json.fromString("grading1to10")) +: obj)
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }

    implicit def decodeMedalliaApiFeedbackUnion: Decoder[FeedbackUnion] = Decoder.instance { c =>
      c.get[Option[String]]("component") match {
        case Right(Some(s)) if s == "nps" => c.as[com.edsancha.medallia.api.v0.models.FeedbackNps]
        case Right(Some(s)) if s == "textArea" => c.as[com.edsancha.medallia.api.v0.models.FeedbackTextArea]
        case Right(Some(s)) if s == "textInput" => c.as[com.edsancha.medallia.api.v0.models.FeedbackTextInput]
        case Right(Some(s)) if s == "radio" => c.as[com.edsancha.medallia.api.v0.models.FeedbackRadioSelector]
        case Right(Some(s)) if s == "checkbox" => c.as[com.edsancha.medallia.api.v0.models.FeedbackCheckbox]
        case Right(Some(s)) if s == "select" => c.as[com.edsancha.medallia.api.v0.models.FeedbackDropdown]
        case Right(Some(s)) if s == "grading" => c.as[com.edsancha.medallia.api.v0.models.FeedbackGrading]
        case Right(Some(s)) if s == "grading0to10" => c.as[com.edsancha.medallia.api.v0.models.FeedbackGrading0to10]
        case Right(Some(s)) if s == "grading1to10" => c.as[com.edsancha.medallia.api.v0.models.FeedbackGrading1to10]
        case Right(Some(s)) => Right(com.edsancha.medallia.api.v0.models.FeedbackUnionUndefinedType(s))
        case _ => Left(DecodingFailure("Union[FeedbackUnion] requires a discriminator named 'component' - this field was not found in the Json", c.history))
      }
    }

    implicit def encodeMedalliaApiFeedbackUnion: Encoder[FeedbackUnion] = Encoder.instance {
      case t: com.edsancha.medallia.api.v0.models.FeedbackNps => t.asJson.mapObject(obj => ("component", Json.fromString("nps")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.FeedbackTextArea => t.asJson.mapObject(obj => ("component", Json.fromString("textArea")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.FeedbackTextInput => t.asJson.mapObject(obj => ("component", Json.fromString("textInput")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.FeedbackRadioSelector => t.asJson.mapObject(obj => ("component", Json.fromString("radio")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.FeedbackCheckbox => t.asJson.mapObject(obj => ("component", Json.fromString("checkbox")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.FeedbackDropdown => t.asJson.mapObject(obj => ("component", Json.fromString("select")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.FeedbackGrading => t.asJson.mapObject(obj => ("component", Json.fromString("grading")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.FeedbackGrading0to10 => t.asJson.mapObject(obj => ("component", Json.fromString("grading0to10")) +: obj)
      case t: com.edsancha.medallia.api.v0.models.FeedbackGrading1to10 => t.asJson.mapObject(obj => ("component", Json.fromString("grading1to10")) +: obj)
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }
  }
}