/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.16.74
 * User agent: apibuilder app.apibuilder.io/apicollective/apibuilder-postman-collection-v2-1/0.16.74/http4s_0_15
 */
package io.apibuilder.postman.collection.v21.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 io.apibuilder.postman.collection.v21.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 jsonDecoderApiBuilderPostmanCollectionV21AuthEnum: Decoder[io.apibuilder.postman.collection.v21.v0.models.AuthEnum] =
      Decoder.decodeString.map(io.apibuilder.postman.collection.v21.v0.models.AuthEnum(_))

    implicit val jsonEncoderApiBuilderPostmanCollectionV21AuthEnum: Encoder[io.apibuilder.postman.collection.v21.v0.models.AuthEnum] =
      Encoder.encodeString.contramap[io.apibuilder.postman.collection.v21.v0.models.AuthEnum](_.toString)

    implicit val jsonDecoderApiBuilderPostmanCollectionV21BodyMode: Decoder[io.apibuilder.postman.collection.v21.v0.models.BodyMode] =
      Decoder.decodeString.map(io.apibuilder.postman.collection.v21.v0.models.BodyMode(_))

    implicit val jsonEncoderApiBuilderPostmanCollectionV21BodyMode: Encoder[io.apibuilder.postman.collection.v21.v0.models.BodyMode] =
      Encoder.encodeString.contramap[io.apibuilder.postman.collection.v21.v0.models.BodyMode](_.toString)

    implicit val jsonDecoderApiBuilderPostmanCollectionV21EventType: Decoder[io.apibuilder.postman.collection.v21.v0.models.EventType] =
      Decoder.decodeString.map(io.apibuilder.postman.collection.v21.v0.models.EventType(_))

    implicit val jsonEncoderApiBuilderPostmanCollectionV21EventType: Encoder[io.apibuilder.postman.collection.v21.v0.models.EventType] =
      Encoder.encodeString.contramap[io.apibuilder.postman.collection.v21.v0.models.EventType](_.toString)

    implicit val jsonDecoderApiBuilderPostmanCollectionV21Method: Decoder[io.apibuilder.postman.collection.v21.v0.models.Method] =
      Decoder.decodeString.map(io.apibuilder.postman.collection.v21.v0.models.Method(_))

    implicit val jsonEncoderApiBuilderPostmanCollectionV21Method: Encoder[io.apibuilder.postman.collection.v21.v0.models.Method] =
      Encoder.encodeString.contramap[io.apibuilder.postman.collection.v21.v0.models.Method](_.toString)

    implicit def decodeApiBuilderPostmanCollectionV21Auth: Decoder[Auth] = Decoder.instance { c =>
     for {
        __type__ <- c.downField("type").as[io.apibuilder.postman.collection.v21.v0.models.AuthEnum]
        basic <- c.downField("basic").as[Option[Seq[io.apibuilder.postman.collection.v21.v0.models.BasicAuth]]]
      } yield {
        Auth(
          `type` = __type__,
          basic = basic
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Auth: Encoder[Auth] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("type" -> t.`type`.asJson),
        t.basic.map(t => "basic" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21BasicAuth: Decoder[BasicAuth] = Decoder.instance { c =>
     for {
        key <- c.downField("key").as[String]
        value <- c.downField("value").as[String]
        __type__ <- c.downField("type").as[Option[String]]
      } yield {
        BasicAuth(
          key = key,
          value = value,
          `type` = __type__
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21BasicAuth: Encoder[BasicAuth] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("key" -> t.key.asJson),
        Some("value" -> t.value.asJson),
        t.`type`.map(t => "type" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21Body: Decoder[Body] = Decoder.instance { c =>
     for {
        raw <- c.downField("raw").as[Option[String]]
        mode <- c.downField("mode").as[Option[io.apibuilder.postman.collection.v21.v0.models.BodyMode]]
        urlencoded <- c.downField("urlencoded").as[Option[Seq[io.apibuilder.postman.collection.v21.v0.models.UrlEncoded]]]
        file <- c.downField("file").as[Option[io.apibuilder.postman.collection.v21.v0.models.File]]
        formdata <- c.downField("formdata").as[Option[Seq[io.apibuilder.postman.collection.v21.v0.models.FormParameter]]]
      } yield {
        Body(
          raw = raw,
          mode = mode,
          urlencoded = urlencoded,
          file = file,
          formdata = formdata
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Body: Encoder[Body] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.raw.map(t => "raw" -> t.asJson),
        t.mode.map(t => "mode" -> t.asJson),
        t.urlencoded.map(t => "urlencoded" -> t.asJson),
        t.file.map(t => "file" -> t.asJson),
        t.formdata.map(t => "formdata" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21Collection: Decoder[Collection] = Decoder.instance { c =>
     for {
        info <- c.downField("info").as[io.apibuilder.postman.collection.v21.v0.models.Info]
        item <- c.downField("item").as[Seq[io.apibuilder.postman.collection.v21.v0.models.Items]]
        event <- c.downField("event").as[Seq[io.apibuilder.postman.collection.v21.v0.models.Event]]
        variable <- c.downField("variable").as[Seq[io.apibuilder.postman.collection.v21.v0.models.Variable]]
        auth <- c.downField("auth").as[Option[io.apibuilder.postman.collection.v21.v0.models.Auth]]
      } yield {
        Collection(
          info = info,
          item = item,
          event = event,
          variable = variable,
          auth = auth
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Collection: Encoder[Collection] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("info" -> t.info.asJson),
        Some("item" -> t.item.asJson),
        Some("event" -> t.event.asJson),
        Some("variable" -> t.variable.asJson),
        t.auth.map(t => "auth" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21Description: Decoder[Description] = Decoder.instance { c =>
     for {
        content <- c.downField("content").as[Option[String]]
        __type__ <- c.downField("type").as[Option[String]]
      } yield {
        Description(
          content = content,
          `type` = __type__
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Description: Encoder[Description] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.content.map(t => "content" -> t.asJson),
        t.`type`.map(t => "type" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21Event: Decoder[Event] = Decoder.instance { c =>
     for {
        listen <- c.downField("listen").as[io.apibuilder.postman.collection.v21.v0.models.EventType]
        script <- c.downField("script").as[Option[io.apibuilder.postman.collection.v21.v0.models.Script]]
        id <- c.downField("id").as[Option[String]]
        disabled <- c.downField("disabled").as[Option[Boolean]]
      } yield {
        Event(
          listen = listen,
          script = script,
          id = id,
          disabled = disabled
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Event: Encoder[Event] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("listen" -> t.listen.asJson),
        t.script.map(t => "script" -> t.asJson),
        t.id.map(t => "id" -> t.asJson),
        t.disabled.map(t => "disabled" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21File: Decoder[File] = Decoder.instance { c =>
     for {
        src <- c.downField("src").as[Option[String]]
        content <- c.downField("content").as[Option[String]]
      } yield {
        File(
          src = src,
          content = content
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21File: Encoder[File] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.src.map(t => "src" -> t.asJson),
        t.content.map(t => "content" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21Folder: Decoder[Folder] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        description <- c.downField("description").as[Option[io.apibuilder.postman.collection.v21.v0.models.Description]]
        variable <- c.downField("variable").as[Option[Seq[io.apibuilder.postman.collection.v21.v0.models.Variable]]]
        item <- c.downField("item").as[Seq[io.apibuilder.postman.collection.v21.v0.models.Item]]
        event <- c.downField("event").as[Option[Seq[io.apibuilder.postman.collection.v21.v0.models.Event]]]
        auth <- c.downField("auth").as[Option[io.apibuilder.postman.collection.v21.v0.models.Auth]]
      } yield {
        Folder(
          name = name,
          description = description,
          variable = variable,
          item = item,
          event = event,
          auth = auth
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Folder: Encoder[Folder] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.variable.map(t => "variable" -> t.asJson),
        Some("item" -> t.item.asJson),
        t.event.map(t => "event" -> t.asJson),
        t.auth.map(t => "auth" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21FormParameter: Decoder[FormParameter] = Decoder.instance { c =>
     for {
        key <- c.downField("key").as[String]
        value <- c.downField("value").as[Option[String]]
        disabled <- c.downField("disabled").as[Option[Boolean]]
        description <- c.downField("description").as[Option[io.apibuilder.postman.collection.v21.v0.models.Description]]
        contentType <- c.downField("contentType").as[Option[String]]
        __type__ <- c.downField("type").as[Option[String]]
      } yield {
        FormParameter(
          key = key,
          value = value,
          disabled = disabled,
          description = description,
          contentType = contentType,
          `type` = __type__
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21FormParameter: Encoder[FormParameter] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("key" -> t.key.asJson),
        t.value.map(t => "value" -> t.asJson),
        t.disabled.map(t => "disabled" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.contentType.map(t => "contentType" -> t.asJson),
        t.`type`.map(t => "type" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21Header: Decoder[Header] = Decoder.instance { c =>
     for {
        key <- c.downField("key").as[String]
        value <- c.downField("value").as[String]
        disabled <- c.downField("disabled").as[Option[Boolean]]
        description <- c.downField("description").as[Option[io.apibuilder.postman.collection.v21.v0.models.Description]]
      } yield {
        Header(
          key = key,
          value = value,
          disabled = disabled,
          description = description
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Header: Encoder[Header] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("key" -> t.key.asJson),
        Some("value" -> t.value.asJson),
        t.disabled.map(t => "disabled" -> t.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21Info: Decoder[Info] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        postmanId <- c.downField("postman_id").as[Option[String]]
        description <- c.downField("description").as[Option[io.apibuilder.postman.collection.v21.v0.models.Description]]
        version <- c.downField("version").as[Option[String]]
        schema <- c.downField("schema").as[String]
      } yield {
        Info(
          name = name,
          postmanId = postmanId,
          description = description,
          version = version,
          schema = schema
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Info: Encoder[Info] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        t.postmanId.map(t => "postman_id" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.version.map(t => "version" -> t.asJson),
        Some("schema" -> t.schema.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21Item: Decoder[Item] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[Option[String]]
        name <- c.downField("name").as[Option[String]]
        description <- c.downField("description").as[Option[io.apibuilder.postman.collection.v21.v0.models.Description]]
        variable <- c.downField("variable").as[Option[Seq[io.apibuilder.postman.collection.v21.v0.models.Variable]]]
        event <- c.downField("event").as[Option[Seq[io.apibuilder.postman.collection.v21.v0.models.Event]]]
        request <- c.downField("request").as[io.apibuilder.postman.collection.v21.v0.models.Request]
        response <- c.downField("response").as[Option[Seq[io.apibuilder.postman.collection.v21.v0.models.Response]]]
      } yield {
        Item(
          id = id,
          name = name,
          description = description,
          variable = variable,
          event = event,
          request = request,
          response = response
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Item: Encoder[Item] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.id.map(t => "id" -> t.asJson),
        t.name.map(t => "name" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.variable.map(t => "variable" -> t.asJson),
        t.event.map(t => "event" -> t.asJson),
        Some("request" -> t.request.asJson),
        t.response.map(t => "response" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21QueryParam: Decoder[QueryParam] = Decoder.instance { c =>
     for {
        key <- c.downField("key").as[Option[String]]
        value <- c.downField("value").as[Option[String]]
        disabled <- c.downField("disabled").as[Option[Boolean]]
        description <- c.downField("description").as[Option[io.apibuilder.postman.collection.v21.v0.models.Description]]
      } yield {
        QueryParam(
          key = key,
          value = value,
          disabled = disabled,
          description = description
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21QueryParam: Encoder[QueryParam] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.key.map(t => "key" -> t.asJson),
        t.value.map(t => "value" -> t.asJson),
        t.disabled.map(t => "disabled" -> t.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21Request: Decoder[Request] = Decoder.instance { c =>
     for {
        url <- c.downField("url").as[Option[io.apibuilder.postman.collection.v21.v0.models.Url]]
        auth <- c.downField("auth").as[Option[io.apibuilder.postman.collection.v21.v0.models.Auth]]
        method <- c.downField("method").as[Option[io.apibuilder.postman.collection.v21.v0.models.Method]]
        description <- c.downField("description").as[Option[io.apibuilder.postman.collection.v21.v0.models.Description]]
        header <- c.downField("header").as[Option[Seq[io.apibuilder.postman.collection.v21.v0.models.Header]]]
        body <- c.downField("body").as[Option[io.apibuilder.postman.collection.v21.v0.models.Body]]
      } yield {
        Request(
          url = url,
          auth = auth,
          method = method,
          description = description,
          header = header,
          body = body
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Request: Encoder[Request] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.url.map(t => "url" -> t.asJson),
        t.auth.map(t => "auth" -> t.asJson),
        t.method.map(t => "method" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.header.map(t => "header" -> t.asJson),
        t.body.map(t => "body" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21Response: Decoder[Response] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[Option[String]]
        name <- c.downField("name").as[Option[String]]
        originalRequest <- c.downField("originalRequest").as[Option[io.apibuilder.postman.collection.v21.v0.models.Request]]
        responseTime <- c.downField("responseTime").as[Option[String]]
        header <- c.downField("header").as[Option[Seq[io.apibuilder.postman.collection.v21.v0.models.Header]]]
        body <- c.downField("body").as[Option[String]]
        status <- c.downField("status").as[Option[String]]
        code <- c.downField("code").as[Option[Int]]
      } yield {
        Response(
          id = id,
          name = name,
          originalRequest = originalRequest,
          responseTime = responseTime,
          header = header,
          body = body,
          status = status,
          code = code
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Response: Encoder[Response] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.id.map(t => "id" -> t.asJson),
        t.name.map(t => "name" -> t.asJson),
        t.originalRequest.map(t => "originalRequest" -> t.asJson),
        t.responseTime.map(t => "responseTime" -> t.asJson),
        t.header.map(t => "header" -> t.asJson),
        t.body.map(t => "body" -> t.asJson),
        t.status.map(t => "status" -> t.asJson),
        t.code.map(t => "code" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21Script: Decoder[Script] = Decoder.instance { c =>
     for {
        exec <- c.downField("exec").as[Seq[String]]
        __type__ <- c.downField("type").as[String]
        id <- c.downField("id").as[Option[String]]
        src <- c.downField("src").as[Option[String]]
        name <- c.downField("name").as[Option[String]]
      } yield {
        Script(
          exec = exec,
          `type` = __type__,
          id = id,
          src = src,
          name = name
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Script: Encoder[Script] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("exec" -> t.exec.asJson),
        Some("type" -> t.`type`.asJson),
        t.id.map(t => "id" -> t.asJson),
        t.src.map(t => "src" -> t.asJson),
        t.name.map(t => "name" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21Url: Decoder[Url] = Decoder.instance { c =>
     for {
        raw <- c.downField("raw").as[Option[String]]
        protocol <- c.downField("protocol").as[Option[String]]
        host <- c.downField("host").as[Option[Seq[String]]]
        path <- c.downField("path").as[Option[Seq[String]]]
        port <- c.downField("port").as[Option[String]]
        query <- c.downField("query").as[Option[Seq[io.apibuilder.postman.collection.v21.v0.models.QueryParam]]]
        hash <- c.downField("hash").as[Option[String]]
        variable <- c.downField("variable").as[Option[Seq[io.apibuilder.postman.collection.v21.v0.models.Variable]]]
      } yield {
        Url(
          raw = raw,
          protocol = protocol,
          host = host,
          path = path,
          port = port,
          query = query,
          hash = hash,
          variable = variable
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Url: Encoder[Url] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.raw.map(t => "raw" -> t.asJson),
        t.protocol.map(t => "protocol" -> t.asJson),
        t.host.map(t => "host" -> t.asJson),
        t.path.map(t => "path" -> t.asJson),
        t.port.map(t => "port" -> t.asJson),
        t.query.map(t => "query" -> t.asJson),
        t.hash.map(t => "hash" -> t.asJson),
        t.variable.map(t => "variable" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21UrlEncoded: Decoder[UrlEncoded] = Decoder.instance { c =>
     for {
        key <- c.downField("key").as[String]
        value <- c.downField("value").as[Option[String]]
        disabled <- c.downField("disabled").as[Option[Boolean]]
        description <- c.downField("description").as[Option[io.apibuilder.postman.collection.v21.v0.models.Description]]
      } yield {
        UrlEncoded(
          key = key,
          value = value,
          disabled = disabled,
          description = description
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21UrlEncoded: Encoder[UrlEncoded] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("key" -> t.key.asJson),
        t.value.map(t => "value" -> t.asJson),
        t.disabled.map(t => "disabled" -> t.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21Variable: Decoder[Variable] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[Option[String]]
        key <- c.downField("key").as[Option[String]]
        value <- c.downField("value").as[Option[String]]
        __type__ <- c.downField("type").as[Option[String]]
        name <- c.downField("name").as[Option[String]]
        description <- c.downField("description").as[Option[io.apibuilder.postman.collection.v21.v0.models.Description]]
        system <- c.downField("system").as[Option[Boolean]]
        disabled <- c.downField("disabled").as[Option[Boolean]]
      } yield {
        Variable(
          id = id,
          key = key,
          value = value,
          `type` = __type__,
          name = name,
          description = description,
          system = system,
          disabled = disabled
        )
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Variable: Encoder[Variable] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.id.map(t => "id" -> t.asJson),
        t.key.map(t => "key" -> t.asJson),
        t.value.map(t => "value" -> t.asJson),
        t.`type`.map(t => "type" -> t.asJson),
        t.name.map(t => "name" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        t.system.map(t => "system" -> t.asJson),
        t.disabled.map(t => "disabled" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApiBuilderPostmanCollectionV21Items: Decoder[Items] = Decoder.instance { c =>
      c.get[Option[String]]("type") match {
        case Right(Some(s)) if s == "item" => c.as[io.apibuilder.postman.collection.v21.v0.models.Item]
        case Right(Some(s)) if s == "folder" => c.as[io.apibuilder.postman.collection.v21.v0.models.Folder]
        case Right(Some(s)) => Right(io.apibuilder.postman.collection.v21.v0.models.ItemsUndefinedType(s))
        case _ => Left(DecodingFailure("Union[Items] requires a discriminator named 'type' - this field was not found in the Json", c.history))
      }
    }

    implicit def encodeApiBuilderPostmanCollectionV21Items: Encoder[Items] = Encoder.instance {
      case t: io.apibuilder.postman.collection.v21.v0.models.Item => t.asJson.mapObject(obj => ("type", Json.fromString("item")) +: obj)
      case t: io.apibuilder.postman.collection.v21.v0.models.Folder => t.asJson.mapObject(obj => ("type", Json.fromString("folder")) +: obj)
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }
  }
}