• Home
• io.github.vigoo
• zio-aws-dynamodb_2.12
• 3.15.63.1
• source code
• package.scala

×

Project download

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

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

io.github.vigoo.zioaws.dynamodb.package.scala Maven / Gradle / Ivy

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 io.github.vigoo.zioaws.core.httpclient.ServiceHttpCapabilities
import software.amazon.awssdk.services.dynamodb.paginators._
import software.amazon.awssdk.services.dynamodb.{ DynamoDbAsyncClient, DynamoDbAsyncClientBuilder }
import zio.{ Chunk, Has, IO, ZIO, ZLayer, ZManaged }
import zio.stream.ZStream
import org.reactivestreams.Publisher
import scala.jdk.CollectionConverters._
package object dynamodb {
  import model._
  type DynamoDb = Has[DynamoDb.Service]
  object DynamoDb {
    trait Service extends AspectSupport[Service] {
      val api: DynamoDbAsyncClient
      def putItem(request: PutItemRequest): IO[AwsError, PutItemResponse.ReadOnly]
      def restoreTableToPointInTime(request: RestoreTableToPointInTimeRequest): IO[AwsError, RestoreTableToPointInTimeResponse.ReadOnly]
      def updateGlobalTableSettings(request: UpdateGlobalTableSettingsRequest): IO[AwsError, UpdateGlobalTableSettingsResponse.ReadOnly]
      def batchExecuteStatement(request: BatchExecuteStatementRequest): IO[AwsError, BatchExecuteStatementResponse.ReadOnly]
      def executeTransaction(request: ExecuteTransactionRequest): IO[AwsError, ExecuteTransactionResponse.ReadOnly]
      def listBackups(request: ListBackupsRequest): IO[AwsError, ListBackupsResponse.ReadOnly]
      def updateContributorInsights(request: UpdateContributorInsightsRequest): IO[AwsError, UpdateContributorInsightsResponse.ReadOnly]
      def describeGlobalTable(request: DescribeGlobalTableRequest): IO[AwsError, DescribeGlobalTableResponse.ReadOnly]
      def createTable(request: CreateTableRequest): IO[AwsError, CreateTableResponse.ReadOnly]
      def deleteTable(request: DeleteTableRequest): IO[AwsError, DeleteTableResponse.ReadOnly]
      def executeStatement(request: ExecuteStatementRequest): ZStream[Any, AwsError, Map[primitives.AttributeName, AttributeValue.ReadOnly]]
      def createBackup(request: CreateBackupRequest): IO[AwsError, CreateBackupResponse.ReadOnly]
      def enableKinesisStreamingDestination(request: EnableKinesisStreamingDestinationRequest): IO[AwsError, EnableKinesisStreamingDestinationResponse.ReadOnly]
      def describeContributorInsights(request: DescribeContributorInsightsRequest): IO[AwsError, DescribeContributorInsightsResponse.ReadOnly]
      def listGlobalTables(request: ListGlobalTablesRequest): IO[AwsError, ListGlobalTablesResponse.ReadOnly]
      def batchGetItem(request: BatchGetItemRequest): IO[AwsError, BatchGetItemResponse.ReadOnly]
      def describeExport(request: DescribeExportRequest): IO[AwsError, DescribeExportResponse.ReadOnly]
      def listExports(request: ListExportsRequest): ZStream[Any, AwsError, ExportSummary.ReadOnly]
      def disableKinesisStreamingDestination(request: DisableKinesisStreamingDestinationRequest): IO[AwsError, DisableKinesisStreamingDestinationResponse.ReadOnly]
      def describeGlobalTableSettings(request: DescribeGlobalTableSettingsRequest): IO[AwsError, DescribeGlobalTableSettingsResponse.ReadOnly]
      def describeTableReplicaAutoScaling(request: DescribeTableReplicaAutoScalingRequest): IO[AwsError, DescribeTableReplicaAutoScalingResponse.ReadOnly]
      def query(request: QueryRequest): zio.stream.ZStream[Any, AwsError, Map[primitives.AttributeName, AttributeValue.ReadOnly]]
      def exportTableToPointInTime(request: ExportTableToPointInTimeRequest): IO[AwsError, ExportTableToPointInTimeResponse.ReadOnly]
      def listTables(request: ListTablesRequest): zio.stream.ZStream[Any, AwsError, primitives.TableName]
      def describeTable(request: DescribeTableRequest): IO[AwsError, DescribeTableResponse.ReadOnly]
      def restoreTableFromBackup(request: RestoreTableFromBackupRequest): IO[AwsError, RestoreTableFromBackupResponse.ReadOnly]
      def updateContinuousBackups(request: UpdateContinuousBackupsRequest): IO[AwsError, UpdateContinuousBackupsResponse.ReadOnly]
      def updateTable(request: UpdateTableRequest): IO[AwsError, UpdateTableResponse.ReadOnly]
      def createGlobalTable(request: CreateGlobalTableRequest): IO[AwsError, CreateGlobalTableResponse.ReadOnly]
      def untagResource(request: UntagResourceRequest): IO[AwsError, scala.Unit]
      def listContributorInsights(request: ListContributorInsightsRequest): ZStream[Any, AwsError, ContributorInsightsSummary.ReadOnly]
      def describeTimeToLive(request: DescribeTimeToLiveRequest): IO[AwsError, DescribeTimeToLiveResponse.ReadOnly]
      def describeEndpoints(request: DescribeEndpointsRequest): IO[AwsError, DescribeEndpointsResponse.ReadOnly]
      def transactWriteItems(request: TransactWriteItemsRequest): IO[AwsError, TransactWriteItemsResponse.ReadOnly]
      def deleteBackup(request: DeleteBackupRequest): IO[AwsError, DeleteBackupResponse.ReadOnly]
      def describeContinuousBackups(request: DescribeContinuousBackupsRequest): IO[AwsError, DescribeContinuousBackupsResponse.ReadOnly]
      def tagResource(request: TagResourceRequest): IO[AwsError, scala.Unit]
      def transactGetItems(request: TransactGetItemsRequest): IO[AwsError, TransactGetItemsResponse.ReadOnly]
      def updateItem(request: UpdateItemRequest): IO[AwsError, UpdateItemResponse.ReadOnly]
      def updateTableReplicaAutoScaling(request: UpdateTableReplicaAutoScalingRequest): IO[AwsError, UpdateTableReplicaAutoScalingResponse.ReadOnly]
      def getItem(request: GetItemRequest): IO[AwsError, GetItemResponse.ReadOnly]
      def updateTimeToLive(request: UpdateTimeToLiveRequest): IO[AwsError, UpdateTimeToLiveResponse.ReadOnly]
      def describeLimits(request: DescribeLimitsRequest): IO[AwsError, DescribeLimitsResponse.ReadOnly]
      def updateGlobalTable(request: UpdateGlobalTableRequest): IO[AwsError, UpdateGlobalTableResponse.ReadOnly]
      def batchWriteItem(request: BatchWriteItemRequest): IO[AwsError, BatchWriteItemResponse.ReadOnly]
      def scan(request: ScanRequest): zio.stream.ZStream[Any, AwsError, Map[primitives.AttributeName, AttributeValue.ReadOnly]]
      def listTagsOfResource(request: ListTagsOfResourceRequest): ZStream[Any, AwsError, Tag.ReadOnly]
      def describeBackup(request: DescribeBackupRequest): IO[AwsError, DescribeBackupResponse.ReadOnly]
      def deleteItem(request: DeleteItemRequest): IO[AwsError, DeleteItemResponse.ReadOnly]
      def describeKinesisStreamingDestination(request: DescribeKinesisStreamingDestinationRequest): IO[AwsError, DescribeKinesisStreamingDestinationResponse.ReadOnly]
    }
  }
  val live: ZLayer[AwsConfig, Throwable, DynamoDb] = customized(identity)
  def customized(customization: DynamoDbAsyncClientBuilder => DynamoDbAsyncClientBuilder): ZLayer[AwsConfig, Throwable, DynamoDb] = managed(customization).toLayer
  def managed(customization: DynamoDbAsyncClientBuilder => DynamoDbAsyncClientBuilder): ZManaged[AwsConfig, Throwable, DynamoDb.Service] = for (awsConfig <- ZManaged.service[AwsConfig.Service]; b0 <- awsConfig.configure[DynamoDbAsyncClient, DynamoDbAsyncClientBuilder](DynamoDbAsyncClient.builder()).toManaged_; b1 <- awsConfig.configureHttpClient[DynamoDbAsyncClient, DynamoDbAsyncClientBuilder](b0, ServiceHttpCapabilities(supportsHttp2 = false)).toManaged_; client <- ZIO(customization(b1).build()).toManaged_) yield new DynamoDbImpl(client, AwsCallAspect.identity, ().asInstanceOf[Any])
  private class DynamoDbImpl[R](override val api: DynamoDbAsyncClient, override val aspect: AwsCallAspect[R], r: R) extends DynamoDb.Service with AwsServiceBase[R, DynamoDbImpl] {
    override val serviceName: String = "DynamoDb"
    override def withAspect[R1](newAspect: AwsCallAspect[R1], r: R1): DynamoDbImpl[R1] = new DynamoDbImpl(api, newAspect, r)
    def putItem(request: PutItemRequest): IO[AwsError, PutItemResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.PutItemRequest, software.amazon.awssdk.services.dynamodb.model.PutItemResponse]("putItem", api.putItem)(request.buildAwsValue()).map(PutItemResponse.wrap).provide(r)
    def restoreTableToPointInTime(request: RestoreTableToPointInTimeRequest): IO[AwsError, RestoreTableToPointInTimeResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.RestoreTableToPointInTimeRequest, software.amazon.awssdk.services.dynamodb.model.RestoreTableToPointInTimeResponse]("restoreTableToPointInTime", api.restoreTableToPointInTime)(request.buildAwsValue()).map(RestoreTableToPointInTimeResponse.wrap).provide(r)
    def updateGlobalTableSettings(request: UpdateGlobalTableSettingsRequest): IO[AwsError, UpdateGlobalTableSettingsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.UpdateGlobalTableSettingsRequest, software.amazon.awssdk.services.dynamodb.model.UpdateGlobalTableSettingsResponse]("updateGlobalTableSettings", api.updateGlobalTableSettings)(request.buildAwsValue()).map(UpdateGlobalTableSettingsResponse.wrap).provide(r)
    def batchExecuteStatement(request: BatchExecuteStatementRequest): IO[AwsError, BatchExecuteStatementResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.BatchExecuteStatementRequest, software.amazon.awssdk.services.dynamodb.model.BatchExecuteStatementResponse]("batchExecuteStatement", api.batchExecuteStatement)(request.buildAwsValue()).map(BatchExecuteStatementResponse.wrap).provide(r)
    def executeTransaction(request: ExecuteTransactionRequest): IO[AwsError, ExecuteTransactionResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.ExecuteTransactionRequest, software.amazon.awssdk.services.dynamodb.model.ExecuteTransactionResponse]("executeTransaction", api.executeTransaction)(request.buildAwsValue()).map(ExecuteTransactionResponse.wrap).provide(r)
    def listBackups(request: ListBackupsRequest): IO[AwsError, ListBackupsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.ListBackupsRequest, software.amazon.awssdk.services.dynamodb.model.ListBackupsResponse]("listBackups", api.listBackups)(request.buildAwsValue()).map(ListBackupsResponse.wrap).provide(r)
    def updateContributorInsights(request: UpdateContributorInsightsRequest): IO[AwsError, UpdateContributorInsightsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.UpdateContributorInsightsRequest, software.amazon.awssdk.services.dynamodb.model.UpdateContributorInsightsResponse]("updateContributorInsights", api.updateContributorInsights)(request.buildAwsValue()).map(UpdateContributorInsightsResponse.wrap).provide(r)
    def describeGlobalTable(request: DescribeGlobalTableRequest): IO[AwsError, DescribeGlobalTableResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DescribeGlobalTableRequest, software.amazon.awssdk.services.dynamodb.model.DescribeGlobalTableResponse]("describeGlobalTable", api.describeGlobalTable)(request.buildAwsValue()).map(DescribeGlobalTableResponse.wrap).provide(r)
    def createTable(request: CreateTableRequest): IO[AwsError, CreateTableResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.CreateTableRequest, software.amazon.awssdk.services.dynamodb.model.CreateTableResponse]("createTable", api.createTable)(request.buildAwsValue()).map(CreateTableResponse.wrap).provide(r)
    def deleteTable(request: DeleteTableRequest): IO[AwsError, DeleteTableResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DeleteTableRequest, software.amazon.awssdk.services.dynamodb.model.DeleteTableResponse]("deleteTable", api.deleteTable)(request.buildAwsValue()).map(DeleteTableResponse.wrap).provide(r)
    def executeStatement(request: ExecuteStatementRequest): ZStream[Any, AwsError, Map[primitives.AttributeName, AttributeValue.ReadOnly]] = asyncSimplePaginatedRequest[software.amazon.awssdk.services.dynamodb.model.ExecuteStatementRequest, software.amazon.awssdk.services.dynamodb.model.ExecuteStatementResponse, java.util.Map[java.lang.String, software.amazon.awssdk.services.dynamodb.model.AttributeValue]]("executeStatement", api.executeStatement, (r, token) => r.toBuilder().nextToken(token).build(), r => Option(r.nextToken()), r => Chunk.fromIterable(r.items().asScala))(request.buildAwsValue()).map(item => item.asScala.map({
      case (key, value) =>
        (key: primitives.AttributeName) -> AttributeValue.wrap(value)
    }).toMap).provide(r)
    def createBackup(request: CreateBackupRequest): IO[AwsError, CreateBackupResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.CreateBackupRequest, software.amazon.awssdk.services.dynamodb.model.CreateBackupResponse]("createBackup", api.createBackup)(request.buildAwsValue()).map(CreateBackupResponse.wrap).provide(r)
    def enableKinesisStreamingDestination(request: EnableKinesisStreamingDestinationRequest): IO[AwsError, EnableKinesisStreamingDestinationResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.EnableKinesisStreamingDestinationRequest, software.amazon.awssdk.services.dynamodb.model.EnableKinesisStreamingDestinationResponse]("enableKinesisStreamingDestination", api.enableKinesisStreamingDestination)(request.buildAwsValue()).map(EnableKinesisStreamingDestinationResponse.wrap).provide(r)
    def describeContributorInsights(request: DescribeContributorInsightsRequest): IO[AwsError, DescribeContributorInsightsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DescribeContributorInsightsRequest, software.amazon.awssdk.services.dynamodb.model.DescribeContributorInsightsResponse]("describeContributorInsights", api.describeContributorInsights)(request.buildAwsValue()).map(DescribeContributorInsightsResponse.wrap).provide(r)
    def listGlobalTables(request: ListGlobalTablesRequest): IO[AwsError, ListGlobalTablesResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.ListGlobalTablesRequest, software.amazon.awssdk.services.dynamodb.model.ListGlobalTablesResponse]("listGlobalTables", api.listGlobalTables)(request.buildAwsValue()).map(ListGlobalTablesResponse.wrap).provide(r)
    def batchGetItem(request: BatchGetItemRequest): IO[AwsError, BatchGetItemResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.BatchGetItemRequest, software.amazon.awssdk.services.dynamodb.model.BatchGetItemResponse]("batchGetItem", api.batchGetItem)(request.buildAwsValue()).map(BatchGetItemResponse.wrap).provide(r)
    def describeExport(request: DescribeExportRequest): IO[AwsError, DescribeExportResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DescribeExportRequest, software.amazon.awssdk.services.dynamodb.model.DescribeExportResponse]("describeExport", api.describeExport)(request.buildAwsValue()).map(DescribeExportResponse.wrap).provide(r)
    def listExports(request: ListExportsRequest): ZStream[Any, AwsError, ExportSummary.ReadOnly] = asyncSimplePaginatedRequest[software.amazon.awssdk.services.dynamodb.model.ListExportsRequest, software.amazon.awssdk.services.dynamodb.model.ListExportsResponse, software.amazon.awssdk.services.dynamodb.model.ExportSummary]("listExports", api.listExports, (r, token) => r.toBuilder().nextToken(token).build(), r => Option(r.nextToken()), r => Chunk.fromIterable(r.exportSummaries().asScala))(request.buildAwsValue()).map(item => ExportSummary.wrap(item)).provide(r)
    def disableKinesisStreamingDestination(request: DisableKinesisStreamingDestinationRequest): IO[AwsError, DisableKinesisStreamingDestinationResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DisableKinesisStreamingDestinationRequest, software.amazon.awssdk.services.dynamodb.model.DisableKinesisStreamingDestinationResponse]("disableKinesisStreamingDestination", api.disableKinesisStreamingDestination)(request.buildAwsValue()).map(DisableKinesisStreamingDestinationResponse.wrap).provide(r)
    def describeGlobalTableSettings(request: DescribeGlobalTableSettingsRequest): IO[AwsError, DescribeGlobalTableSettingsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DescribeGlobalTableSettingsRequest, software.amazon.awssdk.services.dynamodb.model.DescribeGlobalTableSettingsResponse]("describeGlobalTableSettings", api.describeGlobalTableSettings)(request.buildAwsValue()).map(DescribeGlobalTableSettingsResponse.wrap).provide(r)
    def describeTableReplicaAutoScaling(request: DescribeTableReplicaAutoScalingRequest): IO[AwsError, DescribeTableReplicaAutoScalingResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DescribeTableReplicaAutoScalingRequest, software.amazon.awssdk.services.dynamodb.model.DescribeTableReplicaAutoScalingResponse]("describeTableReplicaAutoScaling", api.describeTableReplicaAutoScaling)(request.buildAwsValue()).map(DescribeTableReplicaAutoScalingResponse.wrap).provide(r)
    def query(request: QueryRequest): zio.stream.ZStream[Any, AwsError, Map[primitives.AttributeName, AttributeValue.ReadOnly]] = asyncJavaPaginatedRequest[software.amazon.awssdk.services.dynamodb.model.QueryRequest, java.util.Map[java.lang.String, software.amazon.awssdk.services.dynamodb.model.AttributeValue], software.amazon.awssdk.services.dynamodb.paginators.QueryPublisher]("query", api.queryPaginator, _.items())(request.buildAwsValue()).map(item => item.asScala.map({
      case (key, value) =>
        (key: primitives.AttributeName) -> AttributeValue.wrap(value)
    }).toMap).provide(r)
    def exportTableToPointInTime(request: ExportTableToPointInTimeRequest): IO[AwsError, ExportTableToPointInTimeResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.ExportTableToPointInTimeRequest, software.amazon.awssdk.services.dynamodb.model.ExportTableToPointInTimeResponse]("exportTableToPointInTime", api.exportTableToPointInTime)(request.buildAwsValue()).map(ExportTableToPointInTimeResponse.wrap).provide(r)
    def listTables(request: ListTablesRequest): zio.stream.ZStream[Any, AwsError, primitives.TableName] = asyncJavaPaginatedRequest[software.amazon.awssdk.services.dynamodb.model.ListTablesRequest, java.lang.String, software.amazon.awssdk.services.dynamodb.paginators.ListTablesPublisher]("listTables", api.listTablesPaginator, _.tableNames())(request.buildAwsValue()).map(item => item: primitives.TableName).provide(r)
    def describeTable(request: DescribeTableRequest): IO[AwsError, DescribeTableResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DescribeTableRequest, software.amazon.awssdk.services.dynamodb.model.DescribeTableResponse]("describeTable", api.describeTable)(request.buildAwsValue()).map(DescribeTableResponse.wrap).provide(r)
    def restoreTableFromBackup(request: RestoreTableFromBackupRequest): IO[AwsError, RestoreTableFromBackupResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.RestoreTableFromBackupRequest, software.amazon.awssdk.services.dynamodb.model.RestoreTableFromBackupResponse]("restoreTableFromBackup", api.restoreTableFromBackup)(request.buildAwsValue()).map(RestoreTableFromBackupResponse.wrap).provide(r)
    def updateContinuousBackups(request: UpdateContinuousBackupsRequest): IO[AwsError, UpdateContinuousBackupsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.UpdateContinuousBackupsRequest, software.amazon.awssdk.services.dynamodb.model.UpdateContinuousBackupsResponse]("updateContinuousBackups", api.updateContinuousBackups)(request.buildAwsValue()).map(UpdateContinuousBackupsResponse.wrap).provide(r)
    def updateTable(request: UpdateTableRequest): IO[AwsError, UpdateTableResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.UpdateTableRequest, software.amazon.awssdk.services.dynamodb.model.UpdateTableResponse]("updateTable", api.updateTable)(request.buildAwsValue()).map(UpdateTableResponse.wrap).provide(r)
    def createGlobalTable(request: CreateGlobalTableRequest): IO[AwsError, CreateGlobalTableResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.CreateGlobalTableRequest, software.amazon.awssdk.services.dynamodb.model.CreateGlobalTableResponse]("createGlobalTable", api.createGlobalTable)(request.buildAwsValue()).map(CreateGlobalTableResponse.wrap).provide(r)
    def untagResource(request: UntagResourceRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.UntagResourceRequest, software.amazon.awssdk.services.dynamodb.model.UntagResourceResponse]("untagResource", api.untagResource)(request.buildAwsValue()).unit.provide(r)
    def listContributorInsights(request: ListContributorInsightsRequest): ZStream[Any, AwsError, ContributorInsightsSummary.ReadOnly] = asyncSimplePaginatedRequest[software.amazon.awssdk.services.dynamodb.model.ListContributorInsightsRequest, software.amazon.awssdk.services.dynamodb.model.ListContributorInsightsResponse, software.amazon.awssdk.services.dynamodb.model.ContributorInsightsSummary]("listContributorInsights", api.listContributorInsights, (r, token) => r.toBuilder().nextToken(token).build(), r => Option(r.nextToken()), r => Chunk.fromIterable(r.contributorInsightsSummaries().asScala))(request.buildAwsValue()).map(item => ContributorInsightsSummary.wrap(item)).provide(r)
    def describeTimeToLive(request: DescribeTimeToLiveRequest): IO[AwsError, DescribeTimeToLiveResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DescribeTimeToLiveRequest, software.amazon.awssdk.services.dynamodb.model.DescribeTimeToLiveResponse]("describeTimeToLive", api.describeTimeToLive)(request.buildAwsValue()).map(DescribeTimeToLiveResponse.wrap).provide(r)
    def describeEndpoints(request: DescribeEndpointsRequest): IO[AwsError, DescribeEndpointsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DescribeEndpointsRequest, software.amazon.awssdk.services.dynamodb.model.DescribeEndpointsResponse]("describeEndpoints", api.describeEndpoints)(request.buildAwsValue()).map(DescribeEndpointsResponse.wrap).provide(r)
    def transactWriteItems(request: TransactWriteItemsRequest): IO[AwsError, TransactWriteItemsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.TransactWriteItemsRequest, software.amazon.awssdk.services.dynamodb.model.TransactWriteItemsResponse]("transactWriteItems", api.transactWriteItems)(request.buildAwsValue()).map(TransactWriteItemsResponse.wrap).provide(r)
    def deleteBackup(request: DeleteBackupRequest): IO[AwsError, DeleteBackupResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DeleteBackupRequest, software.amazon.awssdk.services.dynamodb.model.DeleteBackupResponse]("deleteBackup", api.deleteBackup)(request.buildAwsValue()).map(DeleteBackupResponse.wrap).provide(r)
    def describeContinuousBackups(request: DescribeContinuousBackupsRequest): IO[AwsError, DescribeContinuousBackupsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DescribeContinuousBackupsRequest, software.amazon.awssdk.services.dynamodb.model.DescribeContinuousBackupsResponse]("describeContinuousBackups", api.describeContinuousBackups)(request.buildAwsValue()).map(DescribeContinuousBackupsResponse.wrap).provide(r)
    def tagResource(request: TagResourceRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.TagResourceRequest, software.amazon.awssdk.services.dynamodb.model.TagResourceResponse]("tagResource", api.tagResource)(request.buildAwsValue()).unit.provide(r)
    def transactGetItems(request: TransactGetItemsRequest): IO[AwsError, TransactGetItemsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.TransactGetItemsRequest, software.amazon.awssdk.services.dynamodb.model.TransactGetItemsResponse]("transactGetItems", api.transactGetItems)(request.buildAwsValue()).map(TransactGetItemsResponse.wrap).provide(r)
    def updateItem(request: UpdateItemRequest): IO[AwsError, UpdateItemResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.UpdateItemRequest, software.amazon.awssdk.services.dynamodb.model.UpdateItemResponse]("updateItem", api.updateItem)(request.buildAwsValue()).map(UpdateItemResponse.wrap).provide(r)
    def updateTableReplicaAutoScaling(request: UpdateTableReplicaAutoScalingRequest): IO[AwsError, UpdateTableReplicaAutoScalingResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.UpdateTableReplicaAutoScalingRequest, software.amazon.awssdk.services.dynamodb.model.UpdateTableReplicaAutoScalingResponse]("updateTableReplicaAutoScaling", api.updateTableReplicaAutoScaling)(request.buildAwsValue()).map(UpdateTableReplicaAutoScalingResponse.wrap).provide(r)
    def getItem(request: GetItemRequest): IO[AwsError, GetItemResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.GetItemRequest, software.amazon.awssdk.services.dynamodb.model.GetItemResponse]("getItem", api.getItem)(request.buildAwsValue()).map(GetItemResponse.wrap).provide(r)
    def updateTimeToLive(request: UpdateTimeToLiveRequest): IO[AwsError, UpdateTimeToLiveResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.UpdateTimeToLiveRequest, software.amazon.awssdk.services.dynamodb.model.UpdateTimeToLiveResponse]("updateTimeToLive", api.updateTimeToLive)(request.buildAwsValue()).map(UpdateTimeToLiveResponse.wrap).provide(r)
    def describeLimits(request: DescribeLimitsRequest): IO[AwsError, DescribeLimitsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DescribeLimitsRequest, software.amazon.awssdk.services.dynamodb.model.DescribeLimitsResponse]("describeLimits", api.describeLimits)(request.buildAwsValue()).map(DescribeLimitsResponse.wrap).provide(r)
    def updateGlobalTable(request: UpdateGlobalTableRequest): IO[AwsError, UpdateGlobalTableResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.UpdateGlobalTableRequest, software.amazon.awssdk.services.dynamodb.model.UpdateGlobalTableResponse]("updateGlobalTable", api.updateGlobalTable)(request.buildAwsValue()).map(UpdateGlobalTableResponse.wrap).provide(r)
    def batchWriteItem(request: BatchWriteItemRequest): IO[AwsError, BatchWriteItemResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.BatchWriteItemRequest, software.amazon.awssdk.services.dynamodb.model.BatchWriteItemResponse]("batchWriteItem", api.batchWriteItem)(request.buildAwsValue()).map(BatchWriteItemResponse.wrap).provide(r)
    def scan(request: ScanRequest): zio.stream.ZStream[Any, AwsError, Map[primitives.AttributeName, AttributeValue.ReadOnly]] = asyncJavaPaginatedRequest[software.amazon.awssdk.services.dynamodb.model.ScanRequest, java.util.Map[java.lang.String, software.amazon.awssdk.services.dynamodb.model.AttributeValue], software.amazon.awssdk.services.dynamodb.paginators.ScanPublisher]("scan", api.scanPaginator, _.items())(request.buildAwsValue()).map(item => item.asScala.map({
      case (key, value) =>
        (key: primitives.AttributeName) -> AttributeValue.wrap(value)
    }).toMap).provide(r)
    def listTagsOfResource(request: ListTagsOfResourceRequest): ZStream[Any, AwsError, Tag.ReadOnly] = asyncSimplePaginatedRequest[software.amazon.awssdk.services.dynamodb.model.ListTagsOfResourceRequest, software.amazon.awssdk.services.dynamodb.model.ListTagsOfResourceResponse, software.amazon.awssdk.services.dynamodb.model.Tag]("listTagsOfResource", api.listTagsOfResource, (r, token) => r.toBuilder().nextToken(token).build(), r => Option(r.nextToken()), r => Chunk.fromIterable(r.tags().asScala))(request.buildAwsValue()).map(item => Tag.wrap(item)).provide(r)
    def describeBackup(request: DescribeBackupRequest): IO[AwsError, DescribeBackupResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DescribeBackupRequest, software.amazon.awssdk.services.dynamodb.model.DescribeBackupResponse]("describeBackup", api.describeBackup)(request.buildAwsValue()).map(DescribeBackupResponse.wrap).provide(r)
    def deleteItem(request: DeleteItemRequest): IO[AwsError, DeleteItemResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DeleteItemRequest, software.amazon.awssdk.services.dynamodb.model.DeleteItemResponse]("deleteItem", api.deleteItem)(request.buildAwsValue()).map(DeleteItemResponse.wrap).provide(r)
    def describeKinesisStreamingDestination(request: DescribeKinesisStreamingDestinationRequest): IO[AwsError, DescribeKinesisStreamingDestinationResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.dynamodb.model.DescribeKinesisStreamingDestinationRequest, software.amazon.awssdk.services.dynamodb.model.DescribeKinesisStreamingDestinationResponse]("describeKinesisStreamingDestination", api.describeKinesisStreamingDestination)(request.buildAwsValue()).map(DescribeKinesisStreamingDestinationResponse.wrap).provide(r)
  }
  def putItem(request: PutItemRequest): ZIO[DynamoDb, AwsError, PutItemResponse.ReadOnly] = ZIO.accessM(_.get.putItem(request))
  def restoreTableToPointInTime(request: RestoreTableToPointInTimeRequest): ZIO[DynamoDb, AwsError, RestoreTableToPointInTimeResponse.ReadOnly] = ZIO.accessM(_.get.restoreTableToPointInTime(request))
  def updateGlobalTableSettings(request: UpdateGlobalTableSettingsRequest): ZIO[DynamoDb, AwsError, UpdateGlobalTableSettingsResponse.ReadOnly] = ZIO.accessM(_.get.updateGlobalTableSettings(request))
  def batchExecuteStatement(request: BatchExecuteStatementRequest): ZIO[DynamoDb, AwsError, BatchExecuteStatementResponse.ReadOnly] = ZIO.accessM(_.get.batchExecuteStatement(request))
  def executeTransaction(request: ExecuteTransactionRequest): ZIO[DynamoDb, AwsError, ExecuteTransactionResponse.ReadOnly] = ZIO.accessM(_.get.executeTransaction(request))
  def listBackups(request: ListBackupsRequest): ZIO[DynamoDb, AwsError, ListBackupsResponse.ReadOnly] = ZIO.accessM(_.get.listBackups(request))
  def updateContributorInsights(request: UpdateContributorInsightsRequest): ZIO[DynamoDb, AwsError, UpdateContributorInsightsResponse.ReadOnly] = ZIO.accessM(_.get.updateContributorInsights(request))
  def describeGlobalTable(request: DescribeGlobalTableRequest): ZIO[DynamoDb, AwsError, DescribeGlobalTableResponse.ReadOnly] = ZIO.accessM(_.get.describeGlobalTable(request))
  def createTable(request: CreateTableRequest): ZIO[DynamoDb, AwsError, CreateTableResponse.ReadOnly] = ZIO.accessM(_.get.createTable(request))
  def deleteTable(request: DeleteTableRequest): ZIO[DynamoDb, AwsError, DeleteTableResponse.ReadOnly] = ZIO.accessM(_.get.deleteTable(request))
  def executeStatement(request: ExecuteStatementRequest): ZStream[DynamoDb, AwsError, Map[primitives.AttributeName, AttributeValue.ReadOnly]] = ZStream.accessStream(_.get.executeStatement(request))
  def createBackup(request: CreateBackupRequest): ZIO[DynamoDb, AwsError, CreateBackupResponse.ReadOnly] = ZIO.accessM(_.get.createBackup(request))
  def enableKinesisStreamingDestination(request: EnableKinesisStreamingDestinationRequest): ZIO[DynamoDb, AwsError, EnableKinesisStreamingDestinationResponse.ReadOnly] = ZIO.accessM(_.get.enableKinesisStreamingDestination(request))
  def describeContributorInsights(request: DescribeContributorInsightsRequest): ZIO[DynamoDb, AwsError, DescribeContributorInsightsResponse.ReadOnly] = ZIO.accessM(_.get.describeContributorInsights(request))
  def listGlobalTables(request: ListGlobalTablesRequest): ZIO[DynamoDb, AwsError, ListGlobalTablesResponse.ReadOnly] = ZIO.accessM(_.get.listGlobalTables(request))
  def batchGetItem(request: BatchGetItemRequest): ZIO[DynamoDb, AwsError, BatchGetItemResponse.ReadOnly] = ZIO.accessM(_.get.batchGetItem(request))
  def describeExport(request: DescribeExportRequest): ZIO[DynamoDb, AwsError, DescribeExportResponse.ReadOnly] = ZIO.accessM(_.get.describeExport(request))
  def listExports(request: ListExportsRequest): ZStream[DynamoDb, AwsError, ExportSummary.ReadOnly] = ZStream.accessStream(_.get.listExports(request))
  def disableKinesisStreamingDestination(request: DisableKinesisStreamingDestinationRequest): ZIO[DynamoDb, AwsError, DisableKinesisStreamingDestinationResponse.ReadOnly] = ZIO.accessM(_.get.disableKinesisStreamingDestination(request))
  def describeGlobalTableSettings(request: DescribeGlobalTableSettingsRequest): ZIO[DynamoDb, AwsError, DescribeGlobalTableSettingsResponse.ReadOnly] = ZIO.accessM(_.get.describeGlobalTableSettings(request))
  def describeTableReplicaAutoScaling(request: DescribeTableReplicaAutoScalingRequest): ZIO[DynamoDb, AwsError, DescribeTableReplicaAutoScalingResponse.ReadOnly] = ZIO.accessM(_.get.describeTableReplicaAutoScaling(request))
  def query(request: QueryRequest): zio.stream.ZStream[DynamoDb, AwsError, Map[primitives.AttributeName, AttributeValue.ReadOnly]] = ZStream.accessStream(_.get.query(request))
  def exportTableToPointInTime(request: ExportTableToPointInTimeRequest): ZIO[DynamoDb, AwsError, ExportTableToPointInTimeResponse.ReadOnly] = ZIO.accessM(_.get.exportTableToPointInTime(request))
  def listTables(request: ListTablesRequest): zio.stream.ZStream[DynamoDb, AwsError, primitives.TableName] = ZStream.accessStream(_.get.listTables(request))
  def describeTable(request: DescribeTableRequest): ZIO[DynamoDb, AwsError, DescribeTableResponse.ReadOnly] = ZIO.accessM(_.get.describeTable(request))
  def restoreTableFromBackup(request: RestoreTableFromBackupRequest): ZIO[DynamoDb, AwsError, RestoreTableFromBackupResponse.ReadOnly] = ZIO.accessM(_.get.restoreTableFromBackup(request))
  def updateContinuousBackups(request: UpdateContinuousBackupsRequest): ZIO[DynamoDb, AwsError, UpdateContinuousBackupsResponse.ReadOnly] = ZIO.accessM(_.get.updateContinuousBackups(request))
  def updateTable(request: UpdateTableRequest): ZIO[DynamoDb, AwsError, UpdateTableResponse.ReadOnly] = ZIO.accessM(_.get.updateTable(request))
  def createGlobalTable(request: CreateGlobalTableRequest): ZIO[DynamoDb, AwsError, CreateGlobalTableResponse.ReadOnly] = ZIO.accessM(_.get.createGlobalTable(request))
  def untagResource(request: UntagResourceRequest): ZIO[DynamoDb, AwsError, scala.Unit] = ZIO.accessM(_.get.untagResource(request))
  def listContributorInsights(request: ListContributorInsightsRequest): ZStream[DynamoDb, AwsError, ContributorInsightsSummary.ReadOnly] = ZStream.accessStream(_.get.listContributorInsights(request))
  def describeTimeToLive(request: DescribeTimeToLiveRequest): ZIO[DynamoDb, AwsError, DescribeTimeToLiveResponse.ReadOnly] = ZIO.accessM(_.get.describeTimeToLive(request))
  def describeEndpoints(request: DescribeEndpointsRequest): ZIO[DynamoDb, AwsError, DescribeEndpointsResponse.ReadOnly] = ZIO.accessM(_.get.describeEndpoints(request))
  def transactWriteItems(request: TransactWriteItemsRequest): ZIO[DynamoDb, AwsError, TransactWriteItemsResponse.ReadOnly] = ZIO.accessM(_.get.transactWriteItems(request))
  def deleteBackup(request: DeleteBackupRequest): ZIO[DynamoDb, AwsError, DeleteBackupResponse.ReadOnly] = ZIO.accessM(_.get.deleteBackup(request))
  def describeContinuousBackups(request: DescribeContinuousBackupsRequest): ZIO[DynamoDb, AwsError, DescribeContinuousBackupsResponse.ReadOnly] = ZIO.accessM(_.get.describeContinuousBackups(request))
  def tagResource(request: TagResourceRequest): ZIO[DynamoDb, AwsError, scala.Unit] = ZIO.accessM(_.get.tagResource(request))
  def transactGetItems(request: TransactGetItemsRequest): ZIO[DynamoDb, AwsError, TransactGetItemsResponse.ReadOnly] = ZIO.accessM(_.get.transactGetItems(request))
  def updateItem(request: UpdateItemRequest): ZIO[DynamoDb, AwsError, UpdateItemResponse.ReadOnly] = ZIO.accessM(_.get.updateItem(request))
  def updateTableReplicaAutoScaling(request: UpdateTableReplicaAutoScalingRequest): ZIO[DynamoDb, AwsError, UpdateTableReplicaAutoScalingResponse.ReadOnly] = ZIO.accessM(_.get.updateTableReplicaAutoScaling(request))
  def getItem(request: GetItemRequest): ZIO[DynamoDb, AwsError, GetItemResponse.ReadOnly] = ZIO.accessM(_.get.getItem(request))
  def updateTimeToLive(request: UpdateTimeToLiveRequest): ZIO[DynamoDb, AwsError, UpdateTimeToLiveResponse.ReadOnly] = ZIO.accessM(_.get.updateTimeToLive(request))
  def describeLimits(request: DescribeLimitsRequest): ZIO[DynamoDb, AwsError, DescribeLimitsResponse.ReadOnly] = ZIO.accessM(_.get.describeLimits(request))
  def updateGlobalTable(request: UpdateGlobalTableRequest): ZIO[DynamoDb, AwsError, UpdateGlobalTableResponse.ReadOnly] = ZIO.accessM(_.get.updateGlobalTable(request))
  def batchWriteItem(request: BatchWriteItemRequest): ZIO[DynamoDb, AwsError, BatchWriteItemResponse.ReadOnly] = ZIO.accessM(_.get.batchWriteItem(request))
  def scan(request: ScanRequest): zio.stream.ZStream[DynamoDb, AwsError, Map[primitives.AttributeName, AttributeValue.ReadOnly]] = ZStream.accessStream(_.get.scan(request))
  def listTagsOfResource(request: ListTagsOfResourceRequest): ZStream[DynamoDb, AwsError, Tag.ReadOnly] = ZStream.accessStream(_.get.listTagsOfResource(request))
  def describeBackup(request: DescribeBackupRequest): ZIO[DynamoDb, AwsError, DescribeBackupResponse.ReadOnly] = ZIO.accessM(_.get.describeBackup(request))
  def deleteItem(request: DeleteItemRequest): ZIO[DynamoDb, AwsError, DeleteItemResponse.ReadOnly] = ZIO.accessM(_.get.deleteItem(request))
  def describeKinesisStreamingDestination(request: DescribeKinesisStreamingDestinationRequest): ZIO[DynamoDb, AwsError, DescribeKinesisStreamingDestinationResponse.ReadOnly] = ZIO.accessM(_.get.describeKinesisStreamingDestination(request))
}