• Home
• io.github.etspaceman
• kinesis4cats-smithy4s-client_3
• 0.0.28
• source code
• SubscribeToShardEventStream.scala

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

scala.com.amazonaws.kinesis.SubscribeToShardEventStream.scala Maven / Gradle / Ivy

package com.amazonaws.kinesis

import smithy4s.Hints
import smithy4s.Schema
import smithy4s.ShapeId
import smithy4s.ShapeTag
import smithy4s.schema.Schema.bijection
import smithy4s.schema.Schema.union

/** 
This is a tagged union for all of the types of events an enhanced fan-out consumer can
  *             receive over HTTP/2 after a call to SubscribeToShard.
  */
sealed trait SubscribeToShardEventStream extends scala.Product with scala.Serializable { self =>
  @inline final def widen: SubscribeToShardEventStream = this
  def $ordinal: Int

  object project {
    def subscribeToShardEvent: Option[SubscribeToShardEvent] = SubscribeToShardEventStream.SubscribeToShardEventCase.alt.project.lift(self).map(_.subscribeToShardEvent)
    def resourceNotFoundException: Option[ResourceNotFoundException] = SubscribeToShardEventStream.ResourceNotFoundExceptionCase.alt.project.lift(self).map(_.resourceNotFoundException)
    def resourceInUseException: Option[ResourceInUseException] = SubscribeToShardEventStream.ResourceInUseExceptionCase.alt.project.lift(self).map(_.resourceInUseException)
    def kMSDisabledException: Option[KMSDisabledException] = SubscribeToShardEventStream.KMSDisabledExceptionCase.alt.project.lift(self).map(_.kMSDisabledException)
    def kMSInvalidStateException: Option[KMSInvalidStateException] = SubscribeToShardEventStream.KMSInvalidStateExceptionCase.alt.project.lift(self).map(_.kMSInvalidStateException)
    def kMSAccessDeniedException: Option[KMSAccessDeniedException] = SubscribeToShardEventStream.KMSAccessDeniedExceptionCase.alt.project.lift(self).map(_.kMSAccessDeniedException)
    def kMSNotFoundException: Option[KMSNotFoundException] = SubscribeToShardEventStream.KMSNotFoundExceptionCase.alt.project.lift(self).map(_.kMSNotFoundException)
    def kMSOptInRequired: Option[KMSOptInRequired] = SubscribeToShardEventStream.KMSOptInRequiredCase.alt.project.lift(self).map(_.kMSOptInRequired)
    def kMSThrottlingException: Option[KMSThrottlingException] = SubscribeToShardEventStream.KMSThrottlingExceptionCase.alt.project.lift(self).map(_.kMSThrottlingException)
    def internalFailureException: Option[InternalFailureException] = SubscribeToShardEventStream.InternalFailureExceptionCase.alt.project.lift(self).map(_.internalFailureException)
  }

  def accept[A](visitor: SubscribeToShardEventStream.Visitor[A]): A = this match {
    case value: SubscribeToShardEventStream.SubscribeToShardEventCase => visitor.subscribeToShardEvent(value.subscribeToShardEvent)
    case value: SubscribeToShardEventStream.ResourceNotFoundExceptionCase => visitor.resourceNotFoundException(value.resourceNotFoundException)
    case value: SubscribeToShardEventStream.ResourceInUseExceptionCase => visitor.resourceInUseException(value.resourceInUseException)
    case value: SubscribeToShardEventStream.KMSDisabledExceptionCase => visitor.kMSDisabledException(value.kMSDisabledException)
    case value: SubscribeToShardEventStream.KMSInvalidStateExceptionCase => visitor.kMSInvalidStateException(value.kMSInvalidStateException)
    case value: SubscribeToShardEventStream.KMSAccessDeniedExceptionCase => visitor.kMSAccessDeniedException(value.kMSAccessDeniedException)
    case value: SubscribeToShardEventStream.KMSNotFoundExceptionCase => visitor.kMSNotFoundException(value.kMSNotFoundException)
    case value: SubscribeToShardEventStream.KMSOptInRequiredCase => visitor.kMSOptInRequired(value.kMSOptInRequired)
    case value: SubscribeToShardEventStream.KMSThrottlingExceptionCase => visitor.kMSThrottlingException(value.kMSThrottlingException)
    case value: SubscribeToShardEventStream.InternalFailureExceptionCase => visitor.internalFailureException(value.internalFailureException)
  }
}
object SubscribeToShardEventStream extends ShapeTag.Companion[SubscribeToShardEventStream] {

  /** 
After you call SubscribeToShard, Kinesis Data Streams sends events
    *             of this type to your consumer. For an example of how to handle these events, see Enhanced Fan-Out
    *                 Using the Kinesis Data Streams API.
    */
  def subscribeToShardEvent(subscribeToShardEvent: SubscribeToShardEvent): SubscribeToShardEventStream = SubscribeToShardEventCase(subscribeToShardEvent)
  def resourceNotFoundException(resourceNotFoundException: ResourceNotFoundException): SubscribeToShardEventStream = ResourceNotFoundExceptionCase(resourceNotFoundException)
  def resourceInUseException(resourceInUseException: ResourceInUseException): SubscribeToShardEventStream = ResourceInUseExceptionCase(resourceInUseException)
  def kMSDisabledException(kMSDisabledException: KMSDisabledException): SubscribeToShardEventStream = KMSDisabledExceptionCase(kMSDisabledException)
  def kMSInvalidStateException(kMSInvalidStateException: KMSInvalidStateException): SubscribeToShardEventStream = KMSInvalidStateExceptionCase(kMSInvalidStateException)
  def kMSAccessDeniedException(kMSAccessDeniedException: KMSAccessDeniedException): SubscribeToShardEventStream = KMSAccessDeniedExceptionCase(kMSAccessDeniedException)
  def kMSNotFoundException(kMSNotFoundException: KMSNotFoundException): SubscribeToShardEventStream = KMSNotFoundExceptionCase(kMSNotFoundException)
  def kMSOptInRequired(kMSOptInRequired: KMSOptInRequired): SubscribeToShardEventStream = KMSOptInRequiredCase(kMSOptInRequired)
  def kMSThrottlingException(kMSThrottlingException: KMSThrottlingException): SubscribeToShardEventStream = KMSThrottlingExceptionCase(kMSThrottlingException)
  /** 
The processing of the request failed because of an unknown error, exception, or
    *             failure.
    */
  def internalFailureException(internalFailureException: InternalFailureException): SubscribeToShardEventStream = InternalFailureExceptionCase(internalFailureException)

  val id: ShapeId = ShapeId("com.amazonaws.kinesis", "SubscribeToShardEventStream")

  val hints: Hints = Hints(
    smithy.api.Documentation("
This is a tagged union for all of the types of events an enhanced fan-out consumer can\n            receive over HTTP/2 after a call to SubscribeToShard.
"),
    smithy.api.Streaming(),
  ).lazily

  /** 
After you call SubscribeToShard, Kinesis Data Streams sends events
    *             of this type to your consumer. For an example of how to handle these events, see Enhanced Fan-Out
    *                 Using the Kinesis Data Streams API.
    */
  final case class SubscribeToShardEventCase(subscribeToShardEvent: SubscribeToShardEvent) extends SubscribeToShardEventStream { final def $ordinal: Int = 0 }
  final case class ResourceNotFoundExceptionCase(resourceNotFoundException: ResourceNotFoundException) extends SubscribeToShardEventStream { final def $ordinal: Int = 1 }
  final case class ResourceInUseExceptionCase(resourceInUseException: ResourceInUseException) extends SubscribeToShardEventStream { final def $ordinal: Int = 2 }
  final case class KMSDisabledExceptionCase(kMSDisabledException: KMSDisabledException) extends SubscribeToShardEventStream { final def $ordinal: Int = 3 }
  final case class KMSInvalidStateExceptionCase(kMSInvalidStateException: KMSInvalidStateException) extends SubscribeToShardEventStream { final def $ordinal: Int = 4 }
  final case class KMSAccessDeniedExceptionCase(kMSAccessDeniedException: KMSAccessDeniedException) extends SubscribeToShardEventStream { final def $ordinal: Int = 5 }
  final case class KMSNotFoundExceptionCase(kMSNotFoundException: KMSNotFoundException) extends SubscribeToShardEventStream { final def $ordinal: Int = 6 }
  final case class KMSOptInRequiredCase(kMSOptInRequired: KMSOptInRequired) extends SubscribeToShardEventStream { final def $ordinal: Int = 7 }
  final case class KMSThrottlingExceptionCase(kMSThrottlingException: KMSThrottlingException) extends SubscribeToShardEventStream { final def $ordinal: Int = 8 }
  /** 
The processing of the request failed because of an unknown error, exception, or
    *             failure.
    */
  final case class InternalFailureExceptionCase(internalFailureException: InternalFailureException) extends SubscribeToShardEventStream { final def $ordinal: Int = 9 }

  object SubscribeToShardEventCase {
    val hints: Hints = Hints(
      smithy.api.Documentation("
After you call SubscribeToShard, Kinesis Data Streams sends events\n            of this type to your consumer. For an example of how to handle these events, see Enhanced Fan-Out\n                Using the Kinesis Data Streams API.
"),
    ).lazily
    val schema: Schema[SubscribeToShardEventStream.SubscribeToShardEventCase] = bijection(SubscribeToShardEvent.schema.addHints(hints), SubscribeToShardEventStream.SubscribeToShardEventCase(_), _.subscribeToShardEvent)
    val alt = schema.oneOf[SubscribeToShardEventStream]("SubscribeToShardEvent")
  }
  object ResourceNotFoundExceptionCase {
    val hints: Hints = Hints.empty
    val schema: Schema[SubscribeToShardEventStream.ResourceNotFoundExceptionCase] = bijection(ResourceNotFoundException.schema.addHints(hints), SubscribeToShardEventStream.ResourceNotFoundExceptionCase(_), _.resourceNotFoundException)
    val alt = schema.oneOf[SubscribeToShardEventStream]("ResourceNotFoundException")
  }
  object ResourceInUseExceptionCase {
    val hints: Hints = Hints.empty
    val schema: Schema[SubscribeToShardEventStream.ResourceInUseExceptionCase] = bijection(ResourceInUseException.schema.addHints(hints), SubscribeToShardEventStream.ResourceInUseExceptionCase(_), _.resourceInUseException)
    val alt = schema.oneOf[SubscribeToShardEventStream]("ResourceInUseException")
  }
  object KMSDisabledExceptionCase {
    val hints: Hints = Hints.empty
    val schema: Schema[SubscribeToShardEventStream.KMSDisabledExceptionCase] = bijection(KMSDisabledException.schema.addHints(hints), SubscribeToShardEventStream.KMSDisabledExceptionCase(_), _.kMSDisabledException)
    val alt = schema.oneOf[SubscribeToShardEventStream]("KMSDisabledException")
  }
  object KMSInvalidStateExceptionCase {
    val hints: Hints = Hints.empty
    val schema: Schema[SubscribeToShardEventStream.KMSInvalidStateExceptionCase] = bijection(KMSInvalidStateException.schema.addHints(hints), SubscribeToShardEventStream.KMSInvalidStateExceptionCase(_), _.kMSInvalidStateException)
    val alt = schema.oneOf[SubscribeToShardEventStream]("KMSInvalidStateException")
  }
  object KMSAccessDeniedExceptionCase {
    val hints: Hints = Hints.empty
    val schema: Schema[SubscribeToShardEventStream.KMSAccessDeniedExceptionCase] = bijection(KMSAccessDeniedException.schema.addHints(hints), SubscribeToShardEventStream.KMSAccessDeniedExceptionCase(_), _.kMSAccessDeniedException)
    val alt = schema.oneOf[SubscribeToShardEventStream]("KMSAccessDeniedException")
  }
  object KMSNotFoundExceptionCase {
    val hints: Hints = Hints.empty
    val schema: Schema[SubscribeToShardEventStream.KMSNotFoundExceptionCase] = bijection(KMSNotFoundException.schema.addHints(hints), SubscribeToShardEventStream.KMSNotFoundExceptionCase(_), _.kMSNotFoundException)
    val alt = schema.oneOf[SubscribeToShardEventStream]("KMSNotFoundException")
  }
  object KMSOptInRequiredCase {
    val hints: Hints = Hints.empty
    val schema: Schema[SubscribeToShardEventStream.KMSOptInRequiredCase] = bijection(KMSOptInRequired.schema.addHints(hints), SubscribeToShardEventStream.KMSOptInRequiredCase(_), _.kMSOptInRequired)
    val alt = schema.oneOf[SubscribeToShardEventStream]("KMSOptInRequired")
  }
  object KMSThrottlingExceptionCase {
    val hints: Hints = Hints.empty
    val schema: Schema[SubscribeToShardEventStream.KMSThrottlingExceptionCase] = bijection(KMSThrottlingException.schema.addHints(hints), SubscribeToShardEventStream.KMSThrottlingExceptionCase(_), _.kMSThrottlingException)
    val alt = schema.oneOf[SubscribeToShardEventStream]("KMSThrottlingException")
  }
  object InternalFailureExceptionCase {
    val hints: Hints = Hints(
      smithy.api.Documentation("
The processing of the request failed because of an unknown error, exception, or\n            failure.
"),
    ).lazily
    val schema: Schema[SubscribeToShardEventStream.InternalFailureExceptionCase] = bijection(InternalFailureException.schema.addHints(hints), SubscribeToShardEventStream.InternalFailureExceptionCase(_), _.internalFailureException)
    val alt = schema.oneOf[SubscribeToShardEventStream]("InternalFailureException")
  }

  trait Visitor[A] {
    def subscribeToShardEvent(value: SubscribeToShardEvent): A
    def resourceNotFoundException(value: ResourceNotFoundException): A
    def resourceInUseException(value: ResourceInUseException): A
    def kMSDisabledException(value: KMSDisabledException): A
    def kMSInvalidStateException(value: KMSInvalidStateException): A
    def kMSAccessDeniedException(value: KMSAccessDeniedException): A
    def kMSNotFoundException(value: KMSNotFoundException): A
    def kMSOptInRequired(value: KMSOptInRequired): A
    def kMSThrottlingException(value: KMSThrottlingException): A
    def internalFailureException(value: InternalFailureException): A
  }

  object Visitor {
    trait Default[A] extends Visitor[A] {
      def default: A
      def subscribeToShardEvent(value: SubscribeToShardEvent): A = default
      def resourceNotFoundException(value: ResourceNotFoundException): A = default
      def resourceInUseException(value: ResourceInUseException): A = default
      def kMSDisabledException(value: KMSDisabledException): A = default
      def kMSInvalidStateException(value: KMSInvalidStateException): A = default
      def kMSAccessDeniedException(value: KMSAccessDeniedException): A = default
      def kMSNotFoundException(value: KMSNotFoundException): A = default
      def kMSOptInRequired(value: KMSOptInRequired): A = default
      def kMSThrottlingException(value: KMSThrottlingException): A = default
      def internalFailureException(value: InternalFailureException): A = default
    }
  }

  implicit val schema: Schema[SubscribeToShardEventStream] = union(
    SubscribeToShardEventStream.SubscribeToShardEventCase.alt,
    SubscribeToShardEventStream.ResourceNotFoundExceptionCase.alt,
    SubscribeToShardEventStream.ResourceInUseExceptionCase.alt,
    SubscribeToShardEventStream.KMSDisabledExceptionCase.alt,
    SubscribeToShardEventStream.KMSInvalidStateExceptionCase.alt,
    SubscribeToShardEventStream.KMSAccessDeniedExceptionCase.alt,
    SubscribeToShardEventStream.KMSNotFoundExceptionCase.alt,
    SubscribeToShardEventStream.KMSOptInRequiredCase.alt,
    SubscribeToShardEventStream.KMSThrottlingExceptionCase.alt,
    SubscribeToShardEventStream.InternalFailureExceptionCase.alt,
  ){
    _.$ordinal
  }.withId(id).addHints(hints)
}