zio-aws-sqs generated source

model.scala

package io.github.vigoo.zioaws.sqs
import scala.jdk.CollectionConverters._
import java.time.Instant
import zio.{ Chunk, ZIO }
import software.amazon.awssdk.core.SdkBytes
package object model {
  object primitives {
    type Binary = Chunk[Byte]
    type BoxedInteger = Int
    type MessageAttributeName = String
    type TagKey = String
    type TagValue = String
    type Token = String
  }
  type AWSAccountIdList = List[String]
  type ActionNameList = List[String]
  case class AddPermissionRequest(queueUrl: String, label: String, awsAccountIds: Iterable[String], actions: Iterable[String]) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.AddPermissionRequest = {
      import AddPermissionRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.AddPermissionRequest.builder().queueUrl(queueUrl: java.lang.String).label(label: java.lang.String).awsAccountIds(awsAccountIds.map { item => 
        item: java.lang.String
      }.asJavaCollection).actions(actions.map { item => 
        item: java.lang.String
      }.asJavaCollection).build()
    }
  }
  object AddPermissionRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.AddPermissionRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: AddPermissionRequest = AddPermissionRequest(queueUrlValue, labelValue, awsAccountIdsValue, actionsValue)
      def queueUrlValue: String
      def labelValue: String
      def awsAccountIdsValue: List[String]
      def actionsValue: List[String]
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
      def label: ZIO[Any, Nothing, String] = ZIO.succeed(labelValue)
      def awsAccountIds: ZIO[Any, Nothing, List[String]] = ZIO.succeed(awsAccountIdsValue)
      def actions: ZIO[Any, Nothing, List[String]] = ZIO.succeed(actionsValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.AddPermissionRequest) extends AddPermissionRequest.ReadOnly {
      override def queueUrlValue: String = impl.queueUrl(): String
      override def labelValue: String = impl.label(): String
      override def awsAccountIdsValue: List[String] = impl.awsAccountIds().asScala.map { item => 
        item: String
      }.toList
      override def actionsValue: List[String] = impl.actions().asScala.map { item => 
        item: String
      }.toList
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.AddPermissionRequest): ReadOnly = new Wrapper(impl)
  }
  type AttributeNameList = List[QueueAttributeName]
  case class BatchResultErrorEntry(id: String, senderFault: Boolean, code: String, message: scala.Option[String] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.BatchResultErrorEntry = {
      import BatchResultErrorEntry.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.BatchResultErrorEntry.builder().id(id: java.lang.String).senderFault(senderFault: java.lang.Boolean).code(code: java.lang.String).optionallyWith(message.map(value => value: java.lang.String))(_.message).build()
    }
  }
  object BatchResultErrorEntry {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.BatchResultErrorEntry] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: BatchResultErrorEntry = BatchResultErrorEntry(idValue, senderFaultValue, codeValue, messageValue.map(value => value))
      def idValue: String
      def senderFaultValue: Boolean
      def codeValue: String
      def messageValue: scala.Option[String]
      def id: ZIO[Any, Nothing, String] = ZIO.succeed(idValue)
      def senderFault: ZIO[Any, Nothing, Boolean] = ZIO.succeed(senderFaultValue)
      def code: ZIO[Any, Nothing, String] = ZIO.succeed(codeValue)
      def message: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("message", messageValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.BatchResultErrorEntry) extends BatchResultErrorEntry.ReadOnly {
      override def idValue: String = impl.id(): String
      override def senderFaultValue: Boolean = impl.senderFault(): Boolean
      override def codeValue: String = impl.code(): String
      override def messageValue: scala.Option[String] = scala.Option(impl.message()).map(value => value: String)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.BatchResultErrorEntry): ReadOnly = new Wrapper(impl)
  }
  type BatchResultErrorEntryList = List[BatchResultErrorEntry]
  type BinaryList = List[primitives.Binary]
  case class ChangeMessageVisibilityBatchRequest(queueUrl: String, entries: Iterable[ChangeMessageVisibilityBatchRequestEntry]) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchRequest = {
      import ChangeMessageVisibilityBatchRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchRequest.builder().queueUrl(queueUrl: java.lang.String).entries(entries.map { item => 
        item.buildAwsValue()
      }.asJavaCollection).build()
    }
  }
  object ChangeMessageVisibilityBatchRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: ChangeMessageVisibilityBatchRequest = ChangeMessageVisibilityBatchRequest(queueUrlValue, entriesValue.map { item => 
        item.editable
      })
      def queueUrlValue: String
      def entriesValue: List[ChangeMessageVisibilityBatchRequestEntry.ReadOnly]
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
      def entries: ZIO[Any, Nothing, List[ChangeMessageVisibilityBatchRequestEntry.ReadOnly]] = ZIO.succeed(entriesValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchRequest) extends ChangeMessageVisibilityBatchRequest.ReadOnly {
      override def queueUrlValue: String = impl.queueUrl(): String
      override def entriesValue: List[ChangeMessageVisibilityBatchRequestEntry.ReadOnly] = impl.entries().asScala.map { item => 
        ChangeMessageVisibilityBatchRequestEntry.wrap(item)
      }.toList
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchRequest): ReadOnly = new Wrapper(impl)
  }
  case class ChangeMessageVisibilityBatchRequestEntry(id: String, receiptHandle: String, visibilityTimeout: scala.Option[Integer] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchRequestEntry = {
      import ChangeMessageVisibilityBatchRequestEntry.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchRequestEntry.builder().id(id: java.lang.String).receiptHandle(receiptHandle: java.lang.String).optionallyWith(visibilityTimeout.map(value => value: java.lang.Integer))(_.visibilityTimeout).build()
    }
  }
  object ChangeMessageVisibilityBatchRequestEntry {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchRequestEntry] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: ChangeMessageVisibilityBatchRequestEntry = ChangeMessageVisibilityBatchRequestEntry(idValue, receiptHandleValue, visibilityTimeoutValue.map(value => value))
      def idValue: String
      def receiptHandleValue: String
      def visibilityTimeoutValue: scala.Option[Integer]
      def id: ZIO[Any, Nothing, String] = ZIO.succeed(idValue)
      def receiptHandle: ZIO[Any, Nothing, String] = ZIO.succeed(receiptHandleValue)
      def visibilityTimeout: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Integer] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("visibilityTimeout", visibilityTimeoutValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchRequestEntry) extends ChangeMessageVisibilityBatchRequestEntry.ReadOnly {
      override def idValue: String = impl.id(): String
      override def receiptHandleValue: String = impl.receiptHandle(): String
      override def visibilityTimeoutValue: scala.Option[Integer] = scala.Option(impl.visibilityTimeout()).map(value => value: Integer)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchRequestEntry): ReadOnly = new Wrapper(impl)
  }
  type ChangeMessageVisibilityBatchRequestEntryList = List[ChangeMessageVisibilityBatchRequestEntry]
  case class ChangeMessageVisibilityBatchResponse(successful: Iterable[ChangeMessageVisibilityBatchResultEntry], failed: Iterable[BatchResultErrorEntry]) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchResponse = {
      import ChangeMessageVisibilityBatchResponse.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchResponse.builder().successful(successful.map { item => 
        item.buildAwsValue()
      }.asJavaCollection).failed(failed.map { item => 
        item.buildAwsValue()
      }.asJavaCollection).build()
    }
  }
  object ChangeMessageVisibilityBatchResponse {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchResponse] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: ChangeMessageVisibilityBatchResponse = ChangeMessageVisibilityBatchResponse(successfulValue.map { item => 
        item.editable
      }, failedValue.map { item => 
        item.editable
      })
      def successfulValue: List[ChangeMessageVisibilityBatchResultEntry.ReadOnly]
      def failedValue: List[BatchResultErrorEntry.ReadOnly]
      def successful: ZIO[Any, Nothing, List[ChangeMessageVisibilityBatchResultEntry.ReadOnly]] = ZIO.succeed(successfulValue)
      def failed: ZIO[Any, Nothing, List[BatchResultErrorEntry.ReadOnly]] = ZIO.succeed(failedValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchResponse) extends ChangeMessageVisibilityBatchResponse.ReadOnly {
      override def successfulValue: List[ChangeMessageVisibilityBatchResultEntry.ReadOnly] = impl.successful().asScala.map { item => 
        ChangeMessageVisibilityBatchResultEntry.wrap(item)
      }.toList
      override def failedValue: List[BatchResultErrorEntry.ReadOnly] = impl.failed().asScala.map { item => 
        BatchResultErrorEntry.wrap(item)
      }.toList
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchResponse): ReadOnly = new Wrapper(impl)
  }
  case class ChangeMessageVisibilityBatchResultEntry(id: String) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchResultEntry = {
      import ChangeMessageVisibilityBatchResultEntry.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchResultEntry.builder().id(id: java.lang.String).build()
    }
  }
  object ChangeMessageVisibilityBatchResultEntry {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchResultEntry] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: ChangeMessageVisibilityBatchResultEntry = ChangeMessageVisibilityBatchResultEntry(idValue)
      def idValue: String
      def id: ZIO[Any, Nothing, String] = ZIO.succeed(idValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchResultEntry) extends ChangeMessageVisibilityBatchResultEntry.ReadOnly { override def idValue: String = impl.id(): String }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchResultEntry): ReadOnly = new Wrapper(impl)
  }
  type ChangeMessageVisibilityBatchResultEntryList = List[ChangeMessageVisibilityBatchResultEntry]
  case class ChangeMessageVisibilityRequest(queueUrl: String, receiptHandle: String, visibilityTimeout: Integer) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityRequest = {
      import ChangeMessageVisibilityRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityRequest.builder().queueUrl(queueUrl: java.lang.String).receiptHandle(receiptHandle: java.lang.String).visibilityTimeout(visibilityTimeout: java.lang.Integer).build()
    }
  }
  object ChangeMessageVisibilityRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: ChangeMessageVisibilityRequest = ChangeMessageVisibilityRequest(queueUrlValue, receiptHandleValue, visibilityTimeoutValue)
      def queueUrlValue: String
      def receiptHandleValue: String
      def visibilityTimeoutValue: Integer
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
      def receiptHandle: ZIO[Any, Nothing, String] = ZIO.succeed(receiptHandleValue)
      def visibilityTimeout: ZIO[Any, Nothing, Integer] = ZIO.succeed(visibilityTimeoutValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityRequest) extends ChangeMessageVisibilityRequest.ReadOnly {
      override def queueUrlValue: String = impl.queueUrl(): String
      override def receiptHandleValue: String = impl.receiptHandle(): String
      override def visibilityTimeoutValue: Integer = impl.visibilityTimeout(): Integer
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityRequest): ReadOnly = new Wrapper(impl)
  }
  case class CreateQueueRequest(queueName: String, attributes: scala.Option[Map[QueueAttributeName, String]] = None, tags: scala.Option[Map[primitives.TagKey, primitives.TagValue]] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.CreateQueueRequest = {
      import CreateQueueRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.CreateQueueRequest.builder().queueName(queueName: java.lang.String).optionallyWith(attributes.map(value => value.map({
        case (key, value) =>
          key.unwrap.toString -> (value: java.lang.String)
      }).asJava))(_.attributesWithStrings).optionallyWith(tags.map(value => value.map({
        case (key, value) =>
          (key: java.lang.String) -> (value: java.lang.String)
      }).asJava))(_.tags).build()
    }
  }
  object CreateQueueRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.CreateQueueRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: CreateQueueRequest = CreateQueueRequest(queueNameValue, attributesValue.map(value => value), tagsValue.map(value => value))
      def queueNameValue: String
      def attributesValue: scala.Option[Map[QueueAttributeName, String]]
      def tagsValue: scala.Option[Map[primitives.TagKey, primitives.TagValue]]
      def queueName: ZIO[Any, Nothing, String] = ZIO.succeed(queueNameValue)
      def attributes: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Map[QueueAttributeName, String]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("attributes", attributesValue)
      def tags: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Map[primitives.TagKey, primitives.TagValue]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("tags", tagsValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.CreateQueueRequest) extends CreateQueueRequest.ReadOnly {
      override def queueNameValue: String = impl.queueName(): String
      override def attributesValue: scala.Option[Map[QueueAttributeName, String]] = scala.Option(impl.attributes()).map(value => value.asScala.map({
        case (key, value) =>
          QueueAttributeName.wrap(key) -> (value: String)
      }).toMap)
      override def tagsValue: scala.Option[Map[primitives.TagKey, primitives.TagValue]] = scala.Option(impl.tags()).map(value => value.asScala.map({
        case (key, value) =>
          (key: primitives.TagKey) -> (value: primitives.TagValue)
      }).toMap)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.CreateQueueRequest): ReadOnly = new Wrapper(impl)
  }
  case class CreateQueueResponse(queueUrl: scala.Option[String] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.CreateQueueResponse = {
      import CreateQueueResponse.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.CreateQueueResponse.builder().optionallyWith(queueUrl.map(value => value: java.lang.String))(_.queueUrl).build()
    }
  }
  object CreateQueueResponse {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.CreateQueueResponse] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: CreateQueueResponse = CreateQueueResponse(queueUrlValue.map(value => value))
      def queueUrlValue: scala.Option[String]
      def queueUrl: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("queueUrl", queueUrlValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.CreateQueueResponse) extends CreateQueueResponse.ReadOnly { override def queueUrlValue: scala.Option[String] = scala.Option(impl.queueUrl()).map(value => value: String) }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.CreateQueueResponse): ReadOnly = new Wrapper(impl)
  }
  case class DeleteMessageBatchRequest(queueUrl: String, entries: Iterable[DeleteMessageBatchRequestEntry]) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.DeleteMessageBatchRequest = {
      import DeleteMessageBatchRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.DeleteMessageBatchRequest.builder().queueUrl(queueUrl: java.lang.String).entries(entries.map { item => 
        item.buildAwsValue()
      }.asJavaCollection).build()
    }
  }
  object DeleteMessageBatchRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.DeleteMessageBatchRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: DeleteMessageBatchRequest = DeleteMessageBatchRequest(queueUrlValue, entriesValue.map { item => 
        item.editable
      })
      def queueUrlValue: String
      def entriesValue: List[DeleteMessageBatchRequestEntry.ReadOnly]
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
      def entries: ZIO[Any, Nothing, List[DeleteMessageBatchRequestEntry.ReadOnly]] = ZIO.succeed(entriesValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.DeleteMessageBatchRequest) extends DeleteMessageBatchRequest.ReadOnly {
      override def queueUrlValue: String = impl.queueUrl(): String
      override def entriesValue: List[DeleteMessageBatchRequestEntry.ReadOnly] = impl.entries().asScala.map { item => 
        DeleteMessageBatchRequestEntry.wrap(item)
      }.toList
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.DeleteMessageBatchRequest): ReadOnly = new Wrapper(impl)
  }
  case class DeleteMessageBatchRequestEntry(id: String, receiptHandle: String) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.DeleteMessageBatchRequestEntry = {
      import DeleteMessageBatchRequestEntry.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.DeleteMessageBatchRequestEntry.builder().id(id: java.lang.String).receiptHandle(receiptHandle: java.lang.String).build()
    }
  }
  object DeleteMessageBatchRequestEntry {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.DeleteMessageBatchRequestEntry] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: DeleteMessageBatchRequestEntry = DeleteMessageBatchRequestEntry(idValue, receiptHandleValue)
      def idValue: String
      def receiptHandleValue: String
      def id: ZIO[Any, Nothing, String] = ZIO.succeed(idValue)
      def receiptHandle: ZIO[Any, Nothing, String] = ZIO.succeed(receiptHandleValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.DeleteMessageBatchRequestEntry) extends DeleteMessageBatchRequestEntry.ReadOnly {
      override def idValue: String = impl.id(): String
      override def receiptHandleValue: String = impl.receiptHandle(): String
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.DeleteMessageBatchRequestEntry): ReadOnly = new Wrapper(impl)
  }
  type DeleteMessageBatchRequestEntryList = List[DeleteMessageBatchRequestEntry]
  case class DeleteMessageBatchResponse(successful: Iterable[DeleteMessageBatchResultEntry], failed: Iterable[BatchResultErrorEntry]) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.DeleteMessageBatchResponse = {
      import DeleteMessageBatchResponse.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.DeleteMessageBatchResponse.builder().successful(successful.map { item => 
        item.buildAwsValue()
      }.asJavaCollection).failed(failed.map { item => 
        item.buildAwsValue()
      }.asJavaCollection).build()
    }
  }
  object DeleteMessageBatchResponse {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.DeleteMessageBatchResponse] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: DeleteMessageBatchResponse = DeleteMessageBatchResponse(successfulValue.map { item => 
        item.editable
      }, failedValue.map { item => 
        item.editable
      })
      def successfulValue: List[DeleteMessageBatchResultEntry.ReadOnly]
      def failedValue: List[BatchResultErrorEntry.ReadOnly]
      def successful: ZIO[Any, Nothing, List[DeleteMessageBatchResultEntry.ReadOnly]] = ZIO.succeed(successfulValue)
      def failed: ZIO[Any, Nothing, List[BatchResultErrorEntry.ReadOnly]] = ZIO.succeed(failedValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.DeleteMessageBatchResponse) extends DeleteMessageBatchResponse.ReadOnly {
      override def successfulValue: List[DeleteMessageBatchResultEntry.ReadOnly] = impl.successful().asScala.map { item => 
        DeleteMessageBatchResultEntry.wrap(item)
      }.toList
      override def failedValue: List[BatchResultErrorEntry.ReadOnly] = impl.failed().asScala.map { item => 
        BatchResultErrorEntry.wrap(item)
      }.toList
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.DeleteMessageBatchResponse): ReadOnly = new Wrapper(impl)
  }
  case class DeleteMessageBatchResultEntry(id: String) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.DeleteMessageBatchResultEntry = {
      import DeleteMessageBatchResultEntry.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.DeleteMessageBatchResultEntry.builder().id(id: java.lang.String).build()
    }
  }
  object DeleteMessageBatchResultEntry {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.DeleteMessageBatchResultEntry] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: DeleteMessageBatchResultEntry = DeleteMessageBatchResultEntry(idValue)
      def idValue: String
      def id: ZIO[Any, Nothing, String] = ZIO.succeed(idValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.DeleteMessageBatchResultEntry) extends DeleteMessageBatchResultEntry.ReadOnly { override def idValue: String = impl.id(): String }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.DeleteMessageBatchResultEntry): ReadOnly = new Wrapper(impl)
  }
  type DeleteMessageBatchResultEntryList = List[DeleteMessageBatchResultEntry]
  case class DeleteMessageRequest(queueUrl: String, receiptHandle: String) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.DeleteMessageRequest = {
      import DeleteMessageRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.DeleteMessageRequest.builder().queueUrl(queueUrl: java.lang.String).receiptHandle(receiptHandle: java.lang.String).build()
    }
  }
  object DeleteMessageRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.DeleteMessageRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: DeleteMessageRequest = DeleteMessageRequest(queueUrlValue, receiptHandleValue)
      def queueUrlValue: String
      def receiptHandleValue: String
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
      def receiptHandle: ZIO[Any, Nothing, String] = ZIO.succeed(receiptHandleValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.DeleteMessageRequest) extends DeleteMessageRequest.ReadOnly {
      override def queueUrlValue: String = impl.queueUrl(): String
      override def receiptHandleValue: String = impl.receiptHandle(): String
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.DeleteMessageRequest): ReadOnly = new Wrapper(impl)
  }
  case class DeleteQueueRequest(queueUrl: String) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.DeleteQueueRequest = {
      import DeleteQueueRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.DeleteQueueRequest.builder().queueUrl(queueUrl: java.lang.String).build()
    }
  }
  object DeleteQueueRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.DeleteQueueRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: DeleteQueueRequest = DeleteQueueRequest(queueUrlValue)
      def queueUrlValue: String
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.DeleteQueueRequest) extends DeleteQueueRequest.ReadOnly { override def queueUrlValue: String = impl.queueUrl(): String }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.DeleteQueueRequest): ReadOnly = new Wrapper(impl)
  }
  case class GetQueueAttributesRequest(queueUrl: String, attributeNames: scala.Option[Iterable[QueueAttributeName]] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.GetQueueAttributesRequest = {
      import GetQueueAttributesRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.GetQueueAttributesRequest.builder().queueUrl(queueUrl: java.lang.String).optionallyWith(attributeNames.map(value => value.map { item => 
        item.unwrap.toString
      }.asJavaCollection))(_.attributeNamesWithStrings).build()
    }
  }
  object GetQueueAttributesRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.GetQueueAttributesRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: GetQueueAttributesRequest = GetQueueAttributesRequest(queueUrlValue, attributeNamesValue.map(value => value))
      def queueUrlValue: String
      def attributeNamesValue: scala.Option[List[QueueAttributeName]]
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
      def attributeNames: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, List[QueueAttributeName]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("attributeNames", attributeNamesValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.GetQueueAttributesRequest) extends GetQueueAttributesRequest.ReadOnly {
      override def queueUrlValue: String = impl.queueUrl(): String
      override def attributeNamesValue: scala.Option[List[QueueAttributeName]] = scala.Option(impl.attributeNames()).map(value => value.asScala.map { item => 
        QueueAttributeName.wrap(item)
      }.toList)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.GetQueueAttributesRequest): ReadOnly = new Wrapper(impl)
  }
  case class GetQueueAttributesResponse(attributes: scala.Option[Map[QueueAttributeName, String]] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.GetQueueAttributesResponse = {
      import GetQueueAttributesResponse.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.GetQueueAttributesResponse.builder().optionallyWith(attributes.map(value => value.map({
        case (key, value) =>
          key.unwrap.toString -> (value: java.lang.String)
      }).asJava))(_.attributesWithStrings).build()
    }
  }
  object GetQueueAttributesResponse {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.GetQueueAttributesResponse] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: GetQueueAttributesResponse = GetQueueAttributesResponse(attributesValue.map(value => value))
      def attributesValue: scala.Option[Map[QueueAttributeName, String]]
      def attributes: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Map[QueueAttributeName, String]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("attributes", attributesValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.GetQueueAttributesResponse) extends GetQueueAttributesResponse.ReadOnly {
      override def attributesValue: scala.Option[Map[QueueAttributeName, String]] = scala.Option(impl.attributes()).map(value => value.asScala.map({
        case (key, value) =>
          QueueAttributeName.wrap(key) -> (value: String)
      }).toMap)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.GetQueueAttributesResponse): ReadOnly = new Wrapper(impl)
  }
  case class GetQueueUrlRequest(queueName: String, queueOwnerAWSAccountId: scala.Option[String] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest = {
      import GetQueueUrlRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest.builder().queueName(queueName: java.lang.String).optionallyWith(queueOwnerAWSAccountId.map(value => value: java.lang.String))(_.queueOwnerAWSAccountId).build()
    }
  }
  object GetQueueUrlRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: GetQueueUrlRequest = GetQueueUrlRequest(queueNameValue, queueOwnerAWSAccountIdValue.map(value => value))
      def queueNameValue: String
      def queueOwnerAWSAccountIdValue: scala.Option[String]
      def queueName: ZIO[Any, Nothing, String] = ZIO.succeed(queueNameValue)
      def queueOwnerAWSAccountId: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("queueOwnerAWSAccountId", queueOwnerAWSAccountIdValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest) extends GetQueueUrlRequest.ReadOnly {
      override def queueNameValue: String = impl.queueName(): String
      override def queueOwnerAWSAccountIdValue: scala.Option[String] = scala.Option(impl.queueOwnerAWSAccountId()).map(value => value: String)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest): ReadOnly = new Wrapper(impl)
  }
  case class GetQueueUrlResponse(queueUrl: scala.Option[String] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse = {
      import GetQueueUrlResponse.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse.builder().optionallyWith(queueUrl.map(value => value: java.lang.String))(_.queueUrl).build()
    }
  }
  object GetQueueUrlResponse {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: GetQueueUrlResponse = GetQueueUrlResponse(queueUrlValue.map(value => value))
      def queueUrlValue: scala.Option[String]
      def queueUrl: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("queueUrl", queueUrlValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse) extends GetQueueUrlResponse.ReadOnly { override def queueUrlValue: scala.Option[String] = scala.Option(impl.queueUrl()).map(value => value: String) }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse): ReadOnly = new Wrapper(impl)
  }
  case class ListDeadLetterSourceQueuesRequest(queueUrl: String, nextToken: scala.Option[primitives.Token] = None, maxResults: scala.Option[primitives.BoxedInteger] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.ListDeadLetterSourceQueuesRequest = {
      import ListDeadLetterSourceQueuesRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.ListDeadLetterSourceQueuesRequest.builder().queueUrl(queueUrl: java.lang.String).optionallyWith(nextToken.map(value => value: java.lang.String))(_.nextToken).optionallyWith(maxResults.map(value => value: java.lang.Integer))(_.maxResults).build()
    }
  }
  object ListDeadLetterSourceQueuesRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.ListDeadLetterSourceQueuesRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: ListDeadLetterSourceQueuesRequest = ListDeadLetterSourceQueuesRequest(queueUrlValue, nextTokenValue.map(value => value), maxResultsValue.map(value => value))
      def queueUrlValue: String
      def nextTokenValue: scala.Option[primitives.Token]
      def maxResultsValue: scala.Option[primitives.BoxedInteger]
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
      def nextToken: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, primitives.Token] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("nextToken", nextTokenValue)
      def maxResults: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, primitives.BoxedInteger] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("maxResults", maxResultsValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.ListDeadLetterSourceQueuesRequest) extends ListDeadLetterSourceQueuesRequest.ReadOnly {
      override def queueUrlValue: String = impl.queueUrl(): String
      override def nextTokenValue: scala.Option[primitives.Token] = scala.Option(impl.nextToken()).map(value => value: primitives.Token)
      override def maxResultsValue: scala.Option[primitives.BoxedInteger] = scala.Option(impl.maxResults()).map(value => value: primitives.BoxedInteger)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.ListDeadLetterSourceQueuesRequest): ReadOnly = new Wrapper(impl)
  }
  case class ListDeadLetterSourceQueuesResponse(queueUrls: Iterable[String], nextToken: scala.Option[primitives.Token] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.ListDeadLetterSourceQueuesResponse = {
      import ListDeadLetterSourceQueuesResponse.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.ListDeadLetterSourceQueuesResponse.builder().queueUrls(queueUrls.map { item => 
        item: java.lang.String
      }.asJavaCollection).optionallyWith(nextToken.map(value => value: java.lang.String))(_.nextToken).build()
    }
  }
  object ListDeadLetterSourceQueuesResponse {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.ListDeadLetterSourceQueuesResponse] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: ListDeadLetterSourceQueuesResponse = ListDeadLetterSourceQueuesResponse(queueUrlsValue, nextTokenValue.map(value => value))
      def queueUrlsValue: List[String]
      def nextTokenValue: scala.Option[primitives.Token]
      def queueUrls: ZIO[Any, Nothing, List[String]] = ZIO.succeed(queueUrlsValue)
      def nextToken: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, primitives.Token] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("nextToken", nextTokenValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.ListDeadLetterSourceQueuesResponse) extends ListDeadLetterSourceQueuesResponse.ReadOnly {
      override def queueUrlsValue: List[String] = impl.queueUrls().asScala.map { item => 
        item: String
      }.toList
      override def nextTokenValue: scala.Option[primitives.Token] = scala.Option(impl.nextToken()).map(value => value: primitives.Token)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.ListDeadLetterSourceQueuesResponse): ReadOnly = new Wrapper(impl)
  }
  case class ListQueueTagsRequest(queueUrl: String) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.ListQueueTagsRequest = {
      import ListQueueTagsRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.ListQueueTagsRequest.builder().queueUrl(queueUrl: java.lang.String).build()
    }
  }
  object ListQueueTagsRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.ListQueueTagsRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: ListQueueTagsRequest = ListQueueTagsRequest(queueUrlValue)
      def queueUrlValue: String
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.ListQueueTagsRequest) extends ListQueueTagsRequest.ReadOnly { override def queueUrlValue: String = impl.queueUrl(): String }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.ListQueueTagsRequest): ReadOnly = new Wrapper(impl)
  }
  case class ListQueueTagsResponse(tags: scala.Option[Map[primitives.TagKey, primitives.TagValue]] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.ListQueueTagsResponse = {
      import ListQueueTagsResponse.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.ListQueueTagsResponse.builder().optionallyWith(tags.map(value => value.map({
        case (key, value) =>
          (key: java.lang.String) -> (value: java.lang.String)
      }).asJava))(_.tags).build()
    }
  }
  object ListQueueTagsResponse {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.ListQueueTagsResponse] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: ListQueueTagsResponse = ListQueueTagsResponse(tagsValue.map(value => value))
      def tagsValue: scala.Option[Map[primitives.TagKey, primitives.TagValue]]
      def tags: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Map[primitives.TagKey, primitives.TagValue]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("tags", tagsValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.ListQueueTagsResponse) extends ListQueueTagsResponse.ReadOnly {
      override def tagsValue: scala.Option[Map[primitives.TagKey, primitives.TagValue]] = scala.Option(impl.tags()).map(value => value.asScala.map({
        case (key, value) =>
          (key: primitives.TagKey) -> (value: primitives.TagValue)
      }).toMap)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.ListQueueTagsResponse): ReadOnly = new Wrapper(impl)
  }
  case class ListQueuesRequest(queueNamePrefix: scala.Option[String] = None, nextToken: scala.Option[primitives.Token] = None, maxResults: scala.Option[primitives.BoxedInteger] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.ListQueuesRequest = {
      import ListQueuesRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.ListQueuesRequest.builder().optionallyWith(queueNamePrefix.map(value => value: java.lang.String))(_.queueNamePrefix).optionallyWith(nextToken.map(value => value: java.lang.String))(_.nextToken).optionallyWith(maxResults.map(value => value: java.lang.Integer))(_.maxResults).build()
    }
  }
  object ListQueuesRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.ListQueuesRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: ListQueuesRequest = ListQueuesRequest(queueNamePrefixValue.map(value => value), nextTokenValue.map(value => value), maxResultsValue.map(value => value))
      def queueNamePrefixValue: scala.Option[String]
      def nextTokenValue: scala.Option[primitives.Token]
      def maxResultsValue: scala.Option[primitives.BoxedInteger]
      def queueNamePrefix: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("queueNamePrefix", queueNamePrefixValue)
      def nextToken: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, primitives.Token] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("nextToken", nextTokenValue)
      def maxResults: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, primitives.BoxedInteger] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("maxResults", maxResultsValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.ListQueuesRequest) extends ListQueuesRequest.ReadOnly {
      override def queueNamePrefixValue: scala.Option[String] = scala.Option(impl.queueNamePrefix()).map(value => value: String)
      override def nextTokenValue: scala.Option[primitives.Token] = scala.Option(impl.nextToken()).map(value => value: primitives.Token)
      override def maxResultsValue: scala.Option[primitives.BoxedInteger] = scala.Option(impl.maxResults()).map(value => value: primitives.BoxedInteger)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.ListQueuesRequest): ReadOnly = new Wrapper(impl)
  }
  case class ListQueuesResponse(queueUrls: scala.Option[Iterable[String]] = None, nextToken: scala.Option[primitives.Token] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.ListQueuesResponse = {
      import ListQueuesResponse.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.ListQueuesResponse.builder().optionallyWith(queueUrls.map(value => value.map { item => 
        item: java.lang.String
      }.asJavaCollection))(_.queueUrls).optionallyWith(nextToken.map(value => value: java.lang.String))(_.nextToken).build()
    }
  }
  object ListQueuesResponse {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.ListQueuesResponse] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: ListQueuesResponse = ListQueuesResponse(queueUrlsValue.map(value => value), nextTokenValue.map(value => value))
      def queueUrlsValue: scala.Option[List[String]]
      def nextTokenValue: scala.Option[primitives.Token]
      def queueUrls: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, List[String]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("queueUrls", queueUrlsValue)
      def nextToken: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, primitives.Token] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("nextToken", nextTokenValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.ListQueuesResponse) extends ListQueuesResponse.ReadOnly {
      override def queueUrlsValue: scala.Option[List[String]] = scala.Option(impl.queueUrls()).map(value => value.asScala.map { item => 
        item: String
      }.toList)
      override def nextTokenValue: scala.Option[primitives.Token] = scala.Option(impl.nextToken()).map(value => value: primitives.Token)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.ListQueuesResponse): ReadOnly = new Wrapper(impl)
  }
  case class Message(messageId: scala.Option[String] = None, receiptHandle: scala.Option[String] = None, md5OfBody: scala.Option[String] = None, body: scala.Option[String] = None, attributes: scala.Option[Map[MessageSystemAttributeName, String]] = None, md5OfMessageAttributes: scala.Option[String] = None, messageAttributes: scala.Option[Map[String, MessageAttributeValue]] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.Message = {
      import Message.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.Message.builder().optionallyWith(messageId.map(value => value: java.lang.String))(_.messageId).optionallyWith(receiptHandle.map(value => value: java.lang.String))(_.receiptHandle).optionallyWith(md5OfBody.map(value => value: java.lang.String))(_.md5OfBody).optionallyWith(body.map(value => value: java.lang.String))(_.body).optionallyWith(attributes.map(value => value.map({
        case (key, value) =>
          key.unwrap.toString -> (value: java.lang.String)
      }).asJava))(_.attributesWithStrings).optionallyWith(md5OfMessageAttributes.map(value => value: java.lang.String))(_.md5OfMessageAttributes).optionallyWith(messageAttributes.map(value => value.map({
        case (key, value) =>
          (key: java.lang.String) -> value.buildAwsValue()
      }).asJava))(_.messageAttributes).build()
    }
  }
  object Message {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.Message] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: Message = Message(messageIdValue.map(value => value), receiptHandleValue.map(value => value), md5OfBodyValue.map(value => value), bodyValue.map(value => value), attributesValue.map(value => value), md5OfMessageAttributesValue.map(value => value), messageAttributesValue.map(value => value.map({
        case (key, value) =>
          key -> value.editable
      })))
      def messageIdValue: scala.Option[String]
      def receiptHandleValue: scala.Option[String]
      def md5OfBodyValue: scala.Option[String]
      def bodyValue: scala.Option[String]
      def attributesValue: scala.Option[Map[MessageSystemAttributeName, String]]
      def md5OfMessageAttributesValue: scala.Option[String]
      def messageAttributesValue: scala.Option[Map[String, MessageAttributeValue.ReadOnly]]
      def messageId: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("messageId", messageIdValue)
      def receiptHandle: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("receiptHandle", receiptHandleValue)
      def md5OfBody: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("md5OfBody", md5OfBodyValue)
      def body: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("body", bodyValue)
      def attributes: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Map[MessageSystemAttributeName, String]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("attributes", attributesValue)
      def md5OfMessageAttributes: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("md5OfMessageAttributes", md5OfMessageAttributesValue)
      def messageAttributes: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Map[String, MessageAttributeValue.ReadOnly]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("messageAttributes", messageAttributesValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.Message) extends Message.ReadOnly {
      override def messageIdValue: scala.Option[String] = scala.Option(impl.messageId()).map(value => value: String)
      override def receiptHandleValue: scala.Option[String] = scala.Option(impl.receiptHandle()).map(value => value: String)
      override def md5OfBodyValue: scala.Option[String] = scala.Option(impl.md5OfBody()).map(value => value: String)
      override def bodyValue: scala.Option[String] = scala.Option(impl.body()).map(value => value: String)
      override def attributesValue: scala.Option[Map[MessageSystemAttributeName, String]] = scala.Option(impl.attributes()).map(value => value.asScala.map({
        case (key, value) =>
          MessageSystemAttributeName.wrap(key) -> (value: String)
      }).toMap)
      override def md5OfMessageAttributesValue: scala.Option[String] = scala.Option(impl.md5OfMessageAttributes()).map(value => value: String)
      override def messageAttributesValue: scala.Option[Map[String, MessageAttributeValue.ReadOnly]] = scala.Option(impl.messageAttributes()).map(value => value.asScala.map({
        case (key, value) =>
          (key: String) -> MessageAttributeValue.wrap(value)
      }).toMap)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.Message): ReadOnly = new Wrapper(impl)
  }
  type MessageAttributeNameList = List[primitives.MessageAttributeName]
  case class MessageAttributeValue(stringValue: scala.Option[String] = None, binaryValue: scala.Option[primitives.Binary] = None, stringListValues: scala.Option[Iterable[String]] = None, binaryListValues: scala.Option[Iterable[primitives.Binary]] = None, dataType: String) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.MessageAttributeValue = {
      import MessageAttributeValue.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.MessageAttributeValue.builder().optionallyWith(stringValue.map(value => value: java.lang.String))(_.stringValue).optionallyWith(binaryValue.map(value => SdkBytes.fromByteArray(value.toArray[Byte])))(_.binaryValue).optionallyWith(stringListValues.map(value => value.map { item => 
        item: java.lang.String
      }.asJavaCollection))(_.stringListValues).optionallyWith(binaryListValues.map(value => value.map { item => 
        SdkBytes.fromByteArray(item.toArray[Byte])
      }.asJavaCollection))(_.binaryListValues).dataType(dataType: java.lang.String).build()
    }
  }
  object MessageAttributeValue {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.MessageAttributeValue] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: MessageAttributeValue = MessageAttributeValue(stringValueValue.map(value => value), binaryValueValue.map(value => value), stringListValuesValue.map(value => value), binaryListValuesValue.map(value => value), dataTypeValue)
      def stringValueValue: scala.Option[String]
      def binaryValueValue: scala.Option[primitives.Binary]
      def stringListValuesValue: scala.Option[List[String]]
      def binaryListValuesValue: scala.Option[List[primitives.Binary]]
      def dataTypeValue: String
      def stringValue: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("stringValue", stringValueValue)
      def binaryValue: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, primitives.Binary] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("binaryValue", binaryValueValue)
      def stringListValues: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, List[String]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("stringListValues", stringListValuesValue)
      def binaryListValues: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, List[primitives.Binary]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("binaryListValues", binaryListValuesValue)
      def dataType: ZIO[Any, Nothing, String] = ZIO.succeed(dataTypeValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.MessageAttributeValue) extends MessageAttributeValue.ReadOnly {
      override def stringValueValue: scala.Option[String] = scala.Option(impl.stringValue()).map(value => value: String)
      override def binaryValueValue: scala.Option[primitives.Binary] = scala.Option(impl.binaryValue()).map(value => Chunk.fromByteBuffer(value.asByteBuffer()))
      override def stringListValuesValue: scala.Option[List[String]] = scala.Option(impl.stringListValues()).map(value => value.asScala.map { item => 
        item: String
      }.toList)
      override def binaryListValuesValue: scala.Option[List[primitives.Binary]] = scala.Option(impl.binaryListValues()).map(value => value.asScala.map { item => 
        Chunk.fromByteBuffer(item.asByteBuffer())
      }.toList)
      override def dataTypeValue: String = impl.dataType(): String
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.MessageAttributeValue): ReadOnly = new Wrapper(impl)
  }
  type MessageBodyAttributeMap = Map[String, MessageAttributeValue]
  type MessageBodySystemAttributeMap = Map[MessageSystemAttributeNameForSends, MessageSystemAttributeValue]
  type MessageList = List[Message]
  type MessageSystemAttributeMap = Map[MessageSystemAttributeName, String]
  sealed trait MessageSystemAttributeName { def unwrap: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName }
  object MessageSystemAttributeName {
    def wrap(value: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName): MessageSystemAttributeName = value match {
      case software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.UNKNOWN_TO_SDK_VERSION => unknownToSdkVersion
      case software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.SENDER_ID => SenderId
      case software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.SENT_TIMESTAMP => SentTimestamp
      case software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.APPROXIMATE_RECEIVE_COUNT => ApproximateReceiveCount
      case software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.APPROXIMATE_FIRST_RECEIVE_TIMESTAMP => ApproximateFirstReceiveTimestamp
      case software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.SEQUENCE_NUMBER => SequenceNumber
      case software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.MESSAGE_DEDUPLICATION_ID => MessageDeduplicationId
      case software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.MESSAGE_GROUP_ID => MessageGroupId
      case software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.AWS_TRACE_HEADER => AWSTraceHeader
    }
    final case object unknownToSdkVersion extends MessageSystemAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName = software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.UNKNOWN_TO_SDK_VERSION }
    final case object SenderId extends MessageSystemAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName = software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.SENDER_ID }
    final case object SentTimestamp extends MessageSystemAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName = software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.SENT_TIMESTAMP }
    final case object ApproximateReceiveCount extends MessageSystemAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName = software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.APPROXIMATE_RECEIVE_COUNT }
    final case object ApproximateFirstReceiveTimestamp extends MessageSystemAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName = software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.APPROXIMATE_FIRST_RECEIVE_TIMESTAMP }
    final case object SequenceNumber extends MessageSystemAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName = software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.SEQUENCE_NUMBER }
    final case object MessageDeduplicationId extends MessageSystemAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName = software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.MESSAGE_DEDUPLICATION_ID }
    final case object MessageGroupId extends MessageSystemAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName = software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.MESSAGE_GROUP_ID }
    final case object AWSTraceHeader extends MessageSystemAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName = software.amazon.awssdk.services.sqs.model.MessageSystemAttributeName.AWS_TRACE_HEADER }
  }
  sealed trait MessageSystemAttributeNameForSends { def unwrap: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeNameForSends }
  object MessageSystemAttributeNameForSends {
    def wrap(value: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeNameForSends): MessageSystemAttributeNameForSends = value match {
      case software.amazon.awssdk.services.sqs.model.MessageSystemAttributeNameForSends.UNKNOWN_TO_SDK_VERSION => unknownToSdkVersion
      case software.amazon.awssdk.services.sqs.model.MessageSystemAttributeNameForSends.AWS_TRACE_HEADER => AWSTraceHeader
    }
    final case object unknownToSdkVersion extends MessageSystemAttributeNameForSends { override def unwrap: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeNameForSends = software.amazon.awssdk.services.sqs.model.MessageSystemAttributeNameForSends.UNKNOWN_TO_SDK_VERSION }
    final case object AWSTraceHeader extends MessageSystemAttributeNameForSends { override def unwrap: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeNameForSends = software.amazon.awssdk.services.sqs.model.MessageSystemAttributeNameForSends.AWS_TRACE_HEADER }
  }
  case class MessageSystemAttributeValue(stringValue: scala.Option[String] = None, binaryValue: scala.Option[primitives.Binary] = None, stringListValues: scala.Option[Iterable[String]] = None, binaryListValues: scala.Option[Iterable[primitives.Binary]] = None, dataType: String) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.MessageSystemAttributeValue = {
      import MessageSystemAttributeValue.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.MessageSystemAttributeValue.builder().optionallyWith(stringValue.map(value => value: java.lang.String))(_.stringValue).optionallyWith(binaryValue.map(value => SdkBytes.fromByteArray(value.toArray[Byte])))(_.binaryValue).optionallyWith(stringListValues.map(value => value.map { item => 
        item: java.lang.String
      }.asJavaCollection))(_.stringListValues).optionallyWith(binaryListValues.map(value => value.map { item => 
        SdkBytes.fromByteArray(item.toArray[Byte])
      }.asJavaCollection))(_.binaryListValues).dataType(dataType: java.lang.String).build()
    }
  }
  object MessageSystemAttributeValue {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.MessageSystemAttributeValue] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: MessageSystemAttributeValue = MessageSystemAttributeValue(stringValueValue.map(value => value), binaryValueValue.map(value => value), stringListValuesValue.map(value => value), binaryListValuesValue.map(value => value), dataTypeValue)
      def stringValueValue: scala.Option[String]
      def binaryValueValue: scala.Option[primitives.Binary]
      def stringListValuesValue: scala.Option[List[String]]
      def binaryListValuesValue: scala.Option[List[primitives.Binary]]
      def dataTypeValue: String
      def stringValue: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("stringValue", stringValueValue)
      def binaryValue: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, primitives.Binary] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("binaryValue", binaryValueValue)
      def stringListValues: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, List[String]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("stringListValues", stringListValuesValue)
      def binaryListValues: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, List[primitives.Binary]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("binaryListValues", binaryListValuesValue)
      def dataType: ZIO[Any, Nothing, String] = ZIO.succeed(dataTypeValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeValue) extends MessageSystemAttributeValue.ReadOnly {
      override def stringValueValue: scala.Option[String] = scala.Option(impl.stringValue()).map(value => value: String)
      override def binaryValueValue: scala.Option[primitives.Binary] = scala.Option(impl.binaryValue()).map(value => Chunk.fromByteBuffer(value.asByteBuffer()))
      override def stringListValuesValue: scala.Option[List[String]] = scala.Option(impl.stringListValues()).map(value => value.asScala.map { item => 
        item: String
      }.toList)
      override def binaryListValuesValue: scala.Option[List[primitives.Binary]] = scala.Option(impl.binaryListValues()).map(value => value.asScala.map { item => 
        Chunk.fromByteBuffer(item.asByteBuffer())
      }.toList)
      override def dataTypeValue: String = impl.dataType(): String
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.MessageSystemAttributeValue): ReadOnly = new Wrapper(impl)
  }
  case class PurgeQueueRequest(queueUrl: String) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.PurgeQueueRequest = {
      import PurgeQueueRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.PurgeQueueRequest.builder().queueUrl(queueUrl: java.lang.String).build()
    }
  }
  object PurgeQueueRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.PurgeQueueRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: PurgeQueueRequest = PurgeQueueRequest(queueUrlValue)
      def queueUrlValue: String
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.PurgeQueueRequest) extends PurgeQueueRequest.ReadOnly { override def queueUrlValue: String = impl.queueUrl(): String }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.PurgeQueueRequest): ReadOnly = new Wrapper(impl)
  }
  type QueueAttributeMap = Map[QueueAttributeName, String]
  sealed trait QueueAttributeName { def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName }
  object QueueAttributeName {
    def wrap(value: software.amazon.awssdk.services.sqs.model.QueueAttributeName): QueueAttributeName = value match {
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.UNKNOWN_TO_SDK_VERSION => unknownToSdkVersion
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.ALL => All
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.POLICY => Policy
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.VISIBILITY_TIMEOUT => VisibilityTimeout
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.MAXIMUM_MESSAGE_SIZE => MaximumMessageSize
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.MESSAGE_RETENTION_PERIOD => MessageRetentionPeriod
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.APPROXIMATE_NUMBER_OF_MESSAGES => ApproximateNumberOfMessages
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.APPROXIMATE_NUMBER_OF_MESSAGES_NOT_VISIBLE => ApproximateNumberOfMessagesNotVisible
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.CREATED_TIMESTAMP => CreatedTimestamp
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.LAST_MODIFIED_TIMESTAMP => LastModifiedTimestamp
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.QUEUE_ARN => QueueArn
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.APPROXIMATE_NUMBER_OF_MESSAGES_DELAYED => ApproximateNumberOfMessagesDelayed
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.DELAY_SECONDS => DelaySeconds
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.RECEIVE_MESSAGE_WAIT_TIME_SECONDS => ReceiveMessageWaitTimeSeconds
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.REDRIVE_POLICY => RedrivePolicy
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.FIFO_QUEUE => FifoQueue
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.CONTENT_BASED_DEDUPLICATION => ContentBasedDeduplication
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.KMS_MASTER_KEY_ID => KmsMasterKeyId
      case software.amazon.awssdk.services.sqs.model.QueueAttributeName.KMS_DATA_KEY_REUSE_PERIOD_SECONDS => KmsDataKeyReusePeriodSeconds
    }
    final case object unknownToSdkVersion extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.UNKNOWN_TO_SDK_VERSION }
    final case object All extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.ALL }
    final case object Policy extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.POLICY }
    final case object VisibilityTimeout extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.VISIBILITY_TIMEOUT }
    final case object MaximumMessageSize extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.MAXIMUM_MESSAGE_SIZE }
    final case object MessageRetentionPeriod extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.MESSAGE_RETENTION_PERIOD }
    final case object ApproximateNumberOfMessages extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.APPROXIMATE_NUMBER_OF_MESSAGES }
    final case object ApproximateNumberOfMessagesNotVisible extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.APPROXIMATE_NUMBER_OF_MESSAGES_NOT_VISIBLE }
    final case object CreatedTimestamp extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.CREATED_TIMESTAMP }
    final case object LastModifiedTimestamp extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.LAST_MODIFIED_TIMESTAMP }
    final case object QueueArn extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.QUEUE_ARN }
    final case object ApproximateNumberOfMessagesDelayed extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.APPROXIMATE_NUMBER_OF_MESSAGES_DELAYED }
    final case object DelaySeconds extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.DELAY_SECONDS }
    final case object ReceiveMessageWaitTimeSeconds extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.RECEIVE_MESSAGE_WAIT_TIME_SECONDS }
    final case object RedrivePolicy extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.REDRIVE_POLICY }
    final case object FifoQueue extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.FIFO_QUEUE }
    final case object ContentBasedDeduplication extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.CONTENT_BASED_DEDUPLICATION }
    final case object KmsMasterKeyId extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.KMS_MASTER_KEY_ID }
    final case object KmsDataKeyReusePeriodSeconds extends QueueAttributeName { override def unwrap: software.amazon.awssdk.services.sqs.model.QueueAttributeName = software.amazon.awssdk.services.sqs.model.QueueAttributeName.KMS_DATA_KEY_REUSE_PERIOD_SECONDS }
  }
  type QueueUrlList = List[String]
  case class ReceiveMessageRequest(queueUrl: String, attributeNames: scala.Option[Iterable[QueueAttributeName]] = None, messageAttributeNames: scala.Option[Iterable[primitives.MessageAttributeName]] = None, maxNumberOfMessages: scala.Option[Integer] = None, visibilityTimeout: scala.Option[Integer] = None, waitTimeSeconds: scala.Option[Integer] = None, receiveRequestAttemptId: scala.Option[String] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.ReceiveMessageRequest = {
      import ReceiveMessageRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.ReceiveMessageRequest.builder().queueUrl(queueUrl: java.lang.String).optionallyWith(attributeNames.map(value => value.map { item => 
        item.unwrap.toString
      }.asJavaCollection))(_.attributeNamesWithStrings).optionallyWith(messageAttributeNames.map(value => value.map { item => 
        item: java.lang.String
      }.asJavaCollection))(_.messageAttributeNames).optionallyWith(maxNumberOfMessages.map(value => value: java.lang.Integer))(_.maxNumberOfMessages).optionallyWith(visibilityTimeout.map(value => value: java.lang.Integer))(_.visibilityTimeout).optionallyWith(waitTimeSeconds.map(value => value: java.lang.Integer))(_.waitTimeSeconds).optionallyWith(receiveRequestAttemptId.map(value => value: java.lang.String))(_.receiveRequestAttemptId).build()
    }
  }
  object ReceiveMessageRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.ReceiveMessageRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: ReceiveMessageRequest = ReceiveMessageRequest(queueUrlValue, attributeNamesValue.map(value => value), messageAttributeNamesValue.map(value => value), maxNumberOfMessagesValue.map(value => value), visibilityTimeoutValue.map(value => value), waitTimeSecondsValue.map(value => value), receiveRequestAttemptIdValue.map(value => value))
      def queueUrlValue: String
      def attributeNamesValue: scala.Option[List[QueueAttributeName]]
      def messageAttributeNamesValue: scala.Option[List[primitives.MessageAttributeName]]
      def maxNumberOfMessagesValue: scala.Option[Integer]
      def visibilityTimeoutValue: scala.Option[Integer]
      def waitTimeSecondsValue: scala.Option[Integer]
      def receiveRequestAttemptIdValue: scala.Option[String]
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
      def attributeNames: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, List[QueueAttributeName]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("attributeNames", attributeNamesValue)
      def messageAttributeNames: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, List[primitives.MessageAttributeName]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("messageAttributeNames", messageAttributeNamesValue)
      def maxNumberOfMessages: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Integer] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("maxNumberOfMessages", maxNumberOfMessagesValue)
      def visibilityTimeout: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Integer] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("visibilityTimeout", visibilityTimeoutValue)
      def waitTimeSeconds: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Integer] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("waitTimeSeconds", waitTimeSecondsValue)
      def receiveRequestAttemptId: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("receiveRequestAttemptId", receiveRequestAttemptIdValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.ReceiveMessageRequest) extends ReceiveMessageRequest.ReadOnly {
      override def queueUrlValue: String = impl.queueUrl(): String
      override def attributeNamesValue: scala.Option[List[QueueAttributeName]] = scala.Option(impl.attributeNames()).map(value => value.asScala.map { item => 
        QueueAttributeName.wrap(item)
      }.toList)
      override def messageAttributeNamesValue: scala.Option[List[primitives.MessageAttributeName]] = scala.Option(impl.messageAttributeNames()).map(value => value.asScala.map { item => 
        item: primitives.MessageAttributeName
      }.toList)
      override def maxNumberOfMessagesValue: scala.Option[Integer] = scala.Option(impl.maxNumberOfMessages()).map(value => value: Integer)
      override def visibilityTimeoutValue: scala.Option[Integer] = scala.Option(impl.visibilityTimeout()).map(value => value: Integer)
      override def waitTimeSecondsValue: scala.Option[Integer] = scala.Option(impl.waitTimeSeconds()).map(value => value: Integer)
      override def receiveRequestAttemptIdValue: scala.Option[String] = scala.Option(impl.receiveRequestAttemptId()).map(value => value: String)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.ReceiveMessageRequest): ReadOnly = new Wrapper(impl)
  }
  case class ReceiveMessageResponse(messages: scala.Option[Iterable[Message]] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.ReceiveMessageResponse = {
      import ReceiveMessageResponse.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.ReceiveMessageResponse.builder().optionallyWith(messages.map(value => value.map { item => 
        item.buildAwsValue()
      }.asJavaCollection))(_.messages).build()
    }
  }
  object ReceiveMessageResponse {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.ReceiveMessageResponse] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: ReceiveMessageResponse = ReceiveMessageResponse(messagesValue.map(value => value.map { item => 
        item.editable
      }))
      def messagesValue: scala.Option[List[Message.ReadOnly]]
      def messages: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, List[Message.ReadOnly]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("messages", messagesValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.ReceiveMessageResponse) extends ReceiveMessageResponse.ReadOnly {
      override def messagesValue: scala.Option[List[Message.ReadOnly]] = scala.Option(impl.messages()).map(value => value.asScala.map { item => 
        Message.wrap(item)
      }.toList)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.ReceiveMessageResponse): ReadOnly = new Wrapper(impl)
  }
  case class RemovePermissionRequest(queueUrl: String, label: String) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.RemovePermissionRequest = {
      import RemovePermissionRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.RemovePermissionRequest.builder().queueUrl(queueUrl: java.lang.String).label(label: java.lang.String).build()
    }
  }
  object RemovePermissionRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.RemovePermissionRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: RemovePermissionRequest = RemovePermissionRequest(queueUrlValue, labelValue)
      def queueUrlValue: String
      def labelValue: String
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
      def label: ZIO[Any, Nothing, String] = ZIO.succeed(labelValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.RemovePermissionRequest) extends RemovePermissionRequest.ReadOnly {
      override def queueUrlValue: String = impl.queueUrl(): String
      override def labelValue: String = impl.label(): String
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.RemovePermissionRequest): ReadOnly = new Wrapper(impl)
  }
  case class SendMessageBatchRequest(queueUrl: String, entries: Iterable[SendMessageBatchRequestEntry]) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.SendMessageBatchRequest = {
      import SendMessageBatchRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.SendMessageBatchRequest.builder().queueUrl(queueUrl: java.lang.String).entries(entries.map { item => 
        item.buildAwsValue()
      }.asJavaCollection).build()
    }
  }
  object SendMessageBatchRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.SendMessageBatchRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: SendMessageBatchRequest = SendMessageBatchRequest(queueUrlValue, entriesValue.map { item => 
        item.editable
      })
      def queueUrlValue: String
      def entriesValue: List[SendMessageBatchRequestEntry.ReadOnly]
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
      def entries: ZIO[Any, Nothing, List[SendMessageBatchRequestEntry.ReadOnly]] = ZIO.succeed(entriesValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.SendMessageBatchRequest) extends SendMessageBatchRequest.ReadOnly {
      override def queueUrlValue: String = impl.queueUrl(): String
      override def entriesValue: List[SendMessageBatchRequestEntry.ReadOnly] = impl.entries().asScala.map { item => 
        SendMessageBatchRequestEntry.wrap(item)
      }.toList
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.SendMessageBatchRequest): ReadOnly = new Wrapper(impl)
  }
  case class SendMessageBatchRequestEntry(id: String, messageBody: String, delaySeconds: scala.Option[Integer] = None, messageAttributes: scala.Option[Map[String, MessageAttributeValue]] = None, messageSystemAttributes: scala.Option[Map[MessageSystemAttributeNameForSends, MessageSystemAttributeValue]] = None, messageDeduplicationId: scala.Option[String] = None, messageGroupId: scala.Option[String] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.SendMessageBatchRequestEntry = {
      import SendMessageBatchRequestEntry.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.SendMessageBatchRequestEntry.builder().id(id: java.lang.String).messageBody(messageBody: java.lang.String).optionallyWith(delaySeconds.map(value => value: java.lang.Integer))(_.delaySeconds).optionallyWith(messageAttributes.map(value => value.map({
        case (key, value) =>
          (key: java.lang.String) -> value.buildAwsValue()
      }).asJava))(_.messageAttributes).optionallyWith(messageSystemAttributes.map(value => value.map({
        case (key, value) =>
          key.unwrap.toString -> value.buildAwsValue()
      }).asJava))(_.messageSystemAttributesWithStrings).optionallyWith(messageDeduplicationId.map(value => value: java.lang.String))(_.messageDeduplicationId).optionallyWith(messageGroupId.map(value => value: java.lang.String))(_.messageGroupId).build()
    }
  }
  object SendMessageBatchRequestEntry {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.SendMessageBatchRequestEntry] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: SendMessageBatchRequestEntry = SendMessageBatchRequestEntry(idValue, messageBodyValue, delaySecondsValue.map(value => value), messageAttributesValue.map(value => value.map({
        case (key, value) =>
          key -> value.editable
      })), messageSystemAttributesValue.map(value => value.map({
        case (key, value) =>
          key -> value.editable
      })), messageDeduplicationIdValue.map(value => value), messageGroupIdValue.map(value => value))
      def idValue: String
      def messageBodyValue: String
      def delaySecondsValue: scala.Option[Integer]
      def messageAttributesValue: scala.Option[Map[String, MessageAttributeValue.ReadOnly]]
      def messageSystemAttributesValue: scala.Option[Map[MessageSystemAttributeNameForSends, MessageSystemAttributeValue.ReadOnly]]
      def messageDeduplicationIdValue: scala.Option[String]
      def messageGroupIdValue: scala.Option[String]
      def id: ZIO[Any, Nothing, String] = ZIO.succeed(idValue)
      def messageBody: ZIO[Any, Nothing, String] = ZIO.succeed(messageBodyValue)
      def delaySeconds: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Integer] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("delaySeconds", delaySecondsValue)
      def messageAttributes: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Map[String, MessageAttributeValue.ReadOnly]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("messageAttributes", messageAttributesValue)
      def messageSystemAttributes: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Map[MessageSystemAttributeNameForSends, MessageSystemAttributeValue.ReadOnly]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("messageSystemAttributes", messageSystemAttributesValue)
      def messageDeduplicationId: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("messageDeduplicationId", messageDeduplicationIdValue)
      def messageGroupId: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("messageGroupId", messageGroupIdValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.SendMessageBatchRequestEntry) extends SendMessageBatchRequestEntry.ReadOnly {
      override def idValue: String = impl.id(): String
      override def messageBodyValue: String = impl.messageBody(): String
      override def delaySecondsValue: scala.Option[Integer] = scala.Option(impl.delaySeconds()).map(value => value: Integer)
      override def messageAttributesValue: scala.Option[Map[String, MessageAttributeValue.ReadOnly]] = scala.Option(impl.messageAttributes()).map(value => value.asScala.map({
        case (key, value) =>
          (key: String) -> MessageAttributeValue.wrap(value)
      }).toMap)
      override def messageSystemAttributesValue: scala.Option[Map[MessageSystemAttributeNameForSends, MessageSystemAttributeValue.ReadOnly]] = scala.Option(impl.messageSystemAttributes()).map(value => value.asScala.map({
        case (key, value) =>
          MessageSystemAttributeNameForSends.wrap(key) -> MessageSystemAttributeValue.wrap(value)
      }).toMap)
      override def messageDeduplicationIdValue: scala.Option[String] = scala.Option(impl.messageDeduplicationId()).map(value => value: String)
      override def messageGroupIdValue: scala.Option[String] = scala.Option(impl.messageGroupId()).map(value => value: String)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.SendMessageBatchRequestEntry): ReadOnly = new Wrapper(impl)
  }
  type SendMessageBatchRequestEntryList = List[SendMessageBatchRequestEntry]
  case class SendMessageBatchResponse(successful: Iterable[SendMessageBatchResultEntry], failed: Iterable[BatchResultErrorEntry]) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.SendMessageBatchResponse = {
      import SendMessageBatchResponse.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.SendMessageBatchResponse.builder().successful(successful.map { item => 
        item.buildAwsValue()
      }.asJavaCollection).failed(failed.map { item => 
        item.buildAwsValue()
      }.asJavaCollection).build()
    }
  }
  object SendMessageBatchResponse {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.SendMessageBatchResponse] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: SendMessageBatchResponse = SendMessageBatchResponse(successfulValue.map { item => 
        item.editable
      }, failedValue.map { item => 
        item.editable
      })
      def successfulValue: List[SendMessageBatchResultEntry.ReadOnly]
      def failedValue: List[BatchResultErrorEntry.ReadOnly]
      def successful: ZIO[Any, Nothing, List[SendMessageBatchResultEntry.ReadOnly]] = ZIO.succeed(successfulValue)
      def failed: ZIO[Any, Nothing, List[BatchResultErrorEntry.ReadOnly]] = ZIO.succeed(failedValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.SendMessageBatchResponse) extends SendMessageBatchResponse.ReadOnly {
      override def successfulValue: List[SendMessageBatchResultEntry.ReadOnly] = impl.successful().asScala.map { item => 
        SendMessageBatchResultEntry.wrap(item)
      }.toList
      override def failedValue: List[BatchResultErrorEntry.ReadOnly] = impl.failed().asScala.map { item => 
        BatchResultErrorEntry.wrap(item)
      }.toList
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.SendMessageBatchResponse): ReadOnly = new Wrapper(impl)
  }
  case class SendMessageBatchResultEntry(id: String, messageId: String, md5OfMessageBody: String, md5OfMessageAttributes: scala.Option[String] = None, md5OfMessageSystemAttributes: scala.Option[String] = None, sequenceNumber: scala.Option[String] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.SendMessageBatchResultEntry = {
      import SendMessageBatchResultEntry.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.SendMessageBatchResultEntry.builder().id(id: java.lang.String).messageId(messageId: java.lang.String).md5OfMessageBody(md5OfMessageBody: java.lang.String).optionallyWith(md5OfMessageAttributes.map(value => value: java.lang.String))(_.md5OfMessageAttributes).optionallyWith(md5OfMessageSystemAttributes.map(value => value: java.lang.String))(_.md5OfMessageSystemAttributes).optionallyWith(sequenceNumber.map(value => value: java.lang.String))(_.sequenceNumber).build()
    }
  }
  object SendMessageBatchResultEntry {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.SendMessageBatchResultEntry] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: SendMessageBatchResultEntry = SendMessageBatchResultEntry(idValue, messageIdValue, md5OfMessageBodyValue, md5OfMessageAttributesValue.map(value => value), md5OfMessageSystemAttributesValue.map(value => value), sequenceNumberValue.map(value => value))
      def idValue: String
      def messageIdValue: String
      def md5OfMessageBodyValue: String
      def md5OfMessageAttributesValue: scala.Option[String]
      def md5OfMessageSystemAttributesValue: scala.Option[String]
      def sequenceNumberValue: scala.Option[String]
      def id: ZIO[Any, Nothing, String] = ZIO.succeed(idValue)
      def messageId: ZIO[Any, Nothing, String] = ZIO.succeed(messageIdValue)
      def md5OfMessageBody: ZIO[Any, Nothing, String] = ZIO.succeed(md5OfMessageBodyValue)
      def md5OfMessageAttributes: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("md5OfMessageAttributes", md5OfMessageAttributesValue)
      def md5OfMessageSystemAttributes: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("md5OfMessageSystemAttributes", md5OfMessageSystemAttributesValue)
      def sequenceNumber: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("sequenceNumber", sequenceNumberValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.SendMessageBatchResultEntry) extends SendMessageBatchResultEntry.ReadOnly {
      override def idValue: String = impl.id(): String
      override def messageIdValue: String = impl.messageId(): String
      override def md5OfMessageBodyValue: String = impl.md5OfMessageBody(): String
      override def md5OfMessageAttributesValue: scala.Option[String] = scala.Option(impl.md5OfMessageAttributes()).map(value => value: String)
      override def md5OfMessageSystemAttributesValue: scala.Option[String] = scala.Option(impl.md5OfMessageSystemAttributes()).map(value => value: String)
      override def sequenceNumberValue: scala.Option[String] = scala.Option(impl.sequenceNumber()).map(value => value: String)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.SendMessageBatchResultEntry): ReadOnly = new Wrapper(impl)
  }
  type SendMessageBatchResultEntryList = List[SendMessageBatchResultEntry]
  case class SendMessageRequest(queueUrl: String, messageBody: String, delaySeconds: scala.Option[Integer] = None, messageAttributes: scala.Option[Map[String, MessageAttributeValue]] = None, messageSystemAttributes: scala.Option[Map[MessageSystemAttributeNameForSends, MessageSystemAttributeValue]] = None, messageDeduplicationId: scala.Option[String] = None, messageGroupId: scala.Option[String] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.SendMessageRequest = {
      import SendMessageRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.SendMessageRequest.builder().queueUrl(queueUrl: java.lang.String).messageBody(messageBody: java.lang.String).optionallyWith(delaySeconds.map(value => value: java.lang.Integer))(_.delaySeconds).optionallyWith(messageAttributes.map(value => value.map({
        case (key, value) =>
          (key: java.lang.String) -> value.buildAwsValue()
      }).asJava))(_.messageAttributes).optionallyWith(messageSystemAttributes.map(value => value.map({
        case (key, value) =>
          key.unwrap.toString -> value.buildAwsValue()
      }).asJava))(_.messageSystemAttributesWithStrings).optionallyWith(messageDeduplicationId.map(value => value: java.lang.String))(_.messageDeduplicationId).optionallyWith(messageGroupId.map(value => value: java.lang.String))(_.messageGroupId).build()
    }
  }
  object SendMessageRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.SendMessageRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: SendMessageRequest = SendMessageRequest(queueUrlValue, messageBodyValue, delaySecondsValue.map(value => value), messageAttributesValue.map(value => value.map({
        case (key, value) =>
          key -> value.editable
      })), messageSystemAttributesValue.map(value => value.map({
        case (key, value) =>
          key -> value.editable
      })), messageDeduplicationIdValue.map(value => value), messageGroupIdValue.map(value => value))
      def queueUrlValue: String
      def messageBodyValue: String
      def delaySecondsValue: scala.Option[Integer]
      def messageAttributesValue: scala.Option[Map[String, MessageAttributeValue.ReadOnly]]
      def messageSystemAttributesValue: scala.Option[Map[MessageSystemAttributeNameForSends, MessageSystemAttributeValue.ReadOnly]]
      def messageDeduplicationIdValue: scala.Option[String]
      def messageGroupIdValue: scala.Option[String]
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
      def messageBody: ZIO[Any, Nothing, String] = ZIO.succeed(messageBodyValue)
      def delaySeconds: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Integer] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("delaySeconds", delaySecondsValue)
      def messageAttributes: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Map[String, MessageAttributeValue.ReadOnly]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("messageAttributes", messageAttributesValue)
      def messageSystemAttributes: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, Map[MessageSystemAttributeNameForSends, MessageSystemAttributeValue.ReadOnly]] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("messageSystemAttributes", messageSystemAttributesValue)
      def messageDeduplicationId: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("messageDeduplicationId", messageDeduplicationIdValue)
      def messageGroupId: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("messageGroupId", messageGroupIdValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.SendMessageRequest) extends SendMessageRequest.ReadOnly {
      override def queueUrlValue: String = impl.queueUrl(): String
      override def messageBodyValue: String = impl.messageBody(): String
      override def delaySecondsValue: scala.Option[Integer] = scala.Option(impl.delaySeconds()).map(value => value: Integer)
      override def messageAttributesValue: scala.Option[Map[String, MessageAttributeValue.ReadOnly]] = scala.Option(impl.messageAttributes()).map(value => value.asScala.map({
        case (key, value) =>
          (key: String) -> MessageAttributeValue.wrap(value)
      }).toMap)
      override def messageSystemAttributesValue: scala.Option[Map[MessageSystemAttributeNameForSends, MessageSystemAttributeValue.ReadOnly]] = scala.Option(impl.messageSystemAttributes()).map(value => value.asScala.map({
        case (key, value) =>
          MessageSystemAttributeNameForSends.wrap(key) -> MessageSystemAttributeValue.wrap(value)
      }).toMap)
      override def messageDeduplicationIdValue: scala.Option[String] = scala.Option(impl.messageDeduplicationId()).map(value => value: String)
      override def messageGroupIdValue: scala.Option[String] = scala.Option(impl.messageGroupId()).map(value => value: String)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.SendMessageRequest): ReadOnly = new Wrapper(impl)
  }
  case class SendMessageResponse(md5OfMessageBody: scala.Option[String] = None, md5OfMessageAttributes: scala.Option[String] = None, md5OfMessageSystemAttributes: scala.Option[String] = None, messageId: scala.Option[String] = None, sequenceNumber: scala.Option[String] = None) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.SendMessageResponse = {
      import SendMessageResponse.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.SendMessageResponse.builder().optionallyWith(md5OfMessageBody.map(value => value: java.lang.String))(_.md5OfMessageBody).optionallyWith(md5OfMessageAttributes.map(value => value: java.lang.String))(_.md5OfMessageAttributes).optionallyWith(md5OfMessageSystemAttributes.map(value => value: java.lang.String))(_.md5OfMessageSystemAttributes).optionallyWith(messageId.map(value => value: java.lang.String))(_.messageId).optionallyWith(sequenceNumber.map(value => value: java.lang.String))(_.sequenceNumber).build()
    }
  }
  object SendMessageResponse {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.SendMessageResponse] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: SendMessageResponse = SendMessageResponse(md5OfMessageBodyValue.map(value => value), md5OfMessageAttributesValue.map(value => value), md5OfMessageSystemAttributesValue.map(value => value), messageIdValue.map(value => value), sequenceNumberValue.map(value => value))
      def md5OfMessageBodyValue: scala.Option[String]
      def md5OfMessageAttributesValue: scala.Option[String]
      def md5OfMessageSystemAttributesValue: scala.Option[String]
      def messageIdValue: scala.Option[String]
      def sequenceNumberValue: scala.Option[String]
      def md5OfMessageBody: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("md5OfMessageBody", md5OfMessageBodyValue)
      def md5OfMessageAttributes: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("md5OfMessageAttributes", md5OfMessageAttributesValue)
      def md5OfMessageSystemAttributes: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("md5OfMessageSystemAttributes", md5OfMessageSystemAttributesValue)
      def messageId: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("messageId", messageIdValue)
      def sequenceNumber: ZIO[Any, io.github.vigoo.zioaws.core.AwsError, String] = io.github.vigoo.zioaws.core.AwsError.unwrapOptionField("sequenceNumber", sequenceNumberValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.SendMessageResponse) extends SendMessageResponse.ReadOnly {
      override def md5OfMessageBodyValue: scala.Option[String] = scala.Option(impl.md5OfMessageBody()).map(value => value: String)
      override def md5OfMessageAttributesValue: scala.Option[String] = scala.Option(impl.md5OfMessageAttributes()).map(value => value: String)
      override def md5OfMessageSystemAttributesValue: scala.Option[String] = scala.Option(impl.md5OfMessageSystemAttributes()).map(value => value: String)
      override def messageIdValue: scala.Option[String] = scala.Option(impl.messageId()).map(value => value: String)
      override def sequenceNumberValue: scala.Option[String] = scala.Option(impl.sequenceNumber()).map(value => value: String)
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.SendMessageResponse): ReadOnly = new Wrapper(impl)
  }
  case class SetQueueAttributesRequest(queueUrl: String, attributes: Map[QueueAttributeName, String]) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.SetQueueAttributesRequest = {
      import SetQueueAttributesRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.SetQueueAttributesRequest.builder().queueUrl(queueUrl: java.lang.String).attributesWithStrings(attributes.map({
        case (key, value) =>
          key.unwrap.toString -> (value: java.lang.String)
      }).asJava).build()
    }
  }
  object SetQueueAttributesRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.SetQueueAttributesRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: SetQueueAttributesRequest = SetQueueAttributesRequest(queueUrlValue, attributesValue)
      def queueUrlValue: String
      def attributesValue: Map[QueueAttributeName, String]
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
      def attributes: ZIO[Any, Nothing, Map[QueueAttributeName, String]] = ZIO.succeed(attributesValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.SetQueueAttributesRequest) extends SetQueueAttributesRequest.ReadOnly {
      override def queueUrlValue: String = impl.queueUrl(): String
      override def attributesValue: Map[QueueAttributeName, String] = impl.attributes().asScala.map({
        case (key, value) =>
          QueueAttributeName.wrap(key) -> (value: String)
      }).toMap
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.SetQueueAttributesRequest): ReadOnly = new Wrapper(impl)
  }
  type StringList = List[String]
  type TagKeyList = List[primitives.TagKey]
  type TagMap = Map[primitives.TagKey, primitives.TagValue]
  case class TagQueueRequest(queueUrl: String, tags: Map[primitives.TagKey, primitives.TagValue]) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.TagQueueRequest = {
      import TagQueueRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.TagQueueRequest.builder().queueUrl(queueUrl: java.lang.String).tags(tags.map({
        case (key, value) =>
          (key: java.lang.String) -> (value: java.lang.String)
      }).asJava).build()
    }
  }
  object TagQueueRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.TagQueueRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: TagQueueRequest = TagQueueRequest(queueUrlValue, tagsValue)
      def queueUrlValue: String
      def tagsValue: Map[primitives.TagKey, primitives.TagValue]
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
      def tags: ZIO[Any, Nothing, Map[primitives.TagKey, primitives.TagValue]] = ZIO.succeed(tagsValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.TagQueueRequest) extends TagQueueRequest.ReadOnly {
      override def queueUrlValue: String = impl.queueUrl(): String
      override def tagsValue: Map[primitives.TagKey, primitives.TagValue] = impl.tags().asScala.map({
        case (key, value) =>
          (key: primitives.TagKey) -> (value: primitives.TagValue)
      }).toMap
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.TagQueueRequest): ReadOnly = new Wrapper(impl)
  }
  case class UntagQueueRequest(queueUrl: String, tagKeys: Iterable[primitives.TagKey]) {
    def buildAwsValue(): software.amazon.awssdk.services.sqs.model.UntagQueueRequest = {
      import UntagQueueRequest.zioAwsBuilderHelper.BuilderOps
      software.amazon.awssdk.services.sqs.model.UntagQueueRequest.builder().queueUrl(queueUrl: java.lang.String).tagKeys(tagKeys.map { item => 
        item: java.lang.String
      }.asJavaCollection).build()
    }
  }
  object UntagQueueRequest {
    private lazy val zioAwsBuilderHelper: io.github.vigoo.zioaws.core.BuilderHelper[software.amazon.awssdk.services.sqs.model.UntagQueueRequest] = io.github.vigoo.zioaws.core.BuilderHelper.apply
    trait ReadOnly {
      def editable: UntagQueueRequest = UntagQueueRequest(queueUrlValue, tagKeysValue)
      def queueUrlValue: String
      def tagKeysValue: List[primitives.TagKey]
      def queueUrl: ZIO[Any, Nothing, String] = ZIO.succeed(queueUrlValue)
      def tagKeys: ZIO[Any, Nothing, List[primitives.TagKey]] = ZIO.succeed(tagKeysValue)
    }
    private class Wrapper(impl: software.amazon.awssdk.services.sqs.model.UntagQueueRequest) extends UntagQueueRequest.ReadOnly {
      override def queueUrlValue: String = impl.queueUrl(): String
      override def tagKeysValue: List[primitives.TagKey] = impl.tagKeys().asScala.map { item => 
        item: primitives.TagKey
      }.toList
    }
    def wrap(impl: software.amazon.awssdk.services.sqs.model.UntagQueueRequest): ReadOnly = new Wrapper(impl)
  }
}

service.scala

package io.github.vigoo.zioaws
import io.github.vigoo.zioaws.core._
import io.github.vigoo.zioaws.core.aspects._
import io.github.vigoo.zioaws.core.config.AwsConfig
import software.amazon.awssdk.services.sqs.{ SqsAsyncClient, SqsAsyncClientBuilder }
import zio.{ Chunk, Has, IO, ZIO, ZLayer }
import zio.stream.ZStream
import org.reactivestreams.Publisher
import scala.jdk.CollectionConverters._
package object sqs {
  import model._
  type Sqs = Has[Sqs.Service]
  object Sqs {
    trait Service extends AspectSupport[Service] {
      val api: SqsAsyncClient
      def getQueueAttributes(request: GetQueueAttributesRequest): IO[AwsError, GetQueueAttributesResponse.ReadOnly]
      def sendMessage(request: SendMessageRequest): IO[AwsError, SendMessageResponse.ReadOnly]
      def listQueues(request: ListQueuesRequest): ZStream[Any, AwsError, String]
      def untagQueue(request: UntagQueueRequest): IO[AwsError, scala.Unit]
      def tagQueue(request: TagQueueRequest): IO[AwsError, scala.Unit]
      def deleteMessage(request: DeleteMessageRequest): IO[AwsError, scala.Unit]
      def deleteMessageBatch(request: DeleteMessageBatchRequest): IO[AwsError, DeleteMessageBatchResponse.ReadOnly]
      def purgeQueue(request: PurgeQueueRequest): IO[AwsError, scala.Unit]
      def addPermission(request: AddPermissionRequest): IO[AwsError, scala.Unit]
      def listQueueTags(request: ListQueueTagsRequest): IO[AwsError, ListQueueTagsResponse.ReadOnly]
      def createQueue(request: CreateQueueRequest): IO[AwsError, CreateQueueResponse.ReadOnly]
      def listDeadLetterSourceQueues(request: ListDeadLetterSourceQueuesRequest): ZStream[Any, AwsError, String]
      def getQueueUrl(request: GetQueueUrlRequest): IO[AwsError, GetQueueUrlResponse.ReadOnly]
      def removePermission(request: RemovePermissionRequest): IO[AwsError, scala.Unit]
      def receiveMessage(request: ReceiveMessageRequest): IO[AwsError, ReceiveMessageResponse.ReadOnly]
      def setQueueAttributes(request: SetQueueAttributesRequest): IO[AwsError, scala.Unit]
      def deleteQueue(request: DeleteQueueRequest): IO[AwsError, scala.Unit]
      def sendMessageBatch(request: SendMessageBatchRequest): IO[AwsError, SendMessageBatchResponse.ReadOnly]
      def changeMessageVisibilityBatch(request: ChangeMessageVisibilityBatchRequest): IO[AwsError, ChangeMessageVisibilityBatchResponse.ReadOnly]
      def changeMessageVisibility(request: ChangeMessageVisibilityRequest): IO[AwsError, scala.Unit]
    }
  }
  val live: ZLayer[AwsConfig, Throwable, Sqs] = customized(identity)
  def customized(customization: SqsAsyncClientBuilder => SqsAsyncClientBuilder): ZLayer[AwsConfig, Throwable, Sqs] = (for (awsConfig <- ZIO.service[AwsConfig.Service]; b0 <- awsConfig.configure[SqsAsyncClient, SqsAsyncClientBuilder](SqsAsyncClient.builder()); b1 <- awsConfig.configureHttpClient[SqsAsyncClient, SqsAsyncClientBuilder](b0); client <- ZIO(customization(b1).build())) yield new SqsImpl(client, AwsCallAspect.identity, ().asInstanceOf[Any])).toLayer
  private class SqsImpl[R](override val api: SqsAsyncClient, override val aspect: AwsCallAspect[R], r: R) extends Sqs.Service with AwsServiceBase[R, SqsImpl] {
    override val serviceName: String = "Sqs"
    override def withAspect[R1](newAspect: AwsCallAspect[R1], r: R1): SqsImpl[R1] = new SqsImpl(api, newAspect, r)
    def getQueueAttributes(request: GetQueueAttributesRequest): IO[AwsError, GetQueueAttributesResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.GetQueueAttributesRequest, software.amazon.awssdk.services.sqs.model.GetQueueAttributesResponse]("getQueueAttributes", api.getQueueAttributes)(request.buildAwsValue()).map(GetQueueAttributesResponse.wrap).provide(r)
    def sendMessage(request: SendMessageRequest): IO[AwsError, SendMessageResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.SendMessageRequest, software.amazon.awssdk.services.sqs.model.SendMessageResponse]("sendMessage", api.sendMessage)(request.buildAwsValue()).map(SendMessageResponse.wrap).provide(r)
    def listQueues(request: ListQueuesRequest): ZStream[Any, AwsError, String] = asyncSimplePaginatedRequest[software.amazon.awssdk.services.sqs.model.ListQueuesRequest, software.amazon.awssdk.services.sqs.model.ListQueuesResponse, java.lang.String]("listQueues", api.listQueues, (r, token) => r.toBuilder().nextToken(token).build(), r => Option(r.nextToken()), r => Chunk.fromIterable(r.queueUrls().asScala))(request.buildAwsValue()).map(item => item: String).provide(r)
    def untagQueue(request: UntagQueueRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.UntagQueueRequest, software.amazon.awssdk.services.sqs.model.UntagQueueResponse]("untagQueue", api.untagQueue)(request.buildAwsValue()).unit.provide(r)
    def tagQueue(request: TagQueueRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.TagQueueRequest, software.amazon.awssdk.services.sqs.model.TagQueueResponse]("tagQueue", api.tagQueue)(request.buildAwsValue()).unit.provide(r)
    def deleteMessage(request: DeleteMessageRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.DeleteMessageRequest, software.amazon.awssdk.services.sqs.model.DeleteMessageResponse]("deleteMessage", api.deleteMessage)(request.buildAwsValue()).unit.provide(r)
    def deleteMessageBatch(request: DeleteMessageBatchRequest): IO[AwsError, DeleteMessageBatchResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.DeleteMessageBatchRequest, software.amazon.awssdk.services.sqs.model.DeleteMessageBatchResponse]("deleteMessageBatch", api.deleteMessageBatch)(request.buildAwsValue()).map(DeleteMessageBatchResponse.wrap).provide(r)
    def purgeQueue(request: PurgeQueueRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.PurgeQueueRequest, software.amazon.awssdk.services.sqs.model.PurgeQueueResponse]("purgeQueue", api.purgeQueue)(request.buildAwsValue()).unit.provide(r)
    def addPermission(request: AddPermissionRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.AddPermissionRequest, software.amazon.awssdk.services.sqs.model.AddPermissionResponse]("addPermission", api.addPermission)(request.buildAwsValue()).unit.provide(r)
    def listQueueTags(request: ListQueueTagsRequest): IO[AwsError, ListQueueTagsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.ListQueueTagsRequest, software.amazon.awssdk.services.sqs.model.ListQueueTagsResponse]("listQueueTags", api.listQueueTags)(request.buildAwsValue()).map(ListQueueTagsResponse.wrap).provide(r)
    def createQueue(request: CreateQueueRequest): IO[AwsError, CreateQueueResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.CreateQueueRequest, software.amazon.awssdk.services.sqs.model.CreateQueueResponse]("createQueue", api.createQueue)(request.buildAwsValue()).map(CreateQueueResponse.wrap).provide(r)
    def listDeadLetterSourceQueues(request: ListDeadLetterSourceQueuesRequest): ZStream[Any, AwsError, String] = asyncSimplePaginatedRequest[software.amazon.awssdk.services.sqs.model.ListDeadLetterSourceQueuesRequest, software.amazon.awssdk.services.sqs.model.ListDeadLetterSourceQueuesResponse, java.lang.String]("listDeadLetterSourceQueues", api.listDeadLetterSourceQueues, (r, token) => r.toBuilder().nextToken(token).build(), r => Option(r.nextToken()), r => Chunk.fromIterable(r.queueUrls().asScala))(request.buildAwsValue()).map(item => item: String).provide(r)
    def getQueueUrl(request: GetQueueUrlRequest): IO[AwsError, GetQueueUrlResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest, software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse]("getQueueUrl", api.getQueueUrl)(request.buildAwsValue()).map(GetQueueUrlResponse.wrap).provide(r)
    def removePermission(request: RemovePermissionRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.RemovePermissionRequest, software.amazon.awssdk.services.sqs.model.RemovePermissionResponse]("removePermission", api.removePermission)(request.buildAwsValue()).unit.provide(r)
    def receiveMessage(request: ReceiveMessageRequest): IO[AwsError, ReceiveMessageResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.ReceiveMessageRequest, software.amazon.awssdk.services.sqs.model.ReceiveMessageResponse]("receiveMessage", api.receiveMessage)(request.buildAwsValue()).map(ReceiveMessageResponse.wrap).provide(r)
    def setQueueAttributes(request: SetQueueAttributesRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.SetQueueAttributesRequest, software.amazon.awssdk.services.sqs.model.SetQueueAttributesResponse]("setQueueAttributes", api.setQueueAttributes)(request.buildAwsValue()).unit.provide(r)
    def deleteQueue(request: DeleteQueueRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.DeleteQueueRequest, software.amazon.awssdk.services.sqs.model.DeleteQueueResponse]("deleteQueue", api.deleteQueue)(request.buildAwsValue()).unit.provide(r)
    def sendMessageBatch(request: SendMessageBatchRequest): IO[AwsError, SendMessageBatchResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.SendMessageBatchRequest, software.amazon.awssdk.services.sqs.model.SendMessageBatchResponse]("sendMessageBatch", api.sendMessageBatch)(request.buildAwsValue()).map(SendMessageBatchResponse.wrap).provide(r)
    def changeMessageVisibilityBatch(request: ChangeMessageVisibilityBatchRequest): IO[AwsError, ChangeMessageVisibilityBatchResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchRequest, software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityBatchResponse]("changeMessageVisibilityBatch", api.changeMessageVisibilityBatch)(request.buildAwsValue()).map(ChangeMessageVisibilityBatchResponse.wrap).provide(r)
    def changeMessageVisibility(request: ChangeMessageVisibilityRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityRequest, software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityResponse]("changeMessageVisibility", api.changeMessageVisibility)(request.buildAwsValue()).unit.provide(r)
  }
  def getQueueAttributes(request: GetQueueAttributesRequest): ZIO[Sqs, AwsError, GetQueueAttributesResponse.ReadOnly] = ZIO.accessM(_.get.getQueueAttributes(request))
  def sendMessage(request: SendMessageRequest): ZIO[Sqs, AwsError, SendMessageResponse.ReadOnly] = ZIO.accessM(_.get.sendMessage(request))
  def listQueues(request: ListQueuesRequest): ZStream[Sqs, AwsError, String] = ZStream.accessStream(_.get.listQueues(request))
  def untagQueue(request: UntagQueueRequest): ZIO[Sqs, AwsError, scala.Unit] = ZIO.accessM(_.get.untagQueue(request))
  def tagQueue(request: TagQueueRequest): ZIO[Sqs, AwsError, scala.Unit] = ZIO.accessM(_.get.tagQueue(request))
  def deleteMessage(request: DeleteMessageRequest): ZIO[Sqs, AwsError, scala.Unit] = ZIO.accessM(_.get.deleteMessage(request))
  def deleteMessageBatch(request: DeleteMessageBatchRequest): ZIO[Sqs, AwsError, DeleteMessageBatchResponse.ReadOnly] = ZIO.accessM(_.get.deleteMessageBatch(request))
  def purgeQueue(request: PurgeQueueRequest): ZIO[Sqs, AwsError, scala.Unit] = ZIO.accessM(_.get.purgeQueue(request))
  def addPermission(request: AddPermissionRequest): ZIO[Sqs, AwsError, scala.Unit] = ZIO.accessM(_.get.addPermission(request))
  def listQueueTags(request: ListQueueTagsRequest): ZIO[Sqs, AwsError, ListQueueTagsResponse.ReadOnly] = ZIO.accessM(_.get.listQueueTags(request))
  def createQueue(request: CreateQueueRequest): ZIO[Sqs, AwsError, CreateQueueResponse.ReadOnly] = ZIO.accessM(_.get.createQueue(request))
  def listDeadLetterSourceQueues(request: ListDeadLetterSourceQueuesRequest): ZStream[Sqs, AwsError, String] = ZStream.accessStream(_.get.listDeadLetterSourceQueues(request))
  def getQueueUrl(request: GetQueueUrlRequest): ZIO[Sqs, AwsError, GetQueueUrlResponse.ReadOnly] = ZIO.accessM(_.get.getQueueUrl(request))
  def removePermission(request: RemovePermissionRequest): ZIO[Sqs, AwsError, scala.Unit] = ZIO.accessM(_.get.removePermission(request))
  def receiveMessage(request: ReceiveMessageRequest): ZIO[Sqs, AwsError, ReceiveMessageResponse.ReadOnly] = ZIO.accessM(_.get.receiveMessage(request))
  def setQueueAttributes(request: SetQueueAttributesRequest): ZIO[Sqs, AwsError, scala.Unit] = ZIO.accessM(_.get.setQueueAttributes(request))
  def deleteQueue(request: DeleteQueueRequest): ZIO[Sqs, AwsError, scala.Unit] = ZIO.accessM(_.get.deleteQueue(request))
  def sendMessageBatch(request: SendMessageBatchRequest): ZIO[Sqs, AwsError, SendMessageBatchResponse.ReadOnly] = ZIO.accessM(_.get.sendMessageBatch(request))
  def changeMessageVisibilityBatch(request: ChangeMessageVisibilityBatchRequest): ZIO[Sqs, AwsError, ChangeMessageVisibilityBatchResponse.ReadOnly] = ZIO.accessM(_.get.changeMessageVisibilityBatch(request))
  def changeMessageVisibility(request: ChangeMessageVisibilityRequest): ZIO[Sqs, AwsError, scala.Unit] = ZIO.accessM(_.get.changeMessageVisibility(request))
}