/**
 * 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_18
 */
package com.edsancha.medallia.api.v0.models {

  /**
   * Represents the question or fields to be filled by the user
   */
  sealed trait ComponentUnion extends _root_.scala.Product with _root_.scala.Serializable {
    def componentUnionComponent: ComponentUnionComponent
  }

  /**
   * Defines the valid component values for the type ComponentUnion
   */
  sealed trait ComponentUnionComponent extends _root_.scala.Product with _root_.scala.Serializable

  object ComponentUnionComponent {

    case object ComponentLabel extends ComponentUnionComponent { override def toString = "label" }
    case object ComponentImage extends ComponentUnionComponent { override def toString = "image" }
    case object ComponentNps extends ComponentUnionComponent { override def toString = "nps" }
    case object ComponentTextArea extends ComponentUnionComponent { override def toString = "textArea" }
    case object ComponentTextInput extends ComponentUnionComponent { override def toString = "textInput" }
    case object ComponentRadioSelector extends ComponentUnionComponent { override def toString = "radio" }
    case object ComponentCheckbox extends ComponentUnionComponent { override def toString = "checkbox" }
    case object ComponentDropdown extends ComponentUnionComponent { override def toString = "select" }
    case object ComponentGrading extends ComponentUnionComponent { override def toString = "grading" }
    case object ComponentGrading0to10 extends ComponentUnionComponent { override def toString = "grading0to10" }
    case object ComponentGrading1to10 extends ComponentUnionComponent { override def toString = "grading1to10" }

    final case class UNDEFINED(override val toString: String) extends ComponentUnionComponent

    val all: scala.List[ComponentUnionComponent] = scala.List(ComponentLabel, ComponentImage, ComponentNps, ComponentTextArea, ComponentTextInput, ComponentRadioSelector, ComponentCheckbox, ComponentDropdown, ComponentGrading, ComponentGrading0to10, ComponentGrading1to10)

    private val byName: Map[String, ComponentUnionComponent] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): ComponentUnionComponent = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[ComponentUnionComponent] = byName.get(value.toLowerCase)

  }

  /**
   * Represents the component or fields to be filled by the user
   */
  sealed trait FeedbackUnion extends _root_.scala.Product with _root_.scala.Serializable {
    def feedbackUnionComponent: FeedbackUnionComponent
  }

  /**
   * Defines the valid component values for the type FeedbackUnion
   */
  sealed trait FeedbackUnionComponent extends _root_.scala.Product with _root_.scala.Serializable

  object FeedbackUnionComponent {

    case object FeedbackNps extends FeedbackUnionComponent { override def toString = "nps" }
    case object FeedbackTextArea extends FeedbackUnionComponent { override def toString = "textArea" }
    case object FeedbackTextInput extends FeedbackUnionComponent { override def toString = "textInput" }
    case object FeedbackRadioSelector extends FeedbackUnionComponent { override def toString = "radio" }
    case object FeedbackCheckbox extends FeedbackUnionComponent { override def toString = "checkbox" }
    case object FeedbackDropdown extends FeedbackUnionComponent { override def toString = "select" }
    case object FeedbackGrading extends FeedbackUnionComponent { override def toString = "grading" }
    case object FeedbackGrading0to10 extends FeedbackUnionComponent { override def toString = "grading0to10" }
    case object FeedbackGrading1to10 extends FeedbackUnionComponent { override def toString = "grading1to10" }

    final case class UNDEFINED(override val toString: String) extends FeedbackUnionComponent

    val all: scala.List[FeedbackUnionComponent] = scala.List(FeedbackNps, FeedbackTextArea, FeedbackTextInput, FeedbackRadioSelector, FeedbackCheckbox, FeedbackDropdown, FeedbackGrading, FeedbackGrading0to10, FeedbackGrading1to10)

    private val byName: Map[String, FeedbackUnionComponent] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): FeedbackUnionComponent = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[FeedbackUnionComponent] = byName.get(value.toLowerCase)

  }
  /**
   * JWT Access Token to be used to access the APIe
   *
   * @param accessToken JWT Access Token to be used to access the API
   */

  final case class AccessTokenWrapper(
    accessToken: String
  )

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param required Component required
   * @param label Component label
   * @param options Maximum number of characters
   * @param description Component description
   */

  final case class ComponentCheckbox(
    index: Int,
    id: Int,
    uniqueName: String,
    required: Boolean,
    label: String,
    options: Seq[String],
    description: _root_.scala.Option[String] = None
  ) extends ComponentUnion {
    override val componentUnionComponent: ComponentUnionComponent = ComponentUnionComponent.ComponentCheckbox
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param required Component required
   * @param placeholder Component placeholder
   * @param label Component label
   * @param options Maximum number of characters
   * @param description Component description
   */

  final case class ComponentDropdown(
    index: Int,
    id: Int,
    uniqueName: String,
    required: Boolean,
    placeholder: String,
    label: String,
    options: Seq[String],
    description: _root_.scala.Option[String] = None
  ) extends ComponentUnion {
    override val componentUnionComponent: ComponentUnionComponent = ComponentUnionComponent.ComponentDropdown
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param required Component required
   * @param label Component label
   * @param ratingViewType Rating View Type
   * @param description Component description
   */

  final case class ComponentGrading(
    index: Int,
    id: Int,
    uniqueName: String,
    required: Boolean,
    label: String,
    ratingViewType: com.edsancha.medallia.api.v0.models.RatingViewType = com.edsancha.medallia.api.v0.models.RatingViewType.GradingSlider,
    description: _root_.scala.Option[String] = None
  ) extends ComponentUnion {
    override val componentUnionComponent: ComponentUnionComponent = ComponentUnionComponent.ComponentGrading
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param required Component required
   * @param label Component label
   * @param ratingViewType Rating View Type
   * @param description Component description
   */

  final case class ComponentGrading0to10(
    index: Int,
    id: Int,
    uniqueName: String,
    required: Boolean,
    label: String,
    ratingViewType: com.edsancha.medallia.api.v0.models.RatingViewType = com.edsancha.medallia.api.v0.models.RatingViewType.GradingSlider,
    description: _root_.scala.Option[String] = None
  ) extends ComponentUnion {
    override val componentUnionComponent: ComponentUnionComponent = ComponentUnionComponent.ComponentGrading0to10
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param required Component required
   * @param label Component label
   * @param ratingViewType Rating View Type
   * @param description Component description
   */

  final case class ComponentGrading1to10(
    index: Int,
    id: Int,
    uniqueName: String,
    required: Boolean,
    label: String,
    ratingViewType: com.edsancha.medallia.api.v0.models.RatingViewType = com.edsancha.medallia.api.v0.models.RatingViewType.GradingSlider,
    description: _root_.scala.Option[String] = None
  ) extends ComponentUnion {
    override val componentUnionComponent: ComponentUnionComponent = ComponentUnionComponent.ComponentGrading1to10
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param imageObject Image Object uploaded to Medallia, if it's a copy of a previous survey this
   *        field doesnt' show up
   * @param uploadedResource Image Object from a copied survey, it only shows when imageObject is not present
   */

  final case class ComponentImage(
    index: Int,
    id: Int,
    uniqueName: String,
    imageObject: _root_.scala.Option[com.edsancha.medallia.api.v0.models.Image] = None,
    uploadedResource: _root_.scala.Option[com.edsancha.medallia.api.v0.models.Image] = None
  ) extends ComponentUnion {
    override val componentUnionComponent: ComponentUnionComponent = ComponentUnionComponent.ComponentImage
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param labelContent Label Content
   * @param numOfLines Label Number of Lines
   */

  final case class ComponentLabel(
    index: Int,
    id: Int,
    uniqueName: String,
    labelContent: _root_.scala.Option[String] = None,
    numOfLines: Int = 2
  ) extends ComponentUnion {
    override val componentUnionComponent: ComponentUnionComponent = ComponentUnionComponent.ComponentLabel
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param required Component required
   * @param label Component placeholder
   * @param description Component description
   * @param ratingViewType Rating View Type
   */

  final case class ComponentNps(
    index: Int,
    id: Int,
    uniqueName: String,
    required: Boolean,
    label: String,
    description: _root_.scala.Option[String] = None,
    ratingViewType: com.edsancha.medallia.api.v0.models.RatingViewType = com.edsancha.medallia.api.v0.models.RatingViewType.Slide
  ) extends ComponentUnion {
    override val componentUnionComponent: ComponentUnionComponent = ComponentUnionComponent.ComponentNps
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param required Component required
   * @param label Component label
   * @param options Maximum number of characters
   * @param description Component description
   */

  final case class ComponentRadioSelector(
    index: Int,
    id: Int,
    uniqueName: String,
    required: Boolean,
    label: String,
    options: Seq[String],
    description: _root_.scala.Option[String] = None
  ) extends ComponentUnion {
    override val componentUnionComponent: ComponentUnionComponent = ComponentUnionComponent.ComponentRadioSelector
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param required Component required
   * @param placeholder Component placeholder
   * @param label Component placeholder
   * @param numOfLines Number of lines, string parameter though (－‸ლ)
   * @param description Component description
   */

  final case class ComponentTextArea(
    index: Int,
    id: Int,
    uniqueName: String,
    required: Boolean,
    placeholder: String,
    label: String,
    numOfLines: Int = 2,
    description: _root_.scala.Option[String] = None
  ) extends ComponentUnion {
    override val componentUnionComponent: ComponentUnionComponent = ComponentUnionComponent.ComponentTextArea
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param required Component required
   * @param placeholder Component placeholder
   * @param label Component label
   * @param maxChars Maximum number of characters
   * @param description Component description
   */

  final case class ComponentTextInput(
    index: Int,
    id: Int,
    uniqueName: String,
    required: Boolean,
    placeholder: String,
    label: String,
    maxChars: Int = 200,
    description: _root_.scala.Option[String] = None
  ) extends ComponentUnion {
    override val componentUnionComponent: ComponentUnionComponent = ComponentUnionComponent.ComponentTextInput
  }

  /**
   * Configuration main object, including forms
   *
   * @param propertyId Account id
   * @param feedbackSubmitUrl url
   * @param forms Definition and configuration of forms that were created in the command center
   */

  final case class Configuration(
    propertyId: Int,
    feedbackSubmitUrl: String,
    forms: Seq[com.edsancha.medallia.api.v0.models.Form]
  )

  /**
   * @param index Component index
   * @param id Component id
   * @param required Component required
   * @param component Component type
   * @param uniqueName Component unique name
   * @param placeholder Component placeholder
   * @param label Component placeholder
   * @param description Component description
   * @param options Options available if required
   * @param imageObject Image if required
   */

  final case class DynamicData(
    index: Int,
    id: Int,
    required: Boolean,
    component: String,
    uniqueName: String,
    placeholder: String,
    label: String,
    description: _root_.scala.Option[String] = None,
    options: _root_.scala.Option[Seq[String]] = None,
    imageObject: _root_.scala.Option[com.edsancha.medallia.api.v0.models.Image] = None
  )

  /**
   * Feedback main object with survey's results
   *
   * @param formId The submitted form id (from the configuration).
   * @param dynamicData Survey Feedback Data
   */

  final case class Feedback(
    formId: Int,
    dynamicData: com.edsancha.medallia.api.v0.models.FeedbackData
  )

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param value Checkbox selected value
   * @param `type` Component feedback type
   */

  final case class FeedbackCheckbox(
    index: Int,
    id: Int,
    uniqueName: String,
    value: Seq[Int],
    `type`: String = "checkbox"
  ) extends FeedbackUnion {
    override val feedbackUnionComponent: FeedbackUnionComponent = FeedbackUnionComponent.FeedbackCheckbox
  }

  /**
   * Object that will hold the form pages and custom parameters.
   *
   * @param customParams List of survey's pages results
   * @param pages List of survey's pages results
   */

  final case class FeedbackData(
    customParams: _root_.scala.Option[_root_.io.circe.Json] = None,
    pages: Seq[com.edsancha.medallia.api.v0.models.FeedbackPage]
  )

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param value Dropdown selected value
   * @param `type` Component feedback type
   */

  final case class FeedbackDropdown(
    index: Int,
    id: Int,
    uniqueName: String,
    value: Int,
    `type`: String = "select"
  ) extends FeedbackUnion {
    override val feedbackUnionComponent: FeedbackUnionComponent = FeedbackUnionComponent.FeedbackDropdown
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param value Grading selected value
   * @param `type` Component feedback type
   */

  final case class FeedbackGrading(
    index: Int,
    id: Int,
    uniqueName: String,
    value: Int,
    `type`: String = "grading"
  ) extends FeedbackUnion {
    override val feedbackUnionComponent: FeedbackUnionComponent = FeedbackUnionComponent.FeedbackGrading
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param value Grading selected value
   * @param `type` Component feedback type
   */

  final case class FeedbackGrading0to10(
    index: Int,
    id: Int,
    uniqueName: String,
    value: Int,
    `type`: String = "grading0to10"
  ) extends FeedbackUnion {
    override val feedbackUnionComponent: FeedbackUnionComponent = FeedbackUnionComponent.FeedbackGrading0to10
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param value Grading selected value
   * @param `type` Component feedback type
   */

  final case class FeedbackGrading1to10(
    index: Int,
    id: Int,
    uniqueName: String,
    value: Int,
    `type`: String = "grading1to10"
  ) extends FeedbackUnion {
    override val feedbackUnionComponent: FeedbackUnionComponent = FeedbackUnionComponent.FeedbackGrading1to10
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param value NPS selected value
   * @param `type` Component feedback type
   */

  final case class FeedbackNps(
    index: Int,
    id: Int,
    uniqueName: String,
    value: Int,
    `type`: String = "nps"
  ) extends FeedbackUnion {
    override val feedbackUnionComponent: FeedbackUnionComponent = FeedbackUnionComponent.FeedbackNps
  }

  /**
   * Object that will hold the form page
   *
   * @param components List of survey's pages results
   */

  final case class FeedbackPage(
    components: Seq[com.edsancha.medallia.api.v0.models.FeedbackUnion]
  )

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param value Radio Selected Value
   * @param `type` Component feedback type
   */

  final case class FeedbackRadioSelector(
    index: Int,
    id: Int,
    uniqueName: String,
    value: Int,
    `type`: String = "radio"
  ) extends FeedbackUnion {
    override val feedbackUnionComponent: FeedbackUnionComponent = FeedbackUnionComponent.FeedbackRadioSelector
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param value Text Area Content
   * @param `type` Component feedback type
   */

  final case class FeedbackTextArea(
    index: Int,
    id: Int,
    uniqueName: String,
    value: String,
    `type`: String = "textArea"
  ) extends FeedbackUnion {
    override val feedbackUnionComponent: FeedbackUnionComponent = FeedbackUnionComponent.FeedbackTextArea
  }

  /**
   * @param index Component index
   * @param id Component id
   * @param uniqueName Unique name
   * @param value Text Area Content
   * @param `type` Component feedback type
   */

  final case class FeedbackTextInput(
    index: Int,
    id: Int,
    uniqueName: String,
    value: String,
    `type`: String = "textInput"
  ) extends FeedbackUnion {
    override val feedbackUnionComponent: FeedbackUnionComponent = FeedbackUnionComponent.FeedbackTextInput
  }

  /**
   * @param formId Form Identifier
   * @param name Form name
   * @param title Form title
   * @param formType Form type
   * @param inviteData Invitation data
   * @param triggerData Invitation trigger conditions
   * @param formJson Wrapper around form data
   */

  final case class Form(
    formId: Int,
    name: String,
    title: String,
    formType: com.edsancha.medallia.api.v0.models.FormType,
    inviteData: _root_.scala.Option[com.edsancha.medallia.api.v0.models.InviteData] = None,
    triggerData: _root_.scala.Option[com.edsancha.medallia.api.v0.models.TriggerData] = None,
    formJson: com.edsancha.medallia.api.v0.models.FormJson
  )

  /**
   * @param pages Form Page
   */

  final case class FormJson(
    pages: Seq[com.edsancha.medallia.api.v0.models.Page]
  )

  /**
   * @param name Image Name
   * @param url Image Url
   */

  final case class Image(
    name: String,
    url: String
  )

  /**
   * @param invitationHeadline Invitation Headline
   * @param invitationText Invitation Text
   * @param provideButtonText Provide feedback button text
   * @param declineButtonText Decline provide feedback button text
   * @param laterButtonText Provide feedback later button text
   */

  final case class InviteData(
    invitationHeadline: String,
    invitationText: String,
    provideButtonText: String,
    declineButtonText: String,
    laterButtonText: String
  )

  /**
   * @param number Number of app sessions
   * @param compareString Compare String
   */

  final case class NumberOfAppSession(
    number: String,
    compareString: com.edsancha.medallia.api.v0.models.CompareString
  )

  /**
   * @param days Don't invite a visitor who submitted feedback in the past x days
   */

  final case class NumberOfDays(
    days: String
  )

  /**
   * @param name Page name
   * @param index Page index
   */

  final case class Page(
    name: String,
    index: Int = 0,
    dynamicData: Seq[com.edsancha.medallia.api.v0.models.ComponentUnion]
  )

  /**
   * @param prec Don't invite a visitor who submitted feedback in the past x days
   */

  final case class PercentageOfSessions(
    prec: String
  )

  /**
   * @param time Time in Foreground, in seconds
   * @param compareString Compare String
   */

  final case class TimeInForeground(
    time: String,
    compareString: com.edsancha.medallia.api.v0.models.CompareString
  )

  /**
   * @param numberOfAppSession Number of App Sessions to show the invite, with compare string
   * @param timeInForeground App Time in foreground in seconds to show the invite, with compare string
   * @param mobileappVersion Mobile App Versions
   * @param submitted Don't invite a visitor who submitted feedback in the past x days
   * @param declined Don't invite a visitor who declined an invitation in the past x days
   * @param mobileosVersion Mobile App Versions
   * @param percentageOfSessions Invite to this percentage of sessions
   * @param genericRule Set of generic rules creates in the invitation settings
   */

  final case class TriggerData(
    numberOfAppSession: _root_.scala.Option[com.edsancha.medallia.api.v0.models.NumberOfAppSession] = None,
    timeInForeground: _root_.scala.Option[com.edsancha.medallia.api.v0.models.TimeInForeground] = None,
    mobileappVersion: _root_.scala.Option[Seq[String]] = None,
    submitted: _root_.scala.Option[com.edsancha.medallia.api.v0.models.NumberOfDays] = None,
    declined: _root_.scala.Option[com.edsancha.medallia.api.v0.models.NumberOfDays] = None,
    mobileosVersion: _root_.scala.Option[Seq[String]] = None,
    percentageOfSessions: _root_.scala.Option[com.edsancha.medallia.api.v0.models.PercentageOfSessions] = None,
    genericRule: _root_.scala.Option[String] = None
  )

  /**
   * Provides future compatibility in clients - in the future, when a type is added
   * to the union ComponentUnion, it will need to be handled in the client code. This
   * implementation will deserialize these future types as an instance of this class.
   *
   * @param description Information about the type that we received that is undefined in this version of
   *        the client.
   */

  final case class ComponentUnionUndefinedType(
    description: String
  ) extends ComponentUnion {
    override val componentUnionComponent: ComponentUnionComponent = ComponentUnionComponent.UNDEFINED(description)
  }

  /**
   * Provides future compatibility in clients - in the future, when a type is added
   * to the union FeedbackUnion, it will need to be handled in the client code. This
   * implementation will deserialize these future types as an instance of this class.
   *
   * @param description Information about the type that we received that is undefined in this version of
   *        the client.
   */

  final case class FeedbackUnionUndefinedType(
    description: String
  ) extends FeedbackUnion {
    override val feedbackUnionComponent: FeedbackUnionComponent = FeedbackUnionComponent.UNDEFINED(description)
  }
  sealed trait CompareString extends _root_.scala.Product with _root_.scala.Serializable

  object CompareString {

    case object GreaterThan extends CompareString { override def toString = "greaterThan" }
    case object Equals extends CompareString { override def toString = "equals" }
    case object SmallerThan extends CompareString { override def toString = "smallerThan" }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious to users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends CompareString

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[CompareString] = scala.List(GreaterThan, Equals, SmallerThan)

    private
    val byName: Map[String, CompareString] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): CompareString = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[CompareString] = byName.get(value.toLowerCase)

  }

  sealed trait FormType extends _root_.scala.Product with _root_.scala.Serializable

  object FormType {

    case object MobileInvitation extends FormType { override def toString = "mobileInvitation" }
    case object Code extends FormType { override def toString = "code" }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious to users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends FormType

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[FormType] = scala.List(MobileInvitation, Code)

    private
    val byName: Map[String, FormType] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): FormType = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[FormType] = byName.get(value.toLowerCase)

  }

  sealed trait RatingViewType extends _root_.scala.Product with _root_.scala.Serializable

  object RatingViewType {

    case object Slide extends RatingViewType { override def toString = "slide" }
    case object NumbersSquare extends RatingViewType { override def toString = "numbersSquare" }
    case object GradingSlider extends RatingViewType { override def toString = "gradingSlider" }
    case object GradingDropdown extends RatingViewType { override def toString = "gradingDropdown" }
    case object Stars extends RatingViewType { override def toString = "stars" }
    case object Emoticons extends RatingViewType { override def toString = "emoticons" }
    case object Numbers extends RatingViewType { override def toString = "numbers" }
    case object Smilies extends RatingViewType { override def toString = "smilies" }
    case object Bars extends RatingViewType { override def toString = "bars" }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious to users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends RatingViewType

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[RatingViewType] = scala.List(Slide, NumbersSquare, GradingSlider, GradingDropdown, Stars, Emoticons, Numbers, Smilies, Bars)

    private
    val byName: Map[String, RatingViewType] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): RatingViewType = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[RatingViewType] = byName.get(value.toLowerCase)

  }

}

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")
    }
  }
}

package com.edsancha.medallia.api.v0 {
import cats.effect._
import cats.implicits._
import io.circe.syntax._
import scala.language.higherKinds

  object Constants {

    val BaseUrl = "https://api-us.kampyle.com/api/v1"
    val Namespace = "com.edsancha.medallia.api.v0"
    val UserAgent = "apibuilder app.apibuilder.io/edsancha/medallia-api/0.0.1/http4s_0_18"
    val Version = "0.0.1"
    val VersionMajor = 0

  }

  class Client[F[_]: Sync](
    val baseUrl: org.http4s.Uri = org.http4s.Uri.unsafeFromString("https://api-us.kampyle.com/api/v1"),
    auth: scala.Option[com.edsancha.medallia.api.v0.Authorization] = None,
    defaultHeaders: Seq[(String, String)] = Nil,
    httpClient: org.http4s.client.Client[F]
  ) extends interfaces.Client[F] {
    import org.http4s.Response
    import com.edsancha.medallia.api.v0.models.json._
    import com.edsancha.survey.models.v0.models.json._


    def accessTokenWrappers: AccessTokenWrappers[F] = AccessTokenWrappers

    def configurations: Configurations[F] = Configurations

    def feedbacks: Feedbacks[F] = Feedbacks

    object AccessTokenWrappers extends AccessTokenWrappers[F] {
      override def postAccessToken(
        requestHeaders: Seq[(String, String)] = Nil
      ): F[com.edsancha.medallia.api.v0.models.AccessTokenWrapper] = {
        val urlPath = Seq("accessToken")

        _executeRequest[Unit, com.edsancha.medallia.api.v0.models.AccessTokenWrapper]("POST", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.com.edsancha.medallia.api.v0.Client.parseJson[F, com.edsancha.medallia.api.v0.models.AccessTokenWrapper]("com.edsancha.medallia.api.v0.models.AccessTokenWrapper", r)
          case r if r.status.code == 401 => Sync[F].raiseError(new com.edsancha.medallia.api.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 500 => Sync[F].raiseError(new com.edsancha.medallia.api.v0.errors.UnitResponse(r.status.code))
          case r => Sync[F].raiseError(new com.edsancha.medallia.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 500"))
        }
      }
    }

    object Configurations extends Configurations[F] {
      override def getConfiguration(
        requestHeaders: Seq[(String, String)] = Nil
      ): F[com.edsancha.medallia.api.v0.models.Configuration] = {
        val urlPath = Seq("configuration")

        _executeRequest[Unit, com.edsancha.medallia.api.v0.models.Configuration]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.com.edsancha.medallia.api.v0.Client.parseJson[F, com.edsancha.medallia.api.v0.models.Configuration]("com.edsancha.medallia.api.v0.models.Configuration", r)
          case r if r.status.code == 400 => Sync[F].raiseError(new com.edsancha.medallia.api.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 401 => Sync[F].raiseError(new com.edsancha.medallia.api.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 500 => Sync[F].raiseError(new com.edsancha.medallia.api.v0.errors.UnitResponse(r.status.code))
          case r => Sync[F].raiseError(new com.edsancha.medallia.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 400, 401, 500"))
        }
      }
    }

    object Feedbacks extends Feedbacks[F] {
      override def postFeedback(
        feedback: com.edsancha.medallia.api.v0.models.Feedback,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("feedback")

        val (payload, formPayload) = (Some(feedback), None)

        _executeRequest[com.edsancha.medallia.api.v0.models.Feedback, Unit]("POST", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => Sync[F].pure(())
          case r if r.status.code == 400 => Sync[F].raiseError(new com.edsancha.medallia.api.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 401 => Sync[F].raiseError(new com.edsancha.medallia.api.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 500 => Sync[F].raiseError(new com.edsancha.medallia.api.v0.errors.UnitResponse(r.status.code))
          case r => Sync[F].raiseError(new com.edsancha.medallia.api.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 400, 401, 500"))
        }
      }
    }

    private lazy val defaultApiHeaders = Seq(
      ("User-Agent", Constants.UserAgent),
      ("X-Apidoc-Version", Constants.Version),
      ("X-Apidoc-Version-Major", Constants.VersionMajor.toString)
    )

    def apiHeaders: Seq[(String, String)] = defaultApiHeaders

    def modifyRequest(request: F[org.http4s.Request[F]]): F[org.http4s.Request[F]] = request

    implicit def circeJsonEncoder[F[_]: Sync, A](implicit encoder: io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[F, A]

    def _executeRequest[T, U](
      method: String,
      path: Seq[String],
      queryParameters: Seq[(String, String)] = Nil,
      requestHeaders: Seq[(String, String)] = Nil,
      body: Option[T] = None,
      formBody : Option[org.http4s.UrlForm] = None
    )(handler: org.http4s.Response[F] => F[U]
    )(implicit encoder: io.circe.Encoder[T]): F[U] = {
      import org.http4s.QueryParamEncoder._

      val m = org.http4s.Method.fromString(method) match {
        case Right(m) => m
        case Left(e) => sys.error(e.toString)
      }

      val headers = org.http4s.Headers((
        apiHeaders ++
        defaultHeaders ++
        requestHeaders
      ).groupBy(_._1).map { case (k, l) => org.http4s.Header(k, l.last._2) }.toList)

      val queryMap = queryParameters.groupBy(_._1).map { case (k, v) => k -> v.map(_._2) }
      val uri = path.foldLeft(baseUrl){ case (uri, segment) => uri / segment }.setQueryParams(queryMap)

      val request = org.http4s.Request[F](method = m,
                                       uri = uri,
                                       headers = headers)

      val reqAndMaybeAuth = auth.fold(request) {
        case Authorization.Basic(username, passwordOpt) => {
          val userpass = s"$username:${passwordOpt.getOrElse("")}"
          val token = java.util.Base64.getEncoder.encodeToString(userpass.getBytes(java.nio.charset.StandardCharsets.ISO_8859_1))
          request.putHeaders(org.http4s.Header("Authorization", s"Basic $token"))
        }
        case a => sys.error("Invalid authorization scheme[" + a.getClass + "]")
      }

      val reqAndMaybeAuthAndBody =
        if (formBody.nonEmpty) formBody.fold(Sync[F].pure(reqAndMaybeAuth))(reqAndMaybeAuth.withBody)
        else body.fold(Sync[F].pure(reqAndMaybeAuth))(reqAndMaybeAuth.withBody)

      httpClient.fetch(modifyRequest(reqAndMaybeAuthAndBody))(handler)
    }
  }

  object Client {
    import cats.effect._

    implicit def circeJsonDecoder[F[_]: Sync, A](implicit decoder: io.circe.Decoder[A]) = org.http4s.circe.jsonOf[F, A]

    def parseJson[F[_]: Sync, T](
      className: String,
      r: org.http4s.Response[F]
    )(implicit decoder: io.circe.Decoder[T]): F[T] = r.attemptAs[T].value.flatMap {
      case Right(value) => Sync[F].pure(value)
      case Left(error) => Sync[F].raiseError(new com.edsancha.medallia.api.v0.errors.FailedRequest(r.status.code, s"Invalid json for class[" + className + "]", None, error))
    }
  }

  sealed trait Authorization extends _root_.scala.Product with _root_.scala.Serializable
  object Authorization {
    final case class Basic(username: String, password: Option[String] = None) extends Authorization
  }

  package interfaces {

    trait Client[F[_]] {
      def baseUrl: org.http4s.Uri
      def accessTokenWrappers: com.edsancha.medallia.api.v0.AccessTokenWrappers[F]
      def configurations: com.edsancha.medallia.api.v0.Configurations[F]
      def feedbacks: com.edsancha.medallia.api.v0.Feedbacks[F]
    }

  }

  trait AccessTokenWrappers[F[_]] {
    /**
     * This API is used to retrieve the temporary access token that allows your app to
     * access all other APIs
     */
    def postAccessToken(
      requestHeaders: Seq[(String, String)] = Nil
    ): F[com.edsancha.medallia.api.v0.models.AccessTokenWrapper]
  }

  trait Configurations[F[_]] {
    /**
     * This API returns the full configuration as defined in the Medallia Digital
     * command center. It returns the list of surveys, their content and business logic
     * as well as targeting and segmentation rules.
     */
    def getConfiguration(
      requestHeaders: Seq[(String, String)] = Nil
    ): F[com.edsancha.medallia.api.v0.models.Configuration]
  }

  trait Feedbacks[F[_]] {
    /**
     * This API allows the application to submit feedback collected in the app to the
     * Medallia Digital
     */
    def postFeedback(
      feedback: com.edsancha.medallia.api.v0.models.Feedback,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Unit]
  }

  package errors {

    final case class UnitResponse(status: Int) extends Exception(s"HTTP $status")

    final case class FailedRequest(responseCode: Int, message: String, requestUri: Option[_root_.java.net.URI] = None, parent: Exception = null) extends _root_.java.lang.Exception(s"HTTP $responseCode: $message", parent)

  }
}