├── project ├── Publish.scala ├── build.properties ├── plugins.sbt └── Dependencies.scala ├── .gitignore ├── gen ├── project │ └── build.properties ├── src │ └── main │ │ └── scala │ │ └── avias │ │ └── gen │ │ ├── graph │ │ ├── NodeName.scala │ │ ├── EdgeLabel.scala │ │ ├── ServiceNode.scala │ │ └── ServiceGraph.scala │ │ ├── parse │ │ ├── service │ │ │ ├── HttpOperation.scala │ │ │ ├── ServiceOperation.scala │ │ │ ├── Service.scala │ │ │ ├── ServiceMetadata.scala │ │ │ └── ServiceShape.scala │ │ ├── paginators │ │ │ └── Paginators.scala │ │ └── waiters │ │ │ └── Waiters.scala │ │ ├── CodeGen.scala │ │ └── generator │ │ ├── Structures.scala │ │ └── Structure.scala └── build.sbt ├── .gitmodules ├── common ├── core │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── AwsData.scala ├── http4s │ └── src │ │ ├── main │ │ └── scala │ │ │ └── avias │ │ │ ├── CredentialScope.scala │ │ │ ├── SigningString.scala │ │ │ ├── CurrentTime.scala │ │ │ └── CanonicalRequest.scala │ │ └── test │ │ └── scala │ │ ├── CurrentTimeSuite.scala │ │ ├── SigningStringSuite.scala │ │ ├── PureTestSuite.scala │ │ └── CanonicalRequestSuite.scala └── circe │ └── src │ └── main │ └── scala │ └── avias │ └── DefaultCodecs.scala ├── services ├── marketplaceentitlement │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ ├── MyTrait.scala │ │ │ └── Models.scala │ ├── http4s │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ └── Http4sImpl.scala │ └── circe │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── CirceImplicits.scala ├── marketplacecommerceanalytics │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ ├── MyTrait.scala │ │ │ └── Models.scala │ ├── http4s │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ └── Http4sImpl.scala │ └── circe │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── CirceImplicits.scala ├── costandusagereport │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ ├── MyTrait.scala │ │ │ └── Models.scala │ └── http4s │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── Http4sImpl.scala ├── marketplacemeteringservice │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ ├── MyTrait.scala │ │ │ └── Models.scala │ └── http4s │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── Http4sImpl.scala ├── dynamodbstreams │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ ├── MyTrait.scala │ │ │ └── Models.scala │ └── http4s │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── Http4sImpl.scala ├── resourcegroupstaggingapi │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ ├── MyTrait.scala │ │ │ └── Models.scala │ └── http4s │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── Http4sImpl.scala ├── health │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ └── MyTrait.scala │ └── http4s │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── Http4sImpl.scala ├── shield │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ └── MyTrait.scala │ └── http4s │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── Http4sImpl.scala ├── kinesisfirehose │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ └── MyTrait.scala │ └── http4s │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── Http4sImpl.scala ├── acm │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ └── MyTrait.scala │ └── http4s │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── Http4sImpl.scala ├── athena │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ └── MyTrait.scala │ └── http4s │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── Http4sImpl.scala ├── servermigration │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ └── MyTrait.scala │ └── http4s │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── Http4sImpl.scala ├── budgets │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ └── MyTrait.scala │ └── http4s │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── Http4sImpl.scala ├── applicationautoscaling │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ └── MyTrait.scala │ └── http4s │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── Http4sImpl.scala ├── events │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ └── MyTrait.scala │ └── http4s │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── Http4sImpl.scala ├── cloudtrail │ ├── core │ │ └── src │ │ │ └── main │ │ │ └── scala │ │ │ └── avias │ │ │ └── MyTrait.scala │ └── http4s │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── Http4sImpl.scala ├── codebuild │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── rekognition │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── workspaces │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── opsworkscm │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── dynamodb │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── support │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── codestar │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── kinesisanalytics │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── datapipeline │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── kinesis │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── cloudhsm │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── discovery │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── stepfunctions │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── cognitoidentity │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── dax │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── ecr │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── emr │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── codepipeline │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── route53domains │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── appstream │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── kms │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── logs │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── config │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── ecs │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── machinelearning │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── simpleworkflow │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── inspector │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala ├── codecommit │ └── core │ │ └── src │ │ └── main │ │ └── scala │ │ └── avias │ │ └── MyTrait.scala └── directory │ └── core │ └── src │ └── main │ └── scala │ └── avias │ └── MyTrait.scala ├── LICENSE └── README.md /project/Publish.scala: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | .idea/ 3 | target/ 4 | -------------------------------------------------------------------------------- /project/build.properties: -------------------------------------------------------------------------------- 1 | sbt.version=1.1.1 2 | -------------------------------------------------------------------------------- /gen/project/build.properties: -------------------------------------------------------------------------------- 1 | sbt.version=1.1.1 2 | -------------------------------------------------------------------------------- /gen/src/main/scala/avias/gen/graph/NodeName.scala: -------------------------------------------------------------------------------- 1 | package avias.gen.graph 2 | 3 | case class NodeName(term: String) 4 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "gen/aws-sdk-java-v2"] 2 | path = gen/aws-sdk-java-v2 3 | url = https://github.com/aws/aws-sdk-java-v2 4 | -------------------------------------------------------------------------------- /gen/src/main/scala/avias/gen/parse/service/HttpOperation.scala: -------------------------------------------------------------------------------- 1 | package avias.gen.parse.service 2 | 3 | case class HttpOperation(method: String, requestUri: String) 4 | -------------------------------------------------------------------------------- /common/core/src/main/scala/avias/AwsData.scala: -------------------------------------------------------------------------------- 1 | package avias.common 2 | 3 | case class AwsData[F[_]](region: String, accessKeyId: String, secretAccessKey: String, sessionToken: Option[String]) 4 | -------------------------------------------------------------------------------- /services/marketplaceentitlement/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.marketplaceentitlement 2 | trait Amazonmarketplaceentitlement[F[_]] { def getEntitlements(input: avias.marketplaceentitlement.models.GetEntitlementsRequest): F[avias.marketplaceentitlement.models.GetEntitlementsResult] } -------------------------------------------------------------------------------- /common/http4s/src/main/scala/avias/CredentialScope.scala: -------------------------------------------------------------------------------- 1 | package avias.common.http4s 2 | 3 | case class CredentialScope(currentTime: CurrentTime, serviceType: String, awsRegion: String) { 4 | override val toString = s"${currentTime.date}/${awsRegion.toLowerCase}/${serviceType.toLowerCase}/aws4_request" 5 | } 6 | -------------------------------------------------------------------------------- /project/plugins.sbt: -------------------------------------------------------------------------------- 1 | addSbtPlugin("com.eed3si9n" % "sbt-unidoc" % "0.4.1") 2 | addSbtPlugin("com.typesafe.sbt" % "sbt-ghpages" % "0.6.2") 3 | addSbtPlugin("com.typesafe.sbt" % "sbt-site" % "1.3.2") 4 | 5 | addSbtPlugin("io.get-coursier" % "sbt-coursier" % "1.0.0") 6 | addSbtPlugin("com.geirsson" % "sbt-scalafmt" % "1.4.0") 7 | 8 | //addSbtPlugin("io.github.davidgregory084" % "sbt-tpolecat" % "0.1.3") 9 | -------------------------------------------------------------------------------- /gen/src/main/scala/avias/gen/parse/service/ServiceOperation.scala: -------------------------------------------------------------------------------- 1 | package avias.gen.parse.service 2 | 3 | case class ServiceOperation(name: String, 4 | http: HttpOperation, 5 | input: Option[StructureInstance], 6 | output: Option[StructureInstance], 7 | errors: Option[List[StructureInstance]], 8 | documentation: Option[String]) 9 | -------------------------------------------------------------------------------- /common/http4s/src/main/scala/avias/SigningString.scala: -------------------------------------------------------------------------------- 1 | package avias.common.http4s 2 | 3 | object SigningString { 4 | def stringToSign(algorithm: String, 5 | currentTime: CurrentTime, 6 | credentialScope: CredentialScope, 7 | canonicalRequestHash: String): String = { 8 | "AWS4-HMAC-" + algorithm + "\n" + 9 | currentTime.basicTime + "\n" + 10 | credentialScope + "\n" + 11 | canonicalRequestHash 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /services/marketplacecommerceanalytics/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.marketplacecommerceanalytics 2 | trait Amazonmarketplacecommerceanalytics[F[_]] { 3 | def startSupportDataExport(input: avias.marketplacecommerceanalytics.models.StartSupportDataExportRequest): F[avias.marketplacecommerceanalytics.models.StartSupportDataExportResult] 4 | def generateDataSet(input: avias.marketplacecommerceanalytics.models.GenerateDataSetRequest): F[avias.marketplacecommerceanalytics.models.GenerateDataSetResult] 5 | } -------------------------------------------------------------------------------- /gen/src/main/scala/avias/gen/graph/EdgeLabel.scala: -------------------------------------------------------------------------------- 1 | package avias.gen.graph 2 | 3 | sealed trait EdgeLabel extends Product with Serializable 4 | 5 | case object ShapeForList extends EdgeLabel 6 | case object KeyForMap extends EdgeLabel 7 | case object ValueForMap extends EdgeLabel 8 | final case class ItemForStructure(item: String, required: Boolean) 9 | extends EdgeLabel 10 | case object InputForOperation extends EdgeLabel 11 | case object OutputForOperation extends EdgeLabel 12 | case object ErrorForOperation extends EdgeLabel 13 | -------------------------------------------------------------------------------- /services/costandusagereport/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.costandusagereport 2 | trait Amazoncostandusagereport[F[_]] { 3 | def deleteReportDefinition(input: avias.costandusagereport.models.DeleteReportDefinitionRequest): F[avias.costandusagereport.models.DeleteReportDefinitionResponse] 4 | def putReportDefinition(input: avias.costandusagereport.models.PutReportDefinitionRequest): F[scala.Unit] 5 | def describeReportDefinitions(input: avias.costandusagereport.models.DescribeReportDefinitionsRequest): F[avias.costandusagereport.models.DescribeReportDefinitionsResponse] 6 | } -------------------------------------------------------------------------------- /services/marketplacemeteringservice/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.marketplacemeteringservice 2 | trait Amazonmarketplacemeteringservice[F[_]] { 3 | def batchMeterUsage(input: avias.marketplacemeteringservice.models.BatchMeterUsageRequest): F[avias.marketplacemeteringservice.models.BatchMeterUsageResult] 4 | def resolveCustomer(input: avias.marketplacemeteringservice.models.ResolveCustomerRequest): F[avias.marketplacemeteringservice.models.ResolveCustomerResult] 5 | def meterUsage(input: avias.marketplacemeteringservice.models.MeterUsageRequest): F[avias.marketplacemeteringservice.models.MeterUsageResult] 6 | } -------------------------------------------------------------------------------- /services/dynamodbstreams/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.dynamodbstreams 2 | trait Amazondynamodbstreams[F[_]] { 3 | def getShardIterator(input: avias.dynamodbstreams.models.GetShardIteratorInput): F[avias.dynamodbstreams.models.GetShardIteratorOutput] 4 | def listStreams(input: avias.dynamodbstreams.models.ListStreamsInput): F[avias.dynamodbstreams.models.ListStreamsOutput] 5 | def describeStream(input: avias.dynamodbstreams.models.DescribeStreamInput): F[avias.dynamodbstreams.models.DescribeStreamOutput] 6 | def getRecords(input: avias.dynamodbstreams.models.GetRecordsInput): F[avias.dynamodbstreams.models.GetRecordsOutput] 7 | } -------------------------------------------------------------------------------- /common/http4s/src/test/scala/CurrentTimeSuite.scala: -------------------------------------------------------------------------------- 1 | package avias.common.http4s 2 | 3 | import org.scalacheck._ 4 | import org.scalacheck.Prop._ 5 | import java.time._ 6 | 7 | object CurrentTimeSuite extends PureTestSuite { 8 | private[this] val minInstant: Instant = Instant.EPOCH 9 | private[this] val maxInstant: Instant = Instant.parse("3000-01-01T00:00:00.00Z") 10 | val genInstant = Gen.choose(minInstant.getEpochSecond, maxInstant.getEpochSecond).map(Instant.ofEpochSecond) 11 | 12 | implicit val arbitraryCurrentTime: Arbitrary[Instant] = Arbitrary(genInstant) 13 | 14 | test("date should be YYYYMMDD in UTC") { 15 | forAll { (i: Instant) => 16 | val z = i.atZone(ZoneId.of("UTC")) 17 | val c = CurrentTime.fromInstant(i) 18 | c.date ?= f"${z.getYear}${z.getMonthValue}%02d${z.getDayOfMonth}%02d" 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /common/http4s/src/test/scala/SigningStringSuite.scala: -------------------------------------------------------------------------------- 1 | package avias.common.http4s 2 | 3 | import java.time.Instant 4 | import org.scalacheck.Prop._ 5 | 6 | object SigningStringSuite extends PureTestSuite { 7 | test("signing string is correctly calculated") { 8 | val currentTime = CurrentTime.fromInstant(Instant.parse("2015-08-30T12:36:00Z")) 9 | val credentialScope = CredentialScope(currentTime, "IAM", "US-EAST-1") 10 | val canonicalRequestHash = "f536975d06c0309214f805bb90ccff089219ecd68b2577efef23edd43b7e1a59" 11 | val stringToSign = SigningString.stringToSign("SHA256", currentTime, credentialScope, canonicalRequestHash) 12 | """AWS4-HMAC-SHA256 13 | |20150830T123600Z 14 | |20150830/us-east-1/iam/aws4_request 15 | |f536975d06c0309214f805bb90ccff089219ecd68b2577efef23edd43b7e1a59""".stripMargin =? stringToSign 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /gen/src/main/scala/avias/gen/parse/paginators/Paginators.scala: -------------------------------------------------------------------------------- 1 | package avias.gen.parse.paginators 2 | 3 | import java.nio.file.Path 4 | 5 | import io.circe._ 6 | import io.circe.generic.auto._ 7 | import io.circe.parser._ 8 | 9 | import scala.io.Source 10 | 11 | case class Paginator(input_token: String, 12 | limit_key: Option[String], 13 | output_token: String, 14 | result_key: String) 15 | 16 | case class Paginators(pagination: Map[String, Paginator]) 17 | 18 | object Paginators { 19 | def fromFile(f: Path): Either[Error, Option[Paginators]] = { 20 | if (f.toFile.canRead) { 21 | val s = Source.fromFile(f.toFile) 22 | try { 23 | decode[Paginators](s.mkString).map(Option.apply) 24 | } finally { 25 | s.close() 26 | } 27 | } else Right(None) 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /services/resourcegroupstaggingapi/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.resourcegroupstaggingapi 2 | trait Amazonresourcegroupstaggingapi[F[_]] { 3 | def getResources(input: avias.resourcegroupstaggingapi.models.GetResourcesInput): F[avias.resourcegroupstaggingapi.models.GetResourcesOutput] 4 | def tagResources(input: avias.resourcegroupstaggingapi.models.TagResourcesInput): F[avias.resourcegroupstaggingapi.models.TagResourcesOutput] 5 | def getTagValues(input: avias.resourcegroupstaggingapi.models.GetTagValuesInput): F[avias.resourcegroupstaggingapi.models.GetTagValuesOutput] 6 | def getTagKeys(input: avias.resourcegroupstaggingapi.models.GetTagKeysInput): F[avias.resourcegroupstaggingapi.models.GetTagKeysOutput] 7 | def untagResources(input: avias.resourcegroupstaggingapi.models.UntagResourcesInput): F[avias.resourcegroupstaggingapi.models.UntagResourcesOutput] 8 | } -------------------------------------------------------------------------------- /services/health/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.health 2 | trait Amazonhealth[F[_]] { 3 | def describeEventDetails(input: avias.health.models.DescribeEventDetailsRequest): F[avias.health.models.DescribeEventDetailsResponse] 4 | def describeEntityAggregates(input: avias.health.models.DescribeEntityAggregatesRequest): F[avias.health.models.DescribeEntityAggregatesResponse] 5 | def describeEventAggregates(input: avias.health.models.DescribeEventAggregatesRequest): F[avias.health.models.DescribeEventAggregatesResponse] 6 | def describeAffectedEntities(input: avias.health.models.DescribeAffectedEntitiesRequest): F[avias.health.models.DescribeAffectedEntitiesResponse] 7 | def describeEventTypes(input: avias.health.models.DescribeEventTypesRequest): F[avias.health.models.DescribeEventTypesResponse] 8 | def describeEvents(input: avias.health.models.DescribeEventsRequest): F[avias.health.models.DescribeEventsResponse] 9 | } -------------------------------------------------------------------------------- /common/http4s/src/test/scala/PureTestSuite.scala: -------------------------------------------------------------------------------- 1 | package avias.common.http4s 2 | 3 | import cats.effect.IO 4 | import org.scalacheck._ 5 | import org.scalacheck.util.Pretty 6 | import minitest._ 7 | import minitest.api._ 8 | import scala.concurrent.ExecutionContext.Implicits.global 9 | 10 | trait PureTestSuite extends AbstractTestSuite { 11 | private[this] val ts = new SimpleTestSuite {} 12 | lazy val properties = ts.properties 13 | lazy val config = Test.Parameters.default 14 | 15 | def test(name: String)(f: => Prop): Unit = 16 | ts.test(name) { 17 | val result = Test.check(config, f) 18 | if (!result.passed) Asserts.fail(Pretty.pretty(result)) 19 | } 20 | 21 | def testIO(name: String)(f: => IO[Prop]): Unit = 22 | ts.testAsync(name) { 23 | f.unsafeToFuture.map { res => 24 | val result = Test.check(config, res) 25 | if (!result.passed) Asserts.fail(Pretty.pretty(result)) 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /services/shield/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.shield 2 | trait Amazonshield[F[_]] { 3 | def describeSubscription: F[avias.shield.models.DescribeSubscriptionResponse] 4 | def describeAttack(input: avias.shield.models.DescribeAttackRequest): F[avias.shield.models.DescribeAttackResponse] 5 | def deleteSubscription: F[scala.Unit] 6 | def createSubscription: F[scala.Unit] 7 | def createProtection(input: avias.shield.models.CreateProtectionRequest): F[avias.shield.models.CreateProtectionResponse] 8 | def describeProtection(input: avias.shield.models.DescribeProtectionRequest): F[avias.shield.models.DescribeProtectionResponse] 9 | def listProtections(input: avias.shield.models.ListProtectionsRequest): F[avias.shield.models.ListProtectionsResponse] 10 | def deleteProtection(input: avias.shield.models.DeleteProtectionRequest): F[scala.Unit] 11 | def listAttacks(input: avias.shield.models.ListAttacksRequest): F[avias.shield.models.ListAttacksResponse] 12 | } -------------------------------------------------------------------------------- /gen/src/main/scala/avias/gen/parse/waiters/Waiters.scala: -------------------------------------------------------------------------------- 1 | package avias.gen.parse.waiters 2 | 3 | import java.nio.file.Path 4 | 5 | import io.circe._ 6 | import io.circe.generic.auto._ 7 | import io.circe.parser._ 8 | 9 | import scala.io.Source 10 | 11 | case class Acceptor(expected: Boolean, 12 | matcher: String, 13 | state: String, 14 | argument: Option[String]) 15 | 16 | case class Waiter(delay: Int, 17 | operation: String, 18 | maxAttempts: Int, 19 | acceptors: List[Acceptor]) 20 | 21 | case class Waiters(version: Int, waiters: Map[String, Waiter]) 22 | 23 | object Waiters { 24 | def fromFile(f: Path): Either[Error, Option[Waiters]] = { 25 | if (f.toFile.canRead) { 26 | val s = Source.fromFile(f.toFile) 27 | 28 | try { 29 | decode[Waiters](s.mkString).map(Option.apply) 30 | } finally { 31 | s.close() 32 | } 33 | } else Right(None) 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /services/marketplaceentitlement/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.marketplaceentitlement.http4s 2 | import org.http4s.Method._ 3 | import avias.marketplaceentitlement.circe._ 4 | import avias.marketplaceentitlement.models 5 | class AmazonmarketplaceentitlementClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.marketplaceentitlement.Amazonmarketplaceentitlement[F] { 6 | private[this] final val ServiceType: String = "entitlement.marketplace" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("AWSMPEntitlementService") 8 | override def getEntitlements(input: avias.marketplaceentitlement.models.GetEntitlementsRequest): F[avias.marketplaceentitlement.models.GetEntitlementsResult] = avias.common.http4s.ClientUtils.doRequest[F, avias.marketplaceentitlement.models.GetEntitlementsResult, avias.marketplaceentitlement.models.GetEntitlementsRequest](client, awsData, ServiceType, ServiceAndPrefix, "GetEntitlements", POST, "/", input) 9 | } -------------------------------------------------------------------------------- /common/http4s/src/main/scala/avias/CurrentTime.scala: -------------------------------------------------------------------------------- 1 | package avias.common.http4s 2 | 3 | import cats.effect.Sync 4 | import cats.implicits._ 5 | import java.time.{Instant, ZonedDateTime, ZoneId} 6 | import java.time.format.DateTimeFormatter 7 | 8 | case class CurrentTime(now: ZonedDateTime, basicTime: String, date: String) 9 | 10 | object CurrentTime { 11 | private val utcTimezone = ZoneId.of("UTC") 12 | 13 | private val basicFormatter: DateTimeFormatter = DateTimeFormatter 14 | .ofPattern("yyyyMMdd'T'HHmmss'Z'") 15 | 16 | private val dateFormatter: DateTimeFormatter = 17 | DateTimeFormatter.ofPattern("yyyyMMdd") 18 | 19 | def fromNow[F[_]](implicit F: Sync[F]): F[CurrentTime] = { 20 | F.delay(Instant.now).map(fromInstant) 21 | } 22 | 23 | private[http4s] def fromInstant(at: Instant): CurrentTime = { 24 | val inUtc = at.atZone(utcTimezone) 25 | val basicTime = basicFormatter.format(inUtc) 26 | val date = dateFormatter.format(inUtc) 27 | CurrentTime(inUtc, basicTime, date) 28 | } 29 | } -------------------------------------------------------------------------------- /services/kinesisfirehose/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.kinesisfirehose 2 | trait Amazonkinesisfirehose[F[_]] { 3 | def updateDestination(input: avias.kinesisfirehose.models.UpdateDestinationInput): F[scala.Unit] 4 | def describeDeliveryStream(input: avias.kinesisfirehose.models.DescribeDeliveryStreamInput): F[avias.kinesisfirehose.models.DescribeDeliveryStreamOutput] 5 | def putRecord(input: avias.kinesisfirehose.models.PutRecordInput): F[avias.kinesisfirehose.models.PutRecordOutput] 6 | def listDeliveryStreams(input: avias.kinesisfirehose.models.ListDeliveryStreamsInput): F[avias.kinesisfirehose.models.ListDeliveryStreamsOutput] 7 | def createDeliveryStream(input: avias.kinesisfirehose.models.CreateDeliveryStreamInput): F[avias.kinesisfirehose.models.CreateDeliveryStreamOutput] 8 | def deleteDeliveryStream(input: avias.kinesisfirehose.models.DeleteDeliveryStreamInput): F[scala.Unit] 9 | def putRecordBatch(input: avias.kinesisfirehose.models.PutRecordBatchInput): F[avias.kinesisfirehose.models.PutRecordBatchOutput] 10 | } -------------------------------------------------------------------------------- /gen/build.sbt: -------------------------------------------------------------------------------- 1 | val CirceVersion = "0.9.1" 2 | 3 | lazy val gen = project.in(file(".")).settings( 4 | scalaOrganization := "org.typelevel", 5 | scalaVersion := "2.12.4-bin-typelevel-4", 6 | libraryDependencies += "org.scalameta" %% "scalameta" % "3.2.0", 7 | libraryDependencies ++= Seq( 8 | "io.circe" %% "circe-core", 9 | "io.circe" %% "circe-parser", 10 | "io.circe" %% "circe-generic" 11 | ).map(_ % CirceVersion), 12 | libraryDependencies += "org.typelevel" %% "cats-core" % "1.0.1", 13 | libraryDependencies += "org.typelevel" %% "cats-effect" % "0.8", 14 | libraryDependencies += "co.fs2" %% "fs2-core" % "0.10.1", 15 | libraryDependencies += "co.fs2" %% "fs2-io" % "0.10.1", 16 | libraryDependencies += "io.verizon.quiver" %% "core" % "7.0.18", 17 | //scalacOptions += "-Xstrict-patmat-analysis", 18 | //scalacOptions += "-Xlint:strict-unsealed-patmat", 19 | addSbtPlugin("org.lyranthe.sbt" % "partial-unification" % "1.1.0"), 20 | //libraryDependencies += "ch.epfl.scala" %% "scalafix-core" % "0.5.10", 21 | addCompilerPlugin("io.tryp" % "splain" % "0.2.7" cross CrossVersion.patch) 22 | ) 23 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 Gary Coady 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /common/circe/src/main/scala/avias/DefaultCodecs.scala: -------------------------------------------------------------------------------- 1 | package avias.common 2 | 3 | import io.circe._ 4 | import java.time.Instant 5 | import java.util.Base64 6 | 7 | trait DefaultCodecs { 8 | // implicit val byteBufferEncoder: Encoder[ByteBuffer] = 9 | // Encoder[String].contramap((b: ByteBuffer) => ???) 10 | // implicit val byteBufferDecoder: Decoder[ByteBuffer] = 11 | // Decoder[String].emap((s: String) => 12 | // for { 13 | // bytes <- Either.fromTry(Try(s.getBytes("UTF-8"))).leftMap(_.getMessage) 14 | // 15 | // } 16 | // DefaultCodecs.b64Encoder.encode(s.getBytes("UTF-8")).asRight[String] 17 | // ByteVector.fromBase64(s).toRight("Invalid Base64 for binary")) 18 | 19 | implicit val instantEncoder: Encoder[Instant] = 20 | Encoder[Double].contramap((i: Instant) => i.toEpochMilli.toDouble / 1000) 21 | 22 | implicit val instantDecoder: Decoder[Instant] = Decoder[Double] 23 | .map((d: Double) => Instant.ofEpochSecond(d.toLong)) 24 | .or(Decoder[String].map((s: String) => Instant.parse(s))) 25 | } 26 | 27 | object DefaultCodecs { 28 | final val b64Encoder = Base64.getEncoder 29 | final val b64Decoder = Base64.getDecoder 30 | } 31 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # avias 2 | ## Functional AWS API implementation for Scala 3 | 4 | [![Join the chat at https://gitter.im/scala-avias/Lobby](https://badges.gitter.im/scala-avias/Lobby.svg)](https://gitter.im/scala-avias/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) 5 | 6 | This library will implement most Amazon APIs with a from-scratch reimplementation, 7 | based on the underlying service metadata provided by Amazon. 8 | 9 | There are currently three main modules per-API: 10 | 11 | - core: Trait (tagless final) and classes representing the API 12 | - circe: Encoders and decoders for any JSON objects used in the API 13 | - http4s: An implementation using the http4s HTTP client 14 | 15 | # To do: 16 | 17 | - Implement protocols other than "json" 18 | - Add an FS2 module 19 | - Implement sources for credential data 20 | - Environment variables 21 | - .aws directory 22 | - AWS metadata service 23 | - ECS metadata 24 | - Change class encoding to avoid binary incompatibility issues (contraband or similar is possible) 25 | - Think about retry strategies 26 | - Add enums 27 | - Think about refined or other strategies for validating input parameters 28 | -------------------------------------------------------------------------------- /project/Dependencies.scala: -------------------------------------------------------------------------------- 1 | import sbt._ 2 | import sbt.Keys._ 3 | 4 | object Dependencies { 5 | val CirceVersion = "0.9.1" 6 | val Http4sVersion = "0.18.0" 7 | val TsecVersion = "0.0.1-M7" 8 | val monocleVersion = "1.5.0-cats" 9 | 10 | val core = Seq( 11 | libraryDependencies ++= Seq( 12 | "com.github.julien-truffaut" %% "monocle-core" % monocleVersion, 13 | "com.github.julien-truffaut" %% "monocle-macro" % monocleVersion, 14 | "com.github.julien-truffaut" %% "monocle-law" % monocleVersion % "test" 15 | ) 16 | ) 17 | 18 | val circe = Seq( 19 | libraryDependencies ++= Seq( 20 | 21 | "io.circe" %% "circe-core" % CirceVersion, 22 | "io.circe" %% "circe-generic" % CirceVersion, 23 | "io.circe" %% "circe-parser" % CirceVersion 24 | ) 25 | ) 26 | 27 | val http4s = Seq( 28 | resolvers += "jmcardon at bintray" at "https://dl.bintray.com/jmcardon/tsec", 29 | libraryDependencies ++= Seq( 30 | "io.github.jmcardon" %% "tsec-mac" % TsecVersion, 31 | "io.github.jmcardon" %% "tsec-md" % TsecVersion, 32 | "org.http4s" %% "http4s-client" % Http4sVersion, 33 | "org.http4s" %% "http4s-circe" % Http4sVersion 34 | ) 35 | ) 36 | } 37 | -------------------------------------------------------------------------------- /gen/src/main/scala/avias/gen/parse/service/Service.scala: -------------------------------------------------------------------------------- 1 | package avias.gen.parse.service 2 | 3 | import cats.implicits._ 4 | import io.circe._ 5 | import io.circe.generic.auto._ 6 | import io.circe.parser._ 7 | import io.circe.syntax._ 8 | import java.nio.file.Path 9 | 10 | import cats.effect.Sync 11 | 12 | case class StructureInstance(shape: String, documentation: Option[String]) 13 | 14 | case class Service(version: Option[String], 15 | metadata: ServiceMetadata, 16 | operations: Map[String, ServiceOperation], 17 | shapes: Map[String, ServiceShape], 18 | documentation: Option[String]) 19 | 20 | object Service { 21 | def fromFile[F[_]](f: Path)(implicit F: Sync[F]): F[Service] = { 22 | for { 23 | contents <- fs2.io.file 24 | .readAll(f, 4096) 25 | .through(fs2.text.utf8Decode) 26 | .compile 27 | .foldMonoid 28 | serviceOrError = F.pure(decode[Service](contents)) 29 | serviceOrException = serviceOrError.map(_.leftMap(err => 30 | new Throwable(s"Failed decode file: $f: ${err.toString}"))) 31 | service <- F.rethrow(serviceOrException) 32 | } yield service 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /services/marketplacecommerceanalytics/core/src/main/scala/avias/Models.scala: -------------------------------------------------------------------------------- 1 | package avias.marketplacecommerceanalytics.models 2 | final case class GenerateDataSetRequest(dataSetPublicationDate: java.time.Instant, roleNameArn: java.lang.String, snsTopicArn: java.lang.String, destinationS3BucketName: java.lang.String, dataSetType: java.lang.String, destinationS3Prefix: scala.Option[java.lang.String] = scala.None, customerDefinedValues: scala.Option[scala.collection.immutable.Map[java.lang.String, java.lang.String]] = scala.None) 3 | final case class StartSupportDataExportRequest(dataSetType: java.lang.String, roleNameArn: java.lang.String, snsTopicArn: java.lang.String, destinationS3BucketName: java.lang.String, fromDate: java.time.Instant, destinationS3Prefix: scala.Option[java.lang.String] = scala.None, customerDefinedValues: scala.Option[scala.collection.immutable.Map[java.lang.String, java.lang.String]] = scala.None) 4 | final case class MarketplaceCommerceAnalyticsException(message: scala.Option[java.lang.String] = scala.None) 5 | final case class StartSupportDataExportResult(dataSetRequestId: scala.Option[java.lang.String] = scala.None) 6 | final case class GenerateDataSetResult(dataSetRequestId: scala.Option[java.lang.String] = scala.None) -------------------------------------------------------------------------------- /services/acm/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.acm 2 | trait Amazonacm[F[_]] { 3 | def deleteCertificate(input: avias.acm.models.DeleteCertificateRequest): F[scala.Unit] 4 | def addTagsToCertificate(input: avias.acm.models.AddTagsToCertificateRequest): F[scala.Unit] 5 | def listTagsForCertificate(input: avias.acm.models.ListTagsForCertificateRequest): F[avias.acm.models.ListTagsForCertificateResponse] 6 | def removeTagsFromCertificate(input: avias.acm.models.RemoveTagsFromCertificateRequest): F[scala.Unit] 7 | def importCertificate(input: avias.acm.models.ImportCertificateRequest): F[avias.acm.models.ImportCertificateResponse] 8 | def listCertificates(input: avias.acm.models.ListCertificatesRequest): F[avias.acm.models.ListCertificatesResponse] 9 | def describeCertificate(input: avias.acm.models.DescribeCertificateRequest): F[avias.acm.models.DescribeCertificateResponse] 10 | def getCertificate(input: avias.acm.models.GetCertificateRequest): F[avias.acm.models.GetCertificateResponse] 11 | def requestCertificate(input: avias.acm.models.RequestCertificateRequest): F[avias.acm.models.RequestCertificateResponse] 12 | def resendValidationEmail(input: avias.acm.models.ResendValidationEmailRequest): F[scala.Unit] 13 | } -------------------------------------------------------------------------------- /gen/src/main/scala/avias/gen/CodeGen.scala: -------------------------------------------------------------------------------- 1 | package avias.gen 2 | 3 | import generator.{Structures, Trait} 4 | import graph._ 5 | import parse.service.ServiceMetadata 6 | import quiver.Graph 7 | 8 | import scala.meta.{Term, Type} 9 | 10 | class CodeGen(serviceName: Term.Name, 11 | packageName: Term.Name, 12 | serviceException: String, 13 | traitName: Type.Name, 14 | http4sClientName: Type.Name, 15 | serviceMetadata: ServiceMetadata, 16 | graph: Graph[ServiceNode, NodeName, EdgeLabel]) { 17 | val structures: Structures = 18 | Structures.fromGraph(serviceName, packageName, graph) 19 | 20 | def traits: Trait = Trait.fromGraph(structures, 21 | serviceName, packageName, 22 | traitName, 23 | http4sClientName, 24 | serviceMetadata.endpointPrefix, 25 | serviceMetadata.targetPrefix, 26 | graph) 27 | 28 | } 29 | 30 | object CodeGen { 31 | def apply(serviceName: String, 32 | serviceMetadata: ServiceMetadata, 33 | graph: Graph[ServiceNode, NodeName, EdgeLabel]): CodeGen = { 34 | new CodeGen( 35 | Term.Name(serviceName), 36 | Term.Name("avias"), 37 | serviceName + "Exception", 38 | Type.Name("Amazon" + serviceName), 39 | Type.Name("Amazon" + serviceName + "Client"), 40 | serviceMetadata, 41 | graph 42 | ) 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /services/athena/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.athena 2 | trait Amazonathena[F[_]] { 3 | def listQueryExecutions(input: avias.athena.models.ListQueryExecutionsInput): F[avias.athena.models.ListQueryExecutionsOutput] 4 | def getQueryExecution(input: avias.athena.models.GetQueryExecutionInput): F[avias.athena.models.GetQueryExecutionOutput] 5 | def deleteNamedQuery(input: avias.athena.models.DeleteNamedQueryInput): F[scala.Unit] 6 | def batchGetQueryExecution(input: avias.athena.models.BatchGetQueryExecutionInput): F[avias.athena.models.BatchGetQueryExecutionOutput] 7 | def getNamedQuery(input: avias.athena.models.GetNamedQueryInput): F[avias.athena.models.GetNamedQueryOutput] 8 | def stopQueryExecution(input: avias.athena.models.StopQueryExecutionInput): F[scala.Unit] 9 | def getQueryResults(input: avias.athena.models.GetQueryResultsInput): F[avias.athena.models.GetQueryResultsOutput] 10 | def createNamedQuery(input: avias.athena.models.CreateNamedQueryInput): F[avias.athena.models.CreateNamedQueryOutput] 11 | def startQueryExecution(input: avias.athena.models.StartQueryExecutionInput): F[avias.athena.models.StartQueryExecutionOutput] 12 | def batchGetNamedQuery(input: avias.athena.models.BatchGetNamedQueryInput): F[avias.athena.models.BatchGetNamedQueryOutput] 13 | def listNamedQueries(input: avias.athena.models.ListNamedQueriesInput): F[avias.athena.models.ListNamedQueriesOutput] 14 | } -------------------------------------------------------------------------------- /services/servermigration/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.servermigration 2 | trait Amazonservermigration[F[_]] { 3 | def getReplicationRuns(input: avias.servermigration.models.GetReplicationRunsRequest): F[avias.servermigration.models.GetReplicationRunsResponse] 4 | def updateReplicationJob(input: avias.servermigration.models.UpdateReplicationJobRequest): F[scala.Unit] 5 | def getServers(input: avias.servermigration.models.GetServersRequest): F[avias.servermigration.models.GetServersResponse] 6 | def getConnectors(input: avias.servermigration.models.GetConnectorsRequest): F[avias.servermigration.models.GetConnectorsResponse] 7 | def startOnDemandReplicationRun(input: avias.servermigration.models.StartOnDemandReplicationRunRequest): F[avias.servermigration.models.StartOnDemandReplicationRunResponse] 8 | def deleteReplicationJob(input: avias.servermigration.models.DeleteReplicationJobRequest): F[scala.Unit] 9 | def disassociateConnector(input: avias.servermigration.models.DisassociateConnectorRequest): F[scala.Unit] 10 | def getReplicationJobs(input: avias.servermigration.models.GetReplicationJobsRequest): F[avias.servermigration.models.GetReplicationJobsResponse] 11 | def deleteServerCatalog: F[scala.Unit] 12 | def importServerCatalog: F[scala.Unit] 13 | def createReplicationJob(input: avias.servermigration.models.CreateReplicationJobRequest): F[avias.servermigration.models.CreateReplicationJobResponse] 14 | } -------------------------------------------------------------------------------- /services/marketplaceentitlement/core/src/main/scala/avias/Models.scala: -------------------------------------------------------------------------------- 1 | package avias.marketplaceentitlement.models 2 | final case class Entitlement(productCode: scala.Option[java.lang.String] = scala.None, dimension: scala.Option[java.lang.String] = scala.None, customerIdentifier: scala.Option[java.lang.String] = scala.None, value: scala.Option[avias.marketplaceentitlement.models.EntitlementValue] = scala.None, expirationDate: scala.Option[java.time.Instant] = scala.None) 3 | final case class GetEntitlementsRequest(productCode: java.lang.String, filter: scala.Option[scala.collection.immutable.Map[java.lang.String, scala.List[java.lang.String]]] = scala.None, nextToken: scala.Option[java.lang.String] = scala.None, maxResults: scala.Option[scala.Int] = scala.None) 4 | final case class InternalServiceErrorException(message: scala.Option[java.lang.String] = scala.None) 5 | final case class EntitlementValue(integerValue: scala.Option[scala.Int] = scala.None, doubleValue: scala.Option[scala.Double] = scala.None, booleanValue: scala.Option[scala.Boolean] = scala.None, stringValue: scala.Option[java.lang.String] = scala.None) 6 | final case class InvalidParameterException(message: scala.Option[java.lang.String] = scala.None) 7 | final case class ThrottlingException(message: scala.Option[java.lang.String] = scala.None) 8 | final case class GetEntitlementsResult(entitlements: scala.Option[scala.List[avias.marketplaceentitlement.models.Entitlement]] = scala.None, nextToken: scala.Option[java.lang.String] = scala.None) -------------------------------------------------------------------------------- /services/budgets/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.budgets 2 | trait Amazonbudgets[F[_]] { 3 | def describeSubscribersForNotification(input: avias.budgets.models.DescribeSubscribersForNotificationRequest): F[avias.budgets.models.DescribeSubscribersForNotificationResponse] 4 | def createSubscriber(input: avias.budgets.models.CreateSubscriberRequest): F[scala.Unit] 5 | def deleteSubscriber(input: avias.budgets.models.DeleteSubscriberRequest): F[scala.Unit] 6 | def createBudget(input: avias.budgets.models.CreateBudgetRequest): F[scala.Unit] 7 | def describeBudget(input: avias.budgets.models.DescribeBudgetRequest): F[avias.budgets.models.DescribeBudgetResponse] 8 | def deleteBudget(input: avias.budgets.models.DeleteBudgetRequest): F[scala.Unit] 9 | def updateSubscriber(input: avias.budgets.models.UpdateSubscriberRequest): F[scala.Unit] 10 | def describeNotificationsForBudget(input: avias.budgets.models.DescribeNotificationsForBudgetRequest): F[avias.budgets.models.DescribeNotificationsForBudgetResponse] 11 | def describeBudgets(input: avias.budgets.models.DescribeBudgetsRequest): F[avias.budgets.models.DescribeBudgetsResponse] 12 | def updateBudget(input: avias.budgets.models.UpdateBudgetRequest): F[scala.Unit] 13 | def deleteNotification(input: avias.budgets.models.DeleteNotificationRequest): F[scala.Unit] 14 | def createNotification(input: avias.budgets.models.CreateNotificationRequest): F[scala.Unit] 15 | def updateNotification(input: avias.budgets.models.UpdateNotificationRequest): F[scala.Unit] 16 | } -------------------------------------------------------------------------------- /services/marketplacecommerceanalytics/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.marketplacecommerceanalytics.http4s 2 | import org.http4s.Method._ 3 | import avias.marketplacecommerceanalytics.circe._ 4 | import avias.marketplacecommerceanalytics.models 5 | class AmazonmarketplacecommerceanalyticsClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.marketplacecommerceanalytics.Amazonmarketplacecommerceanalytics[F] { 6 | private[this] final val ServiceType: String = "marketplacecommerceanalytics" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("MarketplaceCommerceAnalytics20150701") 8 | override def startSupportDataExport(input: avias.marketplacecommerceanalytics.models.StartSupportDataExportRequest): F[avias.marketplacecommerceanalytics.models.StartSupportDataExportResult] = avias.common.http4s.ClientUtils.doRequest[F, avias.marketplacecommerceanalytics.models.StartSupportDataExportResult, avias.marketplacecommerceanalytics.models.StartSupportDataExportRequest](client, awsData, ServiceType, ServiceAndPrefix, "StartSupportDataExport", POST, "/", input) 9 | override def generateDataSet(input: avias.marketplacecommerceanalytics.models.GenerateDataSetRequest): F[avias.marketplacecommerceanalytics.models.GenerateDataSetResult] = avias.common.http4s.ClientUtils.doRequest[F, avias.marketplacecommerceanalytics.models.GenerateDataSetResult, avias.marketplacecommerceanalytics.models.GenerateDataSetRequest](client, awsData, ServiceType, ServiceAndPrefix, "GenerateDataSet", POST, "/", input) 10 | } -------------------------------------------------------------------------------- /services/costandusagereport/core/src/main/scala/avias/Models.scala: -------------------------------------------------------------------------------- 1 | package avias.costandusagereport.models 2 | final case class DeleteReportDefinitionRequest(reportName: scala.Option[java.lang.String] = scala.None) 3 | final case class DescribeReportDefinitionsResponse(reportDefinitions: scala.Option[scala.List[avias.costandusagereport.models.ReportDefinition]] = scala.None, nextToken: scala.Option[java.lang.String] = scala.None) 4 | case object PutReportDefinitionResponse 5 | final case class DeleteReportDefinitionResponse(responseMessage: scala.Option[java.lang.String] = scala.None) 6 | final case class InternalErrorException(message: scala.Option[java.lang.String] = scala.None) 7 | final case class PutReportDefinitionRequest(reportDefinition: avias.costandusagereport.models.ReportDefinition) 8 | final case class ReportDefinition(additionalSchemaElements: scala.List[java.lang.String], format: java.lang.String, compression: java.lang.String, timeUnit: java.lang.String, s3Region: java.lang.String, s3Bucket: java.lang.String, s3Prefix: java.lang.String, reportName: java.lang.String, additionalArtifacts: scala.Option[scala.List[java.lang.String]] = scala.None) 9 | final case class ReportLimitReachedException(message: scala.Option[java.lang.String] = scala.None) 10 | final case class DescribeReportDefinitionsRequest(maxResults: scala.Option[scala.Int] = scala.None, nextToken: scala.Option[java.lang.String] = scala.None) 11 | final case class ValidationException(message: scala.Option[java.lang.String] = scala.None) 12 | final case class DuplicateReportNameException(message: scala.Option[java.lang.String] = scala.None) -------------------------------------------------------------------------------- /services/applicationautoscaling/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.applicationautoscaling 2 | trait Amazonapplicationautoscaling[F[_]] { 3 | def deregisterScalableTarget(input: avias.applicationautoscaling.models.DeregisterScalableTargetRequest): F[scala.Unit] 4 | def registerScalableTarget(input: avias.applicationautoscaling.models.RegisterScalableTargetRequest): F[scala.Unit] 5 | def describeScalingActivities(input: avias.applicationautoscaling.models.DescribeScalingActivitiesRequest): F[avias.applicationautoscaling.models.DescribeScalingActivitiesResponse] 6 | def deleteScalingPolicy(input: avias.applicationautoscaling.models.DeleteScalingPolicyRequest): F[scala.Unit] 7 | def deleteScheduledAction(input: avias.applicationautoscaling.models.DeleteScheduledActionRequest): F[scala.Unit] 8 | def putScalingPolicy(input: avias.applicationautoscaling.models.PutScalingPolicyRequest): F[avias.applicationautoscaling.models.PutScalingPolicyResponse] 9 | def describeScalableTargets(input: avias.applicationautoscaling.models.DescribeScalableTargetsRequest): F[avias.applicationautoscaling.models.DescribeScalableTargetsResponse] 10 | def putScheduledAction(input: avias.applicationautoscaling.models.PutScheduledActionRequest): F[scala.Unit] 11 | def describeScalingPolicies(input: avias.applicationautoscaling.models.DescribeScalingPoliciesRequest): F[avias.applicationautoscaling.models.DescribeScalingPoliciesResponse] 12 | def describeScheduledActions(input: avias.applicationautoscaling.models.DescribeScheduledActionsRequest): F[avias.applicationautoscaling.models.DescribeScheduledActionsResponse] 13 | } -------------------------------------------------------------------------------- /services/events/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.events 2 | trait Amazonevents[F[_]] { 3 | def putEvents(input: avias.events.models.PutEventsRequest): F[avias.events.models.PutEventsResponse] 4 | def removePermission(input: avias.events.models.RemovePermissionRequest): F[scala.Unit] 5 | def describeEventBus: F[avias.events.models.DescribeEventBusResponse] 6 | def describeRule(input: avias.events.models.DescribeRuleRequest): F[avias.events.models.DescribeRuleResponse] 7 | def disableRule(input: avias.events.models.DisableRuleRequest): F[scala.Unit] 8 | def testEventPattern(input: avias.events.models.TestEventPatternRequest): F[avias.events.models.TestEventPatternResponse] 9 | def enableRule(input: avias.events.models.EnableRuleRequest): F[scala.Unit] 10 | def listTargetsByRule(input: avias.events.models.ListTargetsByRuleRequest): F[avias.events.models.ListTargetsByRuleResponse] 11 | def deleteRule(input: avias.events.models.DeleteRuleRequest): F[scala.Unit] 12 | def removeTargets(input: avias.events.models.RemoveTargetsRequest): F[avias.events.models.RemoveTargetsResponse] 13 | def putRule(input: avias.events.models.PutRuleRequest): F[avias.events.models.PutRuleResponse] 14 | def putPermission(input: avias.events.models.PutPermissionRequest): F[scala.Unit] 15 | def listRuleNamesByTarget(input: avias.events.models.ListRuleNamesByTargetRequest): F[avias.events.models.ListRuleNamesByTargetResponse] 16 | def putTargets(input: avias.events.models.PutTargetsRequest): F[avias.events.models.PutTargetsResponse] 17 | def listRules(input: avias.events.models.ListRulesRequest): F[avias.events.models.ListRulesResponse] 18 | } -------------------------------------------------------------------------------- /services/cloudtrail/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.cloudtrail 2 | trait Amazoncloudtrail[F[_]] { 3 | def addTags(input: avias.cloudtrail.models.AddTagsRequest): F[scala.Unit] 4 | def listTags(input: avias.cloudtrail.models.ListTagsRequest): F[avias.cloudtrail.models.ListTagsResponse] 5 | def createTrail(input: avias.cloudtrail.models.CreateTrailRequest): F[avias.cloudtrail.models.CreateTrailResponse] 6 | def describeTrails(input: avias.cloudtrail.models.DescribeTrailsRequest): F[avias.cloudtrail.models.DescribeTrailsResponse] 7 | def startLogging(input: avias.cloudtrail.models.StartLoggingRequest): F[scala.Unit] 8 | def lookupEvents(input: avias.cloudtrail.models.LookupEventsRequest): F[avias.cloudtrail.models.LookupEventsResponse] 9 | def stopLogging(input: avias.cloudtrail.models.StopLoggingRequest): F[scala.Unit] 10 | def removeTags(input: avias.cloudtrail.models.RemoveTagsRequest): F[scala.Unit] 11 | def deleteTrail(input: avias.cloudtrail.models.DeleteTrailRequest): F[scala.Unit] 12 | def updateTrail(input: avias.cloudtrail.models.UpdateTrailRequest): F[avias.cloudtrail.models.UpdateTrailResponse] 13 | def putEventSelectors(input: avias.cloudtrail.models.PutEventSelectorsRequest): F[avias.cloudtrail.models.PutEventSelectorsResponse] 14 | def getEventSelectors(input: avias.cloudtrail.models.GetEventSelectorsRequest): F[avias.cloudtrail.models.GetEventSelectorsResponse] 15 | def getTrailStatus(input: avias.cloudtrail.models.GetTrailStatusRequest): F[avias.cloudtrail.models.GetTrailStatusResponse] 16 | def listPublicKeys(input: avias.cloudtrail.models.ListPublicKeysRequest): F[avias.cloudtrail.models.ListPublicKeysResponse] 17 | } -------------------------------------------------------------------------------- /services/codebuild/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.codebuild 2 | trait Amazoncodebuild[F[_]] { 3 | def listCuratedEnvironmentImages: F[avias.codebuild.models.ListCuratedEnvironmentImagesOutput] 4 | def createProject(input: avias.codebuild.models.CreateProjectInput): F[avias.codebuild.models.CreateProjectOutput] 5 | def listProjects(input: avias.codebuild.models.ListProjectsInput): F[avias.codebuild.models.ListProjectsOutput] 6 | def batchGetBuilds(input: avias.codebuild.models.BatchGetBuildsInput): F[avias.codebuild.models.BatchGetBuildsOutput] 7 | def createWebhook(input: avias.codebuild.models.CreateWebhookInput): F[avias.codebuild.models.CreateWebhookOutput] 8 | def listBuildsForProject(input: avias.codebuild.models.ListBuildsForProjectInput): F[avias.codebuild.models.ListBuildsForProjectOutput] 9 | def batchGetProjects(input: avias.codebuild.models.BatchGetProjectsInput): F[avias.codebuild.models.BatchGetProjectsOutput] 10 | def listBuilds(input: avias.codebuild.models.ListBuildsInput): F[avias.codebuild.models.ListBuildsOutput] 11 | def deleteWebhook(input: avias.codebuild.models.DeleteWebhookInput): F[scala.Unit] 12 | def stopBuild(input: avias.codebuild.models.StopBuildInput): F[avias.codebuild.models.StopBuildOutput] 13 | def deleteProject(input: avias.codebuild.models.DeleteProjectInput): F[scala.Unit] 14 | def batchDeleteBuilds(input: avias.codebuild.models.BatchDeleteBuildsInput): F[avias.codebuild.models.BatchDeleteBuildsOutput] 15 | def startBuild(input: avias.codebuild.models.StartBuildInput): F[avias.codebuild.models.StartBuildOutput] 16 | def updateProject(input: avias.codebuild.models.UpdateProjectInput): F[avias.codebuild.models.UpdateProjectOutput] 17 | } -------------------------------------------------------------------------------- /services/costandusagereport/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.costandusagereport.http4s 2 | import org.http4s.Method._ 3 | import avias.costandusagereport.circe._ 4 | import avias.costandusagereport.models 5 | class AmazoncostandusagereportClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.costandusagereport.Amazoncostandusagereport[F] { 6 | private[this] final val ServiceType: String = "cur" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("AWSOrigamiServiceGatewayService") 8 | override def deleteReportDefinition(input: avias.costandusagereport.models.DeleteReportDefinitionRequest): F[avias.costandusagereport.models.DeleteReportDefinitionResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.costandusagereport.models.DeleteReportDefinitionResponse, avias.costandusagereport.models.DeleteReportDefinitionRequest](client, awsData, ServiceType, ServiceAndPrefix, "DeleteReportDefinition", POST, "/", input) 9 | override def putReportDefinition(input: avias.costandusagereport.models.PutReportDefinitionRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.costandusagereport.models.PutReportDefinitionRequest](client, awsData, ServiceType, ServiceAndPrefix, "PutReportDefinition", POST, "/", input) 10 | override def describeReportDefinitions(input: avias.costandusagereport.models.DescribeReportDefinitionsRequest): F[avias.costandusagereport.models.DescribeReportDefinitionsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.costandusagereport.models.DescribeReportDefinitionsResponse, avias.costandusagereport.models.DescribeReportDefinitionsRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeReportDefinitions", POST, "/", input) 11 | } -------------------------------------------------------------------------------- /services/marketplacemeteringservice/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.marketplacemeteringservice.http4s 2 | import org.http4s.Method._ 3 | import avias.marketplacemeteringservice.circe._ 4 | import avias.marketplacemeteringservice.models 5 | class AmazonmarketplacemeteringserviceClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.marketplacemeteringservice.Amazonmarketplacemeteringservice[F] { 6 | private[this] final val ServiceType: String = "metering.marketplace" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("AWSMPMeteringService") 8 | override def batchMeterUsage(input: avias.marketplacemeteringservice.models.BatchMeterUsageRequest): F[avias.marketplacemeteringservice.models.BatchMeterUsageResult] = avias.common.http4s.ClientUtils.doRequest[F, avias.marketplacemeteringservice.models.BatchMeterUsageResult, avias.marketplacemeteringservice.models.BatchMeterUsageRequest](client, awsData, ServiceType, ServiceAndPrefix, "BatchMeterUsage", POST, "/", input) 9 | override def resolveCustomer(input: avias.marketplacemeteringservice.models.ResolveCustomerRequest): F[avias.marketplacemeteringservice.models.ResolveCustomerResult] = avias.common.http4s.ClientUtils.doRequest[F, avias.marketplacemeteringservice.models.ResolveCustomerResult, avias.marketplacemeteringservice.models.ResolveCustomerRequest](client, awsData, ServiceType, ServiceAndPrefix, "ResolveCustomer", POST, "/", input) 10 | override def meterUsage(input: avias.marketplacemeteringservice.models.MeterUsageRequest): F[avias.marketplacemeteringservice.models.MeterUsageResult] = avias.common.http4s.ClientUtils.doRequest[F, avias.marketplacemeteringservice.models.MeterUsageResult, avias.marketplacemeteringservice.models.MeterUsageRequest](client, awsData, ServiceType, ServiceAndPrefix, "MeterUsage", POST, "/", input) 11 | } -------------------------------------------------------------------------------- /services/rekognition/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.rekognition 2 | trait Amazonrekognition[F[_]] { 3 | def detectFaces(input: avias.rekognition.models.DetectFacesRequest): F[avias.rekognition.models.DetectFacesResponse] 4 | def indexFaces(input: avias.rekognition.models.IndexFacesRequest): F[avias.rekognition.models.IndexFacesResponse] 5 | def searchFaces(input: avias.rekognition.models.SearchFacesRequest): F[avias.rekognition.models.SearchFacesResponse] 6 | def recognizeCelebrities(input: avias.rekognition.models.RecognizeCelebritiesRequest): F[avias.rekognition.models.RecognizeCelebritiesResponse] 7 | def detectLabels(input: avias.rekognition.models.DetectLabelsRequest): F[avias.rekognition.models.DetectLabelsResponse] 8 | def deleteFaces(input: avias.rekognition.models.DeleteFacesRequest): F[avias.rekognition.models.DeleteFacesResponse] 9 | def deleteCollection(input: avias.rekognition.models.DeleteCollectionRequest): F[avias.rekognition.models.DeleteCollectionResponse] 10 | def listCollections(input: avias.rekognition.models.ListCollectionsRequest): F[avias.rekognition.models.ListCollectionsResponse] 11 | def getCelebrityInfo(input: avias.rekognition.models.GetCelebrityInfoRequest): F[avias.rekognition.models.GetCelebrityInfoResponse] 12 | def detectModerationLabels(input: avias.rekognition.models.DetectModerationLabelsRequest): F[avias.rekognition.models.DetectModerationLabelsResponse] 13 | def compareFaces(input: avias.rekognition.models.CompareFacesRequest): F[avias.rekognition.models.CompareFacesResponse] 14 | def listFaces(input: avias.rekognition.models.ListFacesRequest): F[avias.rekognition.models.ListFacesResponse] 15 | def searchFacesByImage(input: avias.rekognition.models.SearchFacesByImageRequest): F[avias.rekognition.models.SearchFacesByImageResponse] 16 | def createCollection(input: avias.rekognition.models.CreateCollectionRequest): F[avias.rekognition.models.CreateCollectionResponse] 17 | } -------------------------------------------------------------------------------- /services/workspaces/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.workspaces 2 | trait Amazonworkspaces[F[_]] { 3 | def terminateWorkspaces(input: avias.workspaces.models.TerminateWorkspacesRequest): F[avias.workspaces.models.TerminateWorkspacesResult] 4 | def stopWorkspaces(input: avias.workspaces.models.StopWorkspacesRequest): F[avias.workspaces.models.StopWorkspacesResult] 5 | def rebootWorkspaces(input: avias.workspaces.models.RebootWorkspacesRequest): F[avias.workspaces.models.RebootWorkspacesResult] 6 | def describeTags(input: avias.workspaces.models.DescribeTagsRequest): F[avias.workspaces.models.DescribeTagsResult] 7 | def describeWorkspaceBundles(input: avias.workspaces.models.DescribeWorkspaceBundlesRequest): F[avias.workspaces.models.DescribeWorkspaceBundlesResult] 8 | def describeWorkspacesConnectionStatus(input: avias.workspaces.models.DescribeWorkspacesConnectionStatusRequest): F[avias.workspaces.models.DescribeWorkspacesConnectionStatusResult] 9 | def describeWorkspaceDirectories(input: avias.workspaces.models.DescribeWorkspaceDirectoriesRequest): F[avias.workspaces.models.DescribeWorkspaceDirectoriesResult] 10 | def deleteTags(input: avias.workspaces.models.DeleteTagsRequest): F[scala.Unit] 11 | def createTags(input: avias.workspaces.models.CreateTagsRequest): F[scala.Unit] 12 | def describeWorkspaces(input: avias.workspaces.models.DescribeWorkspacesRequest): F[avias.workspaces.models.DescribeWorkspacesResult] 13 | def rebuildWorkspaces(input: avias.workspaces.models.RebuildWorkspacesRequest): F[avias.workspaces.models.RebuildWorkspacesResult] 14 | def createWorkspaces(input: avias.workspaces.models.CreateWorkspacesRequest): F[avias.workspaces.models.CreateWorkspacesResult] 15 | def startWorkspaces(input: avias.workspaces.models.StartWorkspacesRequest): F[avias.workspaces.models.StartWorkspacesResult] 16 | def modifyWorkspaceProperties(input: avias.workspaces.models.ModifyWorkspacePropertiesRequest): F[scala.Unit] 17 | } -------------------------------------------------------------------------------- /services/opsworkscm/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.opsworkscm 2 | trait Amazonopsworkscm[F[_]] { 3 | def describeAccountAttributes: F[avias.opsworkscm.models.DescribeAccountAttributesResponse] 4 | def updateServer(input: avias.opsworkscm.models.UpdateServerRequest): F[avias.opsworkscm.models.UpdateServerResponse] 5 | def startMaintenance(input: avias.opsworkscm.models.StartMaintenanceRequest): F[avias.opsworkscm.models.StartMaintenanceResponse] 6 | def updateServerEngineAttributes(input: avias.opsworkscm.models.UpdateServerEngineAttributesRequest): F[avias.opsworkscm.models.UpdateServerEngineAttributesResponse] 7 | def createServer(input: avias.opsworkscm.models.CreateServerRequest): F[avias.opsworkscm.models.CreateServerResponse] 8 | def describeServers(input: avias.opsworkscm.models.DescribeServersRequest): F[avias.opsworkscm.models.DescribeServersResponse] 9 | def describeNodeAssociationStatus(input: avias.opsworkscm.models.DescribeNodeAssociationStatusRequest): F[avias.opsworkscm.models.DescribeNodeAssociationStatusResponse] 10 | def describeBackups(input: avias.opsworkscm.models.DescribeBackupsRequest): F[avias.opsworkscm.models.DescribeBackupsResponse] 11 | def describeEvents(input: avias.opsworkscm.models.DescribeEventsRequest): F[avias.opsworkscm.models.DescribeEventsResponse] 12 | def createBackup(input: avias.opsworkscm.models.CreateBackupRequest): F[avias.opsworkscm.models.CreateBackupResponse] 13 | def deleteServer(input: avias.opsworkscm.models.DeleteServerRequest): F[scala.Unit] 14 | def deleteBackup(input: avias.opsworkscm.models.DeleteBackupRequest): F[scala.Unit] 15 | def associateNode(input: avias.opsworkscm.models.AssociateNodeRequest): F[avias.opsworkscm.models.AssociateNodeResponse] 16 | def disassociateNode(input: avias.opsworkscm.models.DisassociateNodeRequest): F[avias.opsworkscm.models.DisassociateNodeResponse] 17 | def restoreServer(input: avias.opsworkscm.models.RestoreServerRequest): F[scala.Unit] 18 | } -------------------------------------------------------------------------------- /common/http4s/src/main/scala/avias/CanonicalRequest.scala: -------------------------------------------------------------------------------- 1 | package avias.common.http4s 2 | 3 | import cats.effect.Sync 4 | import cats.implicits._ 5 | import org.http4s._ 6 | import scodec.bits.ByteVector 7 | import tsec.common._ 8 | import tsec.messagedigests._ 9 | import tsec.messagedigests.core._ 10 | 11 | case class CanonicalRequest(signedHeaders: String, canonicalRequest: String, hash: String) 12 | 13 | object CanonicalRequest { 14 | private def getBodyHash[F[_]: Sync, H: DigestTag](req: Request[F]): F[String] = 15 | req.body.chunks.compile.fold(ByteVector.empty) { 16 | case (bv, bytes) => bv ++ ByteVector(bytes.toArray) 17 | } map (_.toArray.hash[H].toHexString) 18 | 19 | def fromRequest[F[_]: Sync, H: DigestTag]( 20 | request: Request[F], 21 | charset: java.nio.charset.Charset = java.nio.charset.StandardCharsets.UTF_8 22 | ): F[CanonicalRequest] = { 23 | val requestMethod = request.method.name 24 | val canonicalUri = request.uri.path 25 | val canonicalQueryString = request.queryString 26 | val headers = 27 | (request.uri.host 28 | .map(h => Header("host", h.value)) 29 | .toList ::: request.headers.toList).sortBy(_.name) 30 | 31 | val canonicalHeaders = 32 | headers 33 | .map(h => s"${h.name.value.toLowerCase}:${h.value.split(" +").mkString(" ")}") 34 | .mkString("", "\n", "\n") 35 | 36 | val signedHeaders: String = 37 | headers.map(_.name.value.toLowerCase).mkString(";") 38 | 39 | getBodyHash[F, H](request) map { bodyHash: String => 40 | val canonicalRequest = 41 | requestMethod + "\n" + 42 | canonicalUri + "\n" + 43 | canonicalQueryString + "\n" + 44 | canonicalHeaders + "\n" + 45 | signedHeaders + "\n" + 46 | bodyHash 47 | 48 | CanonicalRequest( 49 | signedHeaders, 50 | canonicalRequest, 51 | canonicalRequest.getBytes(charset).hash[H].toHexString 52 | ) 53 | } 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /services/dynamodbstreams/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.dynamodbstreams.http4s 2 | import org.http4s.Method._ 3 | import avias.dynamodbstreams.circe._ 4 | import avias.dynamodbstreams.models 5 | class AmazondynamodbstreamsClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.dynamodbstreams.Amazondynamodbstreams[F] { 6 | private[this] final val ServiceType: String = "streams.dynamodb" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("DynamoDBStreams_20120810") 8 | override def getShardIterator(input: avias.dynamodbstreams.models.GetShardIteratorInput): F[avias.dynamodbstreams.models.GetShardIteratorOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.dynamodbstreams.models.GetShardIteratorOutput, avias.dynamodbstreams.models.GetShardIteratorInput](client, awsData, ServiceType, ServiceAndPrefix, "GetShardIterator", POST, "/", input) 9 | override def listStreams(input: avias.dynamodbstreams.models.ListStreamsInput): F[avias.dynamodbstreams.models.ListStreamsOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.dynamodbstreams.models.ListStreamsOutput, avias.dynamodbstreams.models.ListStreamsInput](client, awsData, ServiceType, ServiceAndPrefix, "ListStreams", POST, "/", input) 10 | override def describeStream(input: avias.dynamodbstreams.models.DescribeStreamInput): F[avias.dynamodbstreams.models.DescribeStreamOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.dynamodbstreams.models.DescribeStreamOutput, avias.dynamodbstreams.models.DescribeStreamInput](client, awsData, ServiceType, ServiceAndPrefix, "DescribeStream", POST, "/", input) 11 | override def getRecords(input: avias.dynamodbstreams.models.GetRecordsInput): F[avias.dynamodbstreams.models.GetRecordsOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.dynamodbstreams.models.GetRecordsOutput, avias.dynamodbstreams.models.GetRecordsInput](client, awsData, ServiceType, ServiceAndPrefix, "GetRecords", POST, "/", input) 12 | } -------------------------------------------------------------------------------- /services/dynamodb/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.dynamodb 2 | trait Amazondynamodb[F[_]] { 3 | def listTables(input: avias.dynamodb.models.ListTablesInput): F[avias.dynamodb.models.ListTablesOutput] 4 | def scan(input: avias.dynamodb.models.ScanInput): F[avias.dynamodb.models.ScanOutput] 5 | def batchWriteItem(input: avias.dynamodb.models.BatchWriteItemInput): F[avias.dynamodb.models.BatchWriteItemOutput] 6 | def putItem(input: avias.dynamodb.models.PutItemInput): F[avias.dynamodb.models.PutItemOutput] 7 | def deleteItem(input: avias.dynamodb.models.DeleteItemInput): F[avias.dynamodb.models.DeleteItemOutput] 8 | def untagResource(input: avias.dynamodb.models.UntagResourceInput): F[scala.Unit] 9 | def createTable(input: avias.dynamodb.models.CreateTableInput): F[avias.dynamodb.models.CreateTableOutput] 10 | def describeTimeToLive(input: avias.dynamodb.models.DescribeTimeToLiveInput): F[avias.dynamodb.models.DescribeTimeToLiveOutput] 11 | def deleteTable(input: avias.dynamodb.models.DeleteTableInput): F[avias.dynamodb.models.DeleteTableOutput] 12 | def getItem(input: avias.dynamodb.models.GetItemInput): F[avias.dynamodb.models.GetItemOutput] 13 | def updateItem(input: avias.dynamodb.models.UpdateItemInput): F[avias.dynamodb.models.UpdateItemOutput] 14 | def tagResource(input: avias.dynamodb.models.TagResourceInput): F[scala.Unit] 15 | def describeLimits: F[avias.dynamodb.models.DescribeLimitsOutput] 16 | def updateTable(input: avias.dynamodb.models.UpdateTableInput): F[avias.dynamodb.models.UpdateTableOutput] 17 | def query(input: avias.dynamodb.models.QueryInput): F[avias.dynamodb.models.QueryOutput] 18 | def listTagsOfResource(input: avias.dynamodb.models.ListTagsOfResourceInput): F[avias.dynamodb.models.ListTagsOfResourceOutput] 19 | def describeTable(input: avias.dynamodb.models.DescribeTableInput): F[avias.dynamodb.models.DescribeTableOutput] 20 | def updateTimeToLive(input: avias.dynamodb.models.UpdateTimeToLiveInput): F[avias.dynamodb.models.UpdateTimeToLiveOutput] 21 | def batchGetItem(input: avias.dynamodb.models.BatchGetItemInput): F[avias.dynamodb.models.BatchGetItemOutput] 22 | } -------------------------------------------------------------------------------- /services/support/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.support 2 | trait Amazonsupport[F[_]] { 3 | def describeServices(input: avias.support.models.DescribeServicesRequest): F[avias.support.models.DescribeServicesResponse] 4 | def describeTrustedAdvisorCheckSummaries(input: avias.support.models.DescribeTrustedAdvisorCheckSummariesRequest): F[avias.support.models.DescribeTrustedAdvisorCheckSummariesResponse] 5 | def describeTrustedAdvisorCheckRefreshStatuses(input: avias.support.models.DescribeTrustedAdvisorCheckRefreshStatusesRequest): F[avias.support.models.DescribeTrustedAdvisorCheckRefreshStatusesResponse] 6 | def describeTrustedAdvisorCheckResult(input: avias.support.models.DescribeTrustedAdvisorCheckResultRequest): F[avias.support.models.DescribeTrustedAdvisorCheckResultResponse] 7 | def addCommunicationToCase(input: avias.support.models.AddCommunicationToCaseRequest): F[avias.support.models.AddCommunicationToCaseResponse] 8 | def addAttachmentsToSet(input: avias.support.models.AddAttachmentsToSetRequest): F[avias.support.models.AddAttachmentsToSetResponse] 9 | def refreshTrustedAdvisorCheck(input: avias.support.models.RefreshTrustedAdvisorCheckRequest): F[avias.support.models.RefreshTrustedAdvisorCheckResponse] 10 | def describeSeverityLevels(input: avias.support.models.DescribeSeverityLevelsRequest): F[avias.support.models.DescribeSeverityLevelsResponse] 11 | def resolveCase(input: avias.support.models.ResolveCaseRequest): F[avias.support.models.ResolveCaseResponse] 12 | def describeCommunications(input: avias.support.models.DescribeCommunicationsRequest): F[avias.support.models.DescribeCommunicationsResponse] 13 | def describeCases(input: avias.support.models.DescribeCasesRequest): F[avias.support.models.DescribeCasesResponse] 14 | def createCase(input: avias.support.models.CreateCaseRequest): F[avias.support.models.CreateCaseResponse] 15 | def describeTrustedAdvisorChecks(input: avias.support.models.DescribeTrustedAdvisorChecksRequest): F[avias.support.models.DescribeTrustedAdvisorChecksResponse] 16 | def describeAttachment(input: avias.support.models.DescribeAttachmentRequest): F[avias.support.models.DescribeAttachmentResponse] 17 | } -------------------------------------------------------------------------------- /services/codestar/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.codestar 2 | trait Amazoncodestar[F[_]] { 3 | def associateTeamMember(input: avias.codestar.models.AssociateTeamMemberRequest): F[avias.codestar.models.AssociateTeamMemberResult] 4 | def updateTeamMember(input: avias.codestar.models.UpdateTeamMemberRequest): F[avias.codestar.models.UpdateTeamMemberResult] 5 | def createUserProfile(input: avias.codestar.models.CreateUserProfileRequest): F[avias.codestar.models.CreateUserProfileResult] 6 | def tagProject(input: avias.codestar.models.TagProjectRequest): F[avias.codestar.models.TagProjectResult] 7 | def listUserProfiles(input: avias.codestar.models.ListUserProfilesRequest): F[avias.codestar.models.ListUserProfilesResult] 8 | def listResources(input: avias.codestar.models.ListResourcesRequest): F[avias.codestar.models.ListResourcesResult] 9 | def describeUserProfile(input: avias.codestar.models.DescribeUserProfileRequest): F[avias.codestar.models.DescribeUserProfileResult] 10 | def listTagsForProject(input: avias.codestar.models.ListTagsForProjectRequest): F[avias.codestar.models.ListTagsForProjectResult] 11 | def describeProject(input: avias.codestar.models.DescribeProjectRequest): F[avias.codestar.models.DescribeProjectResult] 12 | def deleteProject(input: avias.codestar.models.DeleteProjectRequest): F[avias.codestar.models.DeleteProjectResult] 13 | def listProjects(input: avias.codestar.models.ListProjectsRequest): F[avias.codestar.models.ListProjectsResult] 14 | def updateProject(input: avias.codestar.models.UpdateProjectRequest): F[scala.Unit] 15 | def createProject(input: avias.codestar.models.CreateProjectRequest): F[avias.codestar.models.CreateProjectResult] 16 | def untagProject(input: avias.codestar.models.UntagProjectRequest): F[scala.Unit] 17 | def listTeamMembers(input: avias.codestar.models.ListTeamMembersRequest): F[avias.codestar.models.ListTeamMembersResult] 18 | def updateUserProfile(input: avias.codestar.models.UpdateUserProfileRequest): F[avias.codestar.models.UpdateUserProfileResult] 19 | def disassociateTeamMember(input: avias.codestar.models.DisassociateTeamMemberRequest): F[scala.Unit] 20 | def deleteUserProfile(input: avias.codestar.models.DeleteUserProfileRequest): F[avias.codestar.models.DeleteUserProfileResult] 21 | } -------------------------------------------------------------------------------- /common/http4s/src/test/scala/CanonicalRequestSuite.scala: -------------------------------------------------------------------------------- 1 | package avias.common.http4s 2 | 3 | import cats.effect.IO 4 | import org.http4s._ 5 | import org.scalacheck.Prop._ 6 | import tsec.messagedigests.imports._ 7 | 8 | object CanonicalRequestSuite extends PureTestSuite { 9 | testIO("appropriate signed headers are included") { 10 | val request = Request[IO]( 11 | method = Method.GET, 12 | uri = Uri.uri("https://iam.amazonaws.com/?Action=ListUsers&Version=2010-05-08")) 13 | .putHeaders( 14 | Header("Content-Type", "application/x-www-form-urlencoded; charset=utf-8"), 15 | Header("X-Amz-Date", "20150830T123600Z") 16 | ) 17 | 18 | CanonicalRequest.fromRequest[IO, SHA256](request).map { req => 19 | "content-type;host;x-amz-date" =? req.signedHeaders 20 | } 21 | } 22 | 23 | testIO("correct canonical request contents is calculated") { 24 | val request = Request[IO]( 25 | method = Method.GET, 26 | uri = Uri.uri("https://iam.amazonaws.com/?Action=ListUsers&Version=2010-05-08")) 27 | .putHeaders( 28 | Header("Content-Type", "application/x-www-form-urlencoded; charset=utf-8"), 29 | Header("X-Amz-Date", "20150830T123600Z") 30 | ) 31 | 32 | CanonicalRequest.fromRequest[IO, SHA256](request).map { req => 33 | """|GET 34 | |/ 35 | |Action=ListUsers&Version=2010-05-08 36 | |content-type:application/x-www-form-urlencoded; charset=utf-8 37 | |host:iam.amazonaws.com 38 | |x-amz-date:20150830T123600Z 39 | | 40 | |content-type;host;x-amz-date 41 | |e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855""".stripMargin =? req.canonicalRequest 42 | } 43 | } 44 | 45 | testIO("correct hash is calculated") { 46 | val request = Request[IO]( 47 | method = Method.GET, 48 | uri = Uri.uri("https://iam.amazonaws.com/?Action=ListUsers&Version=2010-05-08")) 49 | .putHeaders( 50 | Header("Content-Type", "application/x-www-form-urlencoded; charset=utf-8"), 51 | Header("X-Amz-Date", "20150830T123600Z") 52 | ) 53 | 54 | CanonicalRequest.fromRequest[IO, SHA256](request).map { req => 55 | "f536975d06c0309214f805bb90ccff089219ecd68b2577efef23edd43b7e1a59" =? req.hash 56 | } 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /services/kinesisanalytics/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.kinesisanalytics 2 | trait Amazonkinesisanalytics[F[_]] { 3 | def createApplication(input: avias.kinesisanalytics.models.CreateApplicationRequest): F[avias.kinesisanalytics.models.CreateApplicationResponse] 4 | def deleteApplicationInputProcessingConfiguration(input: avias.kinesisanalytics.models.DeleteApplicationInputProcessingConfigurationRequest): F[scala.Unit] 5 | def deleteApplicationOutput(input: avias.kinesisanalytics.models.DeleteApplicationOutputRequest): F[scala.Unit] 6 | def deleteApplicationReferenceDataSource(input: avias.kinesisanalytics.models.DeleteApplicationReferenceDataSourceRequest): F[scala.Unit] 7 | def listApplications(input: avias.kinesisanalytics.models.ListApplicationsRequest): F[avias.kinesisanalytics.models.ListApplicationsResponse] 8 | def deleteApplication(input: avias.kinesisanalytics.models.DeleteApplicationRequest): F[scala.Unit] 9 | def stopApplication(input: avias.kinesisanalytics.models.StopApplicationRequest): F[scala.Unit] 10 | def addApplicationOutput(input: avias.kinesisanalytics.models.AddApplicationOutputRequest): F[scala.Unit] 11 | def addApplicationReferenceDataSource(input: avias.kinesisanalytics.models.AddApplicationReferenceDataSourceRequest): F[scala.Unit] 12 | def updateApplication(input: avias.kinesisanalytics.models.UpdateApplicationRequest): F[scala.Unit] 13 | def describeApplication(input: avias.kinesisanalytics.models.DescribeApplicationRequest): F[avias.kinesisanalytics.models.DescribeApplicationResponse] 14 | def addApplicationInputProcessingConfiguration(input: avias.kinesisanalytics.models.AddApplicationInputProcessingConfigurationRequest): F[scala.Unit] 15 | def deleteApplicationCloudWatchLoggingOption(input: avias.kinesisanalytics.models.DeleteApplicationCloudWatchLoggingOptionRequest): F[scala.Unit] 16 | def startApplication(input: avias.kinesisanalytics.models.StartApplicationRequest): F[scala.Unit] 17 | def discoverInputSchema(input: avias.kinesisanalytics.models.DiscoverInputSchemaRequest): F[avias.kinesisanalytics.models.DiscoverInputSchemaResponse] 18 | def addApplicationInput(input: avias.kinesisanalytics.models.AddApplicationInputRequest): F[scala.Unit] 19 | def addApplicationCloudWatchLoggingOption(input: avias.kinesisanalytics.models.AddApplicationCloudWatchLoggingOptionRequest): F[scala.Unit] 20 | } -------------------------------------------------------------------------------- /services/datapipeline/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.datapipeline 2 | trait Amazondatapipeline[F[_]] { 3 | def deactivatePipeline(input: avias.datapipeline.models.DeactivatePipelineInput): F[scala.Unit] 4 | def queryObjects(input: avias.datapipeline.models.QueryObjectsInput): F[avias.datapipeline.models.QueryObjectsOutput] 5 | def putPipelineDefinition(input: avias.datapipeline.models.PutPipelineDefinitionInput): F[avias.datapipeline.models.PutPipelineDefinitionOutput] 6 | def evaluateExpression(input: avias.datapipeline.models.EvaluateExpressionInput): F[avias.datapipeline.models.EvaluateExpressionOutput] 7 | def reportTaskRunnerHeartbeat(input: avias.datapipeline.models.ReportTaskRunnerHeartbeatInput): F[avias.datapipeline.models.ReportTaskRunnerHeartbeatOutput] 8 | def getPipelineDefinition(input: avias.datapipeline.models.GetPipelineDefinitionInput): F[avias.datapipeline.models.GetPipelineDefinitionOutput] 9 | def reportTaskProgress(input: avias.datapipeline.models.ReportTaskProgressInput): F[avias.datapipeline.models.ReportTaskProgressOutput] 10 | def validatePipelineDefinition(input: avias.datapipeline.models.ValidatePipelineDefinitionInput): F[avias.datapipeline.models.ValidatePipelineDefinitionOutput] 11 | def deletePipeline(input: avias.datapipeline.models.DeletePipelineInput): F[scala.Unit] 12 | def pollForTask(input: avias.datapipeline.models.PollForTaskInput): F[avias.datapipeline.models.PollForTaskOutput] 13 | def activatePipeline(input: avias.datapipeline.models.ActivatePipelineInput): F[scala.Unit] 14 | def setStatus(input: avias.datapipeline.models.SetStatusInput): F[scala.Unit] 15 | def setTaskStatus(input: avias.datapipeline.models.SetTaskStatusInput): F[scala.Unit] 16 | def describeObjects(input: avias.datapipeline.models.DescribeObjectsInput): F[avias.datapipeline.models.DescribeObjectsOutput] 17 | def removeTags(input: avias.datapipeline.models.RemoveTagsInput): F[scala.Unit] 18 | def addTags(input: avias.datapipeline.models.AddTagsInput): F[scala.Unit] 19 | def describePipelines(input: avias.datapipeline.models.DescribePipelinesInput): F[avias.datapipeline.models.DescribePipelinesOutput] 20 | def listPipelines(input: avias.datapipeline.models.ListPipelinesInput): F[avias.datapipeline.models.ListPipelinesOutput] 21 | def createPipeline(input: avias.datapipeline.models.CreatePipelineInput): F[avias.datapipeline.models.CreatePipelineOutput] 22 | } -------------------------------------------------------------------------------- /services/marketplacemeteringservice/core/src/main/scala/avias/Models.scala: -------------------------------------------------------------------------------- 1 | package avias.marketplacemeteringservice.models 2 | final case class TimestampOutOfBoundsException(message: scala.Option[java.lang.String] = scala.None) 3 | final case class UsageRecord(timestamp: java.time.Instant, customerIdentifier: java.lang.String, dimension: java.lang.String, quantity: scala.Int) 4 | final case class InvalidUsageDimensionException(message: scala.Option[java.lang.String] = scala.None) 5 | final case class InvalidCustomerIdentifierException(message: scala.Option[java.lang.String] = scala.None) 6 | final case class ExpiredTokenException(message: scala.Option[java.lang.String] = scala.None) 7 | final case class MeterUsageRequest(timestamp: java.time.Instant, usageQuantity: scala.Int, dryRun: scala.Boolean, usageDimension: java.lang.String, productCode: java.lang.String) 8 | final case class ResolveCustomerRequest(registrationToken: java.lang.String) 9 | final case class BatchMeterUsageResult(results: scala.Option[scala.List[avias.marketplacemeteringservice.models.UsageRecordResult]] = scala.None, unprocessedRecords: scala.Option[scala.List[avias.marketplacemeteringservice.models.UsageRecord]] = scala.None) 10 | final case class InternalServiceErrorException(message: scala.Option[java.lang.String] = scala.None) 11 | final case class DuplicateRequestException(message: scala.Option[java.lang.String] = scala.None) 12 | final case class ThrottlingException(message: scala.Option[java.lang.String] = scala.None) 13 | final case class BatchMeterUsageRequest(usageRecords: scala.List[avias.marketplacemeteringservice.models.UsageRecord], productCode: java.lang.String) 14 | final case class InvalidTokenException(message: scala.Option[java.lang.String] = scala.None) 15 | final case class InvalidProductCodeException(message: scala.Option[java.lang.String] = scala.None) 16 | final case class ResolveCustomerResult(customerIdentifier: scala.Option[java.lang.String] = scala.None, productCode: scala.Option[java.lang.String] = scala.None) 17 | final case class MeterUsageResult(meteringRecordId: scala.Option[java.lang.String] = scala.None) 18 | final case class InvalidEndpointRegionException(message: scala.Option[java.lang.String] = scala.None) 19 | final case class UsageRecordResult(usageRecord: scala.Option[avias.marketplacemeteringservice.models.UsageRecord] = scala.None, meteringRecordId: scala.Option[java.lang.String] = scala.None, status: scala.Option[java.lang.String] = scala.None) -------------------------------------------------------------------------------- /services/kinesis/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.kinesis 2 | trait Amazonkinesis[F[_]] { 3 | def putRecord(input: avias.kinesis.models.PutRecordInput): F[avias.kinesis.models.PutRecordOutput] 4 | def describeStream(input: avias.kinesis.models.DescribeStreamInput): F[avias.kinesis.models.DescribeStreamOutput] 5 | def addTagsToStream(input: avias.kinesis.models.AddTagsToStreamInput): F[scala.Unit] 6 | def getShardIterator(input: avias.kinesis.models.GetShardIteratorInput): F[avias.kinesis.models.GetShardIteratorOutput] 7 | def listTagsForStream(input: avias.kinesis.models.ListTagsForStreamInput): F[avias.kinesis.models.ListTagsForStreamOutput] 8 | def startStreamEncryption(input: avias.kinesis.models.StartStreamEncryptionInput): F[scala.Unit] 9 | def putRecords(input: avias.kinesis.models.PutRecordsInput): F[avias.kinesis.models.PutRecordsOutput] 10 | def enableEnhancedMonitoring(input: avias.kinesis.models.EnableEnhancedMonitoringInput): F[avias.kinesis.models.EnhancedMonitoringOutput] 11 | def stopStreamEncryption(input: avias.kinesis.models.StopStreamEncryptionInput): F[scala.Unit] 12 | def describeLimits: F[avias.kinesis.models.DescribeLimitsOutput] 13 | def getRecords(input: avias.kinesis.models.GetRecordsInput): F[avias.kinesis.models.GetRecordsOutput] 14 | def mergeShards(input: avias.kinesis.models.MergeShardsInput): F[scala.Unit] 15 | def createStream(input: avias.kinesis.models.CreateStreamInput): F[scala.Unit] 16 | def listStreams(input: avias.kinesis.models.ListStreamsInput): F[avias.kinesis.models.ListStreamsOutput] 17 | def increaseStreamRetentionPeriod(input: avias.kinesis.models.IncreaseStreamRetentionPeriodInput): F[scala.Unit] 18 | def describeStreamSummary(input: avias.kinesis.models.DescribeStreamSummaryInput): F[avias.kinesis.models.DescribeStreamSummaryOutput] 19 | def disableEnhancedMonitoring(input: avias.kinesis.models.DisableEnhancedMonitoringInput): F[avias.kinesis.models.EnhancedMonitoringOutput] 20 | def deleteStream(input: avias.kinesis.models.DeleteStreamInput): F[scala.Unit] 21 | def removeTagsFromStream(input: avias.kinesis.models.RemoveTagsFromStreamInput): F[scala.Unit] 22 | def splitShard(input: avias.kinesis.models.SplitShardInput): F[scala.Unit] 23 | def decreaseStreamRetentionPeriod(input: avias.kinesis.models.DecreaseStreamRetentionPeriodInput): F[scala.Unit] 24 | def updateShardCount(input: avias.kinesis.models.UpdateShardCountInput): F[avias.kinesis.models.UpdateShardCountOutput] 25 | } -------------------------------------------------------------------------------- /services/cloudhsm/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.cloudhsm 2 | trait Amazoncloudhsm[F[_]] { 3 | def deleteLunaClient(input: avias.cloudhsm.models.DeleteLunaClientRequest): F[avias.cloudhsm.models.DeleteLunaClientResponse] 4 | def describeHapg(input: avias.cloudhsm.models.DescribeHapgRequest): F[avias.cloudhsm.models.DescribeHapgResponse] 5 | def describeLunaClient(input: avias.cloudhsm.models.DescribeLunaClientRequest): F[avias.cloudhsm.models.DescribeLunaClientResponse] 6 | def modifyLunaClient(input: avias.cloudhsm.models.ModifyLunaClientRequest): F[avias.cloudhsm.models.ModifyLunaClientResponse] 7 | def createHapg(input: avias.cloudhsm.models.CreateHapgRequest): F[avias.cloudhsm.models.CreateHapgResponse] 8 | def addTagsToResource(input: avias.cloudhsm.models.AddTagsToResourceRequest): F[avias.cloudhsm.models.AddTagsToResourceResponse] 9 | def listHapgs(input: avias.cloudhsm.models.ListHapgsRequest): F[avias.cloudhsm.models.ListHapgsResponse] 10 | def listLunaClients(input: avias.cloudhsm.models.ListLunaClientsRequest): F[avias.cloudhsm.models.ListLunaClientsResponse] 11 | def deleteHapg(input: avias.cloudhsm.models.DeleteHapgRequest): F[avias.cloudhsm.models.DeleteHapgResponse] 12 | def getConfig(input: avias.cloudhsm.models.GetConfigRequest): F[avias.cloudhsm.models.GetConfigResponse] 13 | def listTagsForResource(input: avias.cloudhsm.models.ListTagsForResourceRequest): F[avias.cloudhsm.models.ListTagsForResourceResponse] 14 | def listAvailableZones: F[avias.cloudhsm.models.ListAvailableZonesResponse] 15 | def modifyHapg(input: avias.cloudhsm.models.ModifyHapgRequest): F[avias.cloudhsm.models.ModifyHapgResponse] 16 | def removeTagsFromResource(input: avias.cloudhsm.models.RemoveTagsFromResourceRequest): F[avias.cloudhsm.models.RemoveTagsFromResourceResponse] 17 | def listHsms(input: avias.cloudhsm.models.ListHsmsRequest): F[avias.cloudhsm.models.ListHsmsResponse] 18 | def deleteHsm(input: avias.cloudhsm.models.DeleteHsmRequest): F[avias.cloudhsm.models.DeleteHsmResponse] 19 | def createHsm(input: avias.cloudhsm.models.CreateHsmRequest): F[avias.cloudhsm.models.CreateHsmResponse] 20 | def createLunaClient(input: avias.cloudhsm.models.CreateLunaClientRequest): F[avias.cloudhsm.models.CreateLunaClientResponse] 21 | def describeHsm(input: avias.cloudhsm.models.DescribeHsmRequest): F[avias.cloudhsm.models.DescribeHsmResponse] 22 | def modifyHsm(input: avias.cloudhsm.models.ModifyHsmRequest): F[avias.cloudhsm.models.ModifyHsmResponse] 23 | } -------------------------------------------------------------------------------- /services/discovery/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.discovery 2 | trait Amazondiscovery[F[_]] { 3 | def listConfigurations(input: avias.discovery.models.ListConfigurationsRequest): F[avias.discovery.models.ListConfigurationsResponse] 4 | def listServerNeighbors(input: avias.discovery.models.ListServerNeighborsRequest): F[avias.discovery.models.ListServerNeighborsResponse] 5 | def deleteTags(input: avias.discovery.models.DeleteTagsRequest): F[scala.Unit] 6 | def describeAgents(input: avias.discovery.models.DescribeAgentsRequest): F[avias.discovery.models.DescribeAgentsResponse] 7 | def createTags(input: avias.discovery.models.CreateTagsRequest): F[scala.Unit] 8 | def describeTags(input: avias.discovery.models.DescribeTagsRequest): F[avias.discovery.models.DescribeTagsResponse] 9 | def describeExportConfigurations(input: avias.discovery.models.DescribeExportConfigurationsRequest): F[avias.discovery.models.DescribeExportConfigurationsResponse] 10 | def updateApplication(input: avias.discovery.models.UpdateApplicationRequest): F[scala.Unit] 11 | def startDataCollectionByAgentIds(input: avias.discovery.models.StartDataCollectionByAgentIdsRequest): F[avias.discovery.models.StartDataCollectionByAgentIdsResponse] 12 | def createApplication(input: avias.discovery.models.CreateApplicationRequest): F[avias.discovery.models.CreateApplicationResponse] 13 | def startExportTask(input: avias.discovery.models.StartExportTaskRequest): F[avias.discovery.models.StartExportTaskResponse] 14 | def exportConfigurations: F[avias.discovery.models.ExportConfigurationsResponse] 15 | def associateConfigurationItemsToApplication(input: avias.discovery.models.AssociateConfigurationItemsToApplicationRequest): F[scala.Unit] 16 | def stopDataCollectionByAgentIds(input: avias.discovery.models.StopDataCollectionByAgentIdsRequest): F[avias.discovery.models.StopDataCollectionByAgentIdsResponse] 17 | def disassociateConfigurationItemsFromApplication(input: avias.discovery.models.DisassociateConfigurationItemsFromApplicationRequest): F[scala.Unit] 18 | def describeExportTasks(input: avias.discovery.models.DescribeExportTasksRequest): F[avias.discovery.models.DescribeExportTasksResponse] 19 | def getDiscoverySummary: F[avias.discovery.models.GetDiscoverySummaryResponse] 20 | def describeConfigurations(input: avias.discovery.models.DescribeConfigurationsRequest): F[avias.discovery.models.DescribeConfigurationsResponse] 21 | def deleteApplications(input: avias.discovery.models.DeleteApplicationsRequest): F[scala.Unit] 22 | } -------------------------------------------------------------------------------- /gen/src/main/scala/avias/gen/parse/service/ServiceMetadata.scala: -------------------------------------------------------------------------------- 1 | package avias.gen.parse.service 2 | 3 | import cats.implicits._ 4 | import io.circe.Decoder 5 | 6 | sealed abstract class ServiceProtocol extends Product with Serializable 7 | 8 | object ServiceProtocol { 9 | implicit val decodeServiceProtocol: Decoder[ServiceProtocol] = { 10 | List[Decoder[ServiceProtocol]]( 11 | Decoder[JsonProtocol.type].widen, 12 | Decoder[RestJsonProtocol.type].widen, 13 | Decoder[QueryProtocol.type].widen, 14 | Decoder[RestXmlProtocol.type].widen, 15 | Decoder[Ec2Protocol.type].widen 16 | ).reduceLeft(_ or _) 17 | } 18 | } 19 | 20 | case object JsonProtocol extends ServiceProtocol { 21 | implicit val jsonDecoder: Decoder[JsonProtocol.type] = Decoder[String].emap { 22 | s => Either.fromOption({ if (s == "json") Some(JsonProtocol) else None }, s + " is not json") 23 | } 24 | } 25 | 26 | case object RestJsonProtocol extends ServiceProtocol { 27 | implicit val restJsonDecoder: Decoder[RestJsonProtocol.type] = Decoder[String].emap { 28 | s => Either.fromOption({ if (s == "rest-json") Some(RestJsonProtocol) else None }, s + " is not rest-json") 29 | } 30 | } 31 | 32 | case object QueryProtocol extends ServiceProtocol { 33 | implicit val queryDecoder: Decoder[QueryProtocol.type] = Decoder[String].emap { 34 | s => Either.fromOption({ if (s == "query") Some(QueryProtocol) else None }, s + " is not query") 35 | } 36 | } 37 | 38 | case object RestXmlProtocol extends ServiceProtocol { 39 | implicit val restXmlDecoder: Decoder[RestXmlProtocol.type] = Decoder[String].emap { 40 | s => Either.fromOption({ if (s == "rest-xml") Some(RestXmlProtocol) else None }, s + " is not rest-xml") 41 | } 42 | } 43 | 44 | case object Ec2Protocol extends ServiceProtocol { 45 | implicit val ec2Decoder: Decoder[Ec2Protocol.type] = Decoder[String].emap { 46 | s => Either.fromOption({ if (s == "ec2") Some(Ec2Protocol) else None }, s + " is not ec2") 47 | } 48 | } 49 | 50 | 51 | 52 | 53 | case class ServiceMetadata(apiVersion: String, 54 | endpointPrefix: String, 55 | jsonVersion: Option[String], 56 | protocol: ServiceProtocol, 57 | serviceAbbreviation: Option[String], 58 | serviceFullName: String, 59 | signatureVersion: String, 60 | targetPrefix: Option[String], 61 | uid: Option[String]) 62 | -------------------------------------------------------------------------------- /gen/src/main/scala/avias/gen/generator/Structures.scala: -------------------------------------------------------------------------------- 1 | package avias.gen.generator 2 | 3 | import avias.gen.graph._ 4 | import quiver.{Context, Graph} 5 | 6 | import scala.meta.Term 7 | import scala.meta.quasiquotes._ 8 | 9 | case class Structures(servicePackageName: Term.Select, 10 | items: List[Structure]) { 11 | private val map = items.groupBy(_.typeName).map { case (k, v) => k -> v.head } 12 | 13 | def getByName(typeName: String): Option[Structure] = map.get(typeName) 14 | 15 | def circeImplicits = q""" 16 | package $servicePackageName { 17 | 18 | import cats.implicits._ 19 | import io.circe._ 20 | import io.circe.syntax._ 21 | 22 | object circe extends avias.common.DefaultCodecs { 23 | ..${items.map(_.encoder)} 24 | ..${items.map(_.decoder)} 25 | } 26 | } 27 | """ 28 | 29 | def modelDefinitions = 30 | q""" 31 | package $servicePackageName.models { 32 | ..${items.map(_.definition)} 33 | } 34 | """ 35 | } 36 | 37 | object Structures { 38 | def fromGraph(serviceName: Term.Name, 39 | packageName: Term.Ref, 40 | graph: Graph[ServiceNode, NodeName, EdgeLabel]): Structures = { 41 | val serviceTraitName = Term.Name(serviceName.value.replace("-", "_")) 42 | val servicePackageName = Term.Select(packageName, serviceTraitName) 43 | val commonPackageName = Term.Select(packageName, Term.Name("common")) 44 | val modelsPackageName = Term.Select(servicePackageName, Term.Name("models")) 45 | val circePackageName = Term.Select(servicePackageName, Term.Name("circe")) 46 | 47 | val structures = graph.contexts 48 | .collect({ 49 | case Context(in, e: StructureNode, label, out) => 50 | val isError = in.forall(_._1 == "error") 51 | 52 | val requiredParams = out.collect { 53 | case (ItemForStructure(item, true), v: ShapeNode) => 54 | val tpe = v.getType(modelsPackageName.toString, graph) 55 | StructureField(item, tpe, false) 56 | } 57 | 58 | val optionalParams = out.collect { 59 | case (ItemForStructure(item, false), v: ShapeNode) => 60 | val tpe = v.getType(modelsPackageName.toString, graph) 61 | StructureField(item, tpe, true) 62 | } 63 | 64 | val allParams = (requiredParams ++ optionalParams).toList 65 | Structure(modelsPackageName.toString, label.term, isError, allParams) 66 | }).toList 67 | 68 | Structures(servicePackageName, structures) 69 | } 70 | } 71 | -------------------------------------------------------------------------------- /services/stepfunctions/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.stepfunctions 2 | trait Amazonstepfunctions[F[_]] { 3 | def listStateMachines(input: avias.stepfunctions.models.ListStateMachinesInput): F[avias.stepfunctions.models.ListStateMachinesOutput] 4 | def createActivity(input: avias.stepfunctions.models.CreateActivityInput): F[avias.stepfunctions.models.CreateActivityOutput] 5 | def startExecution(input: avias.stepfunctions.models.StartExecutionInput): F[avias.stepfunctions.models.StartExecutionOutput] 6 | def sendTaskFailure(input: avias.stepfunctions.models.SendTaskFailureInput): F[scala.Unit] 7 | def describeActivity(input: avias.stepfunctions.models.DescribeActivityInput): F[avias.stepfunctions.models.DescribeActivityOutput] 8 | def stopExecution(input: avias.stepfunctions.models.StopExecutionInput): F[avias.stepfunctions.models.StopExecutionOutput] 9 | def deleteActivity(input: avias.stepfunctions.models.DeleteActivityInput): F[scala.Unit] 10 | def describeStateMachineForExecution(input: avias.stepfunctions.models.DescribeStateMachineForExecutionInput): F[avias.stepfunctions.models.DescribeStateMachineForExecutionOutput] 11 | def getExecutionHistory(input: avias.stepfunctions.models.GetExecutionHistoryInput): F[avias.stepfunctions.models.GetExecutionHistoryOutput] 12 | def listActivities(input: avias.stepfunctions.models.ListActivitiesInput): F[avias.stepfunctions.models.ListActivitiesOutput] 13 | def deleteStateMachine(input: avias.stepfunctions.models.DeleteStateMachineInput): F[scala.Unit] 14 | def updateStateMachine(input: avias.stepfunctions.models.UpdateStateMachineInput): F[avias.stepfunctions.models.UpdateStateMachineOutput] 15 | def createStateMachine(input: avias.stepfunctions.models.CreateStateMachineInput): F[avias.stepfunctions.models.CreateStateMachineOutput] 16 | def getActivityTask(input: avias.stepfunctions.models.GetActivityTaskInput): F[avias.stepfunctions.models.GetActivityTaskOutput] 17 | def sendTaskHeartbeat(input: avias.stepfunctions.models.SendTaskHeartbeatInput): F[scala.Unit] 18 | def listExecutions(input: avias.stepfunctions.models.ListExecutionsInput): F[avias.stepfunctions.models.ListExecutionsOutput] 19 | def sendTaskSuccess(input: avias.stepfunctions.models.SendTaskSuccessInput): F[scala.Unit] 20 | def describeStateMachine(input: avias.stepfunctions.models.DescribeStateMachineInput): F[avias.stepfunctions.models.DescribeStateMachineOutput] 21 | def describeExecution(input: avias.stepfunctions.models.DescribeExecutionInput): F[avias.stepfunctions.models.DescribeExecutionOutput] 22 | } -------------------------------------------------------------------------------- /services/cognitoidentity/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.cognitoidentity 2 | trait Amazoncognitoidentity[F[_]] { 3 | def updateIdentityPool(input: avias.cognitoidentity.models.IdentityPool): F[avias.cognitoidentity.models.IdentityPool] 4 | def deleteIdentities(input: avias.cognitoidentity.models.DeleteIdentitiesInput): F[avias.cognitoidentity.models.DeleteIdentitiesResponse] 5 | def getId(input: avias.cognitoidentity.models.GetIdInput): F[avias.cognitoidentity.models.GetIdResponse] 6 | def getIdentityPoolRoles(input: avias.cognitoidentity.models.GetIdentityPoolRolesInput): F[avias.cognitoidentity.models.GetIdentityPoolRolesResponse] 7 | def unlinkDeveloperIdentity(input: avias.cognitoidentity.models.UnlinkDeveloperIdentityInput): F[scala.Unit] 8 | def unlinkIdentity(input: avias.cognitoidentity.models.UnlinkIdentityInput): F[scala.Unit] 9 | def getOpenIdTokenForDeveloperIdentity(input: avias.cognitoidentity.models.GetOpenIdTokenForDeveloperIdentityInput): F[avias.cognitoidentity.models.GetOpenIdTokenForDeveloperIdentityResponse] 10 | def listIdentities(input: avias.cognitoidentity.models.ListIdentitiesInput): F[avias.cognitoidentity.models.ListIdentitiesResponse] 11 | def createIdentityPool(input: avias.cognitoidentity.models.CreateIdentityPoolInput): F[avias.cognitoidentity.models.IdentityPool] 12 | def setIdentityPoolRoles(input: avias.cognitoidentity.models.SetIdentityPoolRolesInput): F[scala.Unit] 13 | def lookupDeveloperIdentity(input: avias.cognitoidentity.models.LookupDeveloperIdentityInput): F[avias.cognitoidentity.models.LookupDeveloperIdentityResponse] 14 | def mergeDeveloperIdentities(input: avias.cognitoidentity.models.MergeDeveloperIdentitiesInput): F[avias.cognitoidentity.models.MergeDeveloperIdentitiesResponse] 15 | def describeIdentity(input: avias.cognitoidentity.models.DescribeIdentityInput): F[avias.cognitoidentity.models.IdentityDescription] 16 | def describeIdentityPool(input: avias.cognitoidentity.models.DescribeIdentityPoolInput): F[avias.cognitoidentity.models.IdentityPool] 17 | def getCredentialsForIdentity(input: avias.cognitoidentity.models.GetCredentialsForIdentityInput): F[avias.cognitoidentity.models.GetCredentialsForIdentityResponse] 18 | def listIdentityPools(input: avias.cognitoidentity.models.ListIdentityPoolsInput): F[avias.cognitoidentity.models.ListIdentityPoolsResponse] 19 | def getOpenIdToken(input: avias.cognitoidentity.models.GetOpenIdTokenInput): F[avias.cognitoidentity.models.GetOpenIdTokenResponse] 20 | def deleteIdentityPool(input: avias.cognitoidentity.models.DeleteIdentityPoolInput): F[scala.Unit] 21 | } -------------------------------------------------------------------------------- /services/resourcegroupstaggingapi/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.resourcegroupstaggingapi.http4s 2 | import org.http4s.Method._ 3 | import avias.resourcegroupstaggingapi.circe._ 4 | import avias.resourcegroupstaggingapi.models 5 | class AmazonresourcegroupstaggingapiClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.resourcegroupstaggingapi.Amazonresourcegroupstaggingapi[F] { 6 | private[this] final val ServiceType: String = "tagging" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("ResourceGroupsTaggingAPI_20170126") 8 | override def getResources(input: avias.resourcegroupstaggingapi.models.GetResourcesInput): F[avias.resourcegroupstaggingapi.models.GetResourcesOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.resourcegroupstaggingapi.models.GetResourcesOutput, avias.resourcegroupstaggingapi.models.GetResourcesInput](client, awsData, ServiceType, ServiceAndPrefix, "GetResources", POST, "/", input) 9 | override def tagResources(input: avias.resourcegroupstaggingapi.models.TagResourcesInput): F[avias.resourcegroupstaggingapi.models.TagResourcesOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.resourcegroupstaggingapi.models.TagResourcesOutput, avias.resourcegroupstaggingapi.models.TagResourcesInput](client, awsData, ServiceType, ServiceAndPrefix, "TagResources", POST, "/", input) 10 | override def getTagValues(input: avias.resourcegroupstaggingapi.models.GetTagValuesInput): F[avias.resourcegroupstaggingapi.models.GetTagValuesOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.resourcegroupstaggingapi.models.GetTagValuesOutput, avias.resourcegroupstaggingapi.models.GetTagValuesInput](client, awsData, ServiceType, ServiceAndPrefix, "GetTagValues", POST, "/", input) 11 | override def getTagKeys(input: avias.resourcegroupstaggingapi.models.GetTagKeysInput): F[avias.resourcegroupstaggingapi.models.GetTagKeysOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.resourcegroupstaggingapi.models.GetTagKeysOutput, avias.resourcegroupstaggingapi.models.GetTagKeysInput](client, awsData, ServiceType, ServiceAndPrefix, "GetTagKeys", POST, "/", input) 12 | override def untagResources(input: avias.resourcegroupstaggingapi.models.UntagResourcesInput): F[avias.resourcegroupstaggingapi.models.UntagResourcesOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.resourcegroupstaggingapi.models.UntagResourcesOutput, avias.resourcegroupstaggingapi.models.UntagResourcesInput](client, awsData, ServiceType, ServiceAndPrefix, "UntagResources", POST, "/", input) 13 | } -------------------------------------------------------------------------------- /services/dax/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.dax 2 | trait Amazondax[F[_]] { 3 | def describeClusters(input: avias.dax.models.DescribeClustersRequest): F[avias.dax.models.DescribeClustersResponse] 4 | def describeEvents(input: avias.dax.models.DescribeEventsRequest): F[avias.dax.models.DescribeEventsResponse] 5 | def rebootNode(input: avias.dax.models.RebootNodeRequest): F[avias.dax.models.RebootNodeResponse] 6 | def tagResource(input: avias.dax.models.TagResourceRequest): F[avias.dax.models.TagResourceResponse] 7 | def createSubnetGroup(input: avias.dax.models.CreateSubnetGroupRequest): F[avias.dax.models.CreateSubnetGroupResponse] 8 | def describeParameterGroups(input: avias.dax.models.DescribeParameterGroupsRequest): F[avias.dax.models.DescribeParameterGroupsResponse] 9 | def untagResource(input: avias.dax.models.UntagResourceRequest): F[avias.dax.models.UntagResourceResponse] 10 | def deleteCluster(input: avias.dax.models.DeleteClusterRequest): F[avias.dax.models.DeleteClusterResponse] 11 | def deleteParameterGroup(input: avias.dax.models.DeleteParameterGroupRequest): F[avias.dax.models.DeleteParameterGroupResponse] 12 | def increaseReplicationFactor(input: avias.dax.models.IncreaseReplicationFactorRequest): F[avias.dax.models.IncreaseReplicationFactorResponse] 13 | def updateCluster(input: avias.dax.models.UpdateClusterRequest): F[avias.dax.models.UpdateClusterResponse] 14 | def listTags(input: avias.dax.models.ListTagsRequest): F[avias.dax.models.ListTagsResponse] 15 | def describeParameters(input: avias.dax.models.DescribeParametersRequest): F[avias.dax.models.DescribeParametersResponse] 16 | def deleteSubnetGroup(input: avias.dax.models.DeleteSubnetGroupRequest): F[avias.dax.models.DeleteSubnetGroupResponse] 17 | def describeSubnetGroups(input: avias.dax.models.DescribeSubnetGroupsRequest): F[avias.dax.models.DescribeSubnetGroupsResponse] 18 | def updateParameterGroup(input: avias.dax.models.UpdateParameterGroupRequest): F[avias.dax.models.UpdateParameterGroupResponse] 19 | def describeDefaultParameters(input: avias.dax.models.DescribeDefaultParametersRequest): F[avias.dax.models.DescribeDefaultParametersResponse] 20 | def createParameterGroup(input: avias.dax.models.CreateParameterGroupRequest): F[avias.dax.models.CreateParameterGroupResponse] 21 | def createCluster(input: avias.dax.models.CreateClusterRequest): F[avias.dax.models.CreateClusterResponse] 22 | def decreaseReplicationFactor(input: avias.dax.models.DecreaseReplicationFactorRequest): F[avias.dax.models.DecreaseReplicationFactorResponse] 23 | def updateSubnetGroup(input: avias.dax.models.UpdateSubnetGroupRequest): F[avias.dax.models.UpdateSubnetGroupResponse] 24 | } -------------------------------------------------------------------------------- /services/health/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.health.http4s 2 | import org.http4s.Method._ 3 | import avias.health.circe._ 4 | import avias.health.models 5 | class AmazonhealthClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.health.Amazonhealth[F] { 6 | private[this] final val ServiceType: String = "health" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("AWSHealth_20160804") 8 | override def describeEventDetails(input: avias.health.models.DescribeEventDetailsRequest): F[avias.health.models.DescribeEventDetailsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.health.models.DescribeEventDetailsResponse, avias.health.models.DescribeEventDetailsRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeEventDetails", POST, "/", input) 9 | override def describeEntityAggregates(input: avias.health.models.DescribeEntityAggregatesRequest): F[avias.health.models.DescribeEntityAggregatesResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.health.models.DescribeEntityAggregatesResponse, avias.health.models.DescribeEntityAggregatesRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeEntityAggregates", POST, "/", input) 10 | override def describeEventAggregates(input: avias.health.models.DescribeEventAggregatesRequest): F[avias.health.models.DescribeEventAggregatesResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.health.models.DescribeEventAggregatesResponse, avias.health.models.DescribeEventAggregatesRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeEventAggregates", POST, "/", input) 11 | override def describeAffectedEntities(input: avias.health.models.DescribeAffectedEntitiesRequest): F[avias.health.models.DescribeAffectedEntitiesResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.health.models.DescribeAffectedEntitiesResponse, avias.health.models.DescribeAffectedEntitiesRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeAffectedEntities", POST, "/", input) 12 | override def describeEventTypes(input: avias.health.models.DescribeEventTypesRequest): F[avias.health.models.DescribeEventTypesResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.health.models.DescribeEventTypesResponse, avias.health.models.DescribeEventTypesRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeEventTypes", POST, "/", input) 13 | override def describeEvents(input: avias.health.models.DescribeEventsRequest): F[avias.health.models.DescribeEventsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.health.models.DescribeEventsResponse, avias.health.models.DescribeEventsRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeEvents", POST, "/", input) 14 | } -------------------------------------------------------------------------------- /services/ecr/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.ecr 2 | trait Amazonecr[F[_]] { 3 | def initiateLayerUpload(input: avias.ecr.models.InitiateLayerUploadRequest): F[avias.ecr.models.InitiateLayerUploadResponse] 4 | def putImage(input: avias.ecr.models.PutImageRequest): F[avias.ecr.models.PutImageResponse] 5 | def uploadLayerPart(input: avias.ecr.models.UploadLayerPartRequest): F[avias.ecr.models.UploadLayerPartResponse] 6 | def setRepositoryPolicy(input: avias.ecr.models.SetRepositoryPolicyRequest): F[avias.ecr.models.SetRepositoryPolicyResponse] 7 | def putLifecyclePolicy(input: avias.ecr.models.PutLifecyclePolicyRequest): F[avias.ecr.models.PutLifecyclePolicyResponse] 8 | def batchCheckLayerAvailability(input: avias.ecr.models.BatchCheckLayerAvailabilityRequest): F[avias.ecr.models.BatchCheckLayerAvailabilityResponse] 9 | def batchDeleteImage(input: avias.ecr.models.BatchDeleteImageRequest): F[avias.ecr.models.BatchDeleteImageResponse] 10 | def describeImages(input: avias.ecr.models.DescribeImagesRequest): F[avias.ecr.models.DescribeImagesResponse] 11 | def listImages(input: avias.ecr.models.ListImagesRequest): F[avias.ecr.models.ListImagesResponse] 12 | def startLifecyclePolicyPreview(input: avias.ecr.models.StartLifecyclePolicyPreviewRequest): F[avias.ecr.models.StartLifecyclePolicyPreviewResponse] 13 | def completeLayerUpload(input: avias.ecr.models.CompleteLayerUploadRequest): F[avias.ecr.models.CompleteLayerUploadResponse] 14 | def deleteLifecyclePolicy(input: avias.ecr.models.DeleteLifecyclePolicyRequest): F[avias.ecr.models.DeleteLifecyclePolicyResponse] 15 | def createRepository(input: avias.ecr.models.CreateRepositoryRequest): F[avias.ecr.models.CreateRepositoryResponse] 16 | def getLifecyclePolicyPreview(input: avias.ecr.models.GetLifecyclePolicyPreviewRequest): F[avias.ecr.models.GetLifecyclePolicyPreviewResponse] 17 | def batchGetImage(input: avias.ecr.models.BatchGetImageRequest): F[avias.ecr.models.BatchGetImageResponse] 18 | def deleteRepository(input: avias.ecr.models.DeleteRepositoryRequest): F[avias.ecr.models.DeleteRepositoryResponse] 19 | def describeRepositories(input: avias.ecr.models.DescribeRepositoriesRequest): F[avias.ecr.models.DescribeRepositoriesResponse] 20 | def getDownloadUrlForLayer(input: avias.ecr.models.GetDownloadUrlForLayerRequest): F[avias.ecr.models.GetDownloadUrlForLayerResponse] 21 | def getLifecyclePolicy(input: avias.ecr.models.GetLifecyclePolicyRequest): F[avias.ecr.models.GetLifecyclePolicyResponse] 22 | def deleteRepositoryPolicy(input: avias.ecr.models.DeleteRepositoryPolicyRequest): F[avias.ecr.models.DeleteRepositoryPolicyResponse] 23 | def getAuthorizationToken(input: avias.ecr.models.GetAuthorizationTokenRequest): F[avias.ecr.models.GetAuthorizationTokenResponse] 24 | def getRepositoryPolicy(input: avias.ecr.models.GetRepositoryPolicyRequest): F[avias.ecr.models.GetRepositoryPolicyResponse] 25 | } -------------------------------------------------------------------------------- /services/resourcegroupstaggingapi/core/src/main/scala/avias/Models.scala: -------------------------------------------------------------------------------- 1 | package avias.resourcegroupstaggingapi.models 2 | final case class GetTagValuesInput(key: java.lang.String, paginationToken: scala.Option[java.lang.String] = scala.None) 3 | final case class InternalServiceException(message: scala.Option[java.lang.String] = scala.None) 4 | final case class GetTagKeysOutput(paginationToken: scala.Option[java.lang.String] = scala.None, tagKeys: scala.Option[scala.List[java.lang.String]] = scala.None) 5 | final case class GetTagValuesOutput(paginationToken: scala.Option[java.lang.String] = scala.None, tagValues: scala.Option[scala.List[java.lang.String]] = scala.None) 6 | final case class GetResourcesOutput(paginationToken: scala.Option[java.lang.String] = scala.None, resourceTagMappingList: scala.Option[scala.List[avias.resourcegroupstaggingapi.models.ResourceTagMapping]] = scala.None) 7 | final case class GetTagKeysInput(paginationToken: scala.Option[java.lang.String] = scala.None) 8 | final case class TagResourcesInput(resourceARNList: scala.List[java.lang.String], tags: scala.collection.immutable.Map[java.lang.String, java.lang.String]) 9 | final case class UntagResourcesInput(resourceARNList: scala.List[java.lang.String], tagKeys: scala.List[java.lang.String]) 10 | final case class GetResourcesInput(resourcesPerPage: scala.Option[scala.Int] = scala.None, paginationToken: scala.Option[java.lang.String] = scala.None, tagFilters: scala.Option[scala.List[avias.resourcegroupstaggingapi.models.TagFilter]] = scala.None, resourceTypeFilters: scala.Option[scala.List[java.lang.String]] = scala.None, tagsPerPage: scala.Option[scala.Int] = scala.None) 11 | final case class TagResourcesOutput(failedResourcesMap: scala.Option[scala.collection.immutable.Map[java.lang.String, avias.resourcegroupstaggingapi.models.FailureInfo]] = scala.None) 12 | final case class PaginationTokenExpiredException(message: scala.Option[java.lang.String] = scala.None) 13 | final case class UntagResourcesOutput(failedResourcesMap: scala.Option[scala.collection.immutable.Map[java.lang.String, avias.resourcegroupstaggingapi.models.FailureInfo]] = scala.None) 14 | final case class FailureInfo(statusCode: scala.Option[scala.Int] = scala.None, errorCode: scala.Option[java.lang.String] = scala.None, errorMessage: scala.Option[java.lang.String] = scala.None) 15 | final case class ResourceTagMapping(resourceARN: scala.Option[java.lang.String] = scala.None, tags: scala.Option[scala.List[avias.resourcegroupstaggingapi.models.Tag]] = scala.None) 16 | final case class InvalidParameterException(message: scala.Option[java.lang.String] = scala.None) 17 | final case class Tag(key: java.lang.String, value: java.lang.String) 18 | final case class ThrottledException(message: scala.Option[java.lang.String] = scala.None) 19 | final case class TagFilter(key: scala.Option[java.lang.String] = scala.None, values: scala.Option[scala.List[java.lang.String]] = scala.None) -------------------------------------------------------------------------------- /gen/src/main/scala/avias/gen/parse/service/ServiceShape.scala: -------------------------------------------------------------------------------- 1 | package avias.gen.parse.service 2 | 3 | import io.circe._ 4 | import io.circe.generic.auto._ 5 | 6 | import scala.collection.immutable.ListMap 7 | 8 | sealed trait ServiceShape extends Product with Serializable 9 | case class BlobServiceShape(documentation: Option[String]) extends ServiceShape 10 | case class BooleanServiceShape(documentation: Option[String]) 11 | extends ServiceShape 12 | case class DoubleServiceShape(documentation: Option[String]) 13 | extends ServiceShape 14 | case class FloatServiceShape(documentation: Option[String]) extends ServiceShape 15 | case class IntegerServiceShape(documentation: Option[String], 16 | min: Option[Int], 17 | max: Option[Int]) 18 | extends ServiceShape 19 | case class ListServiceShape(documentation: Option[String], 20 | member: StructureInstance, 21 | min: Option[Int]) 22 | extends ServiceShape 23 | case class LongServiceShape(documentation: Option[String], 24 | min: Option[Long], 25 | max: Option[Long]) 26 | extends ServiceShape 27 | case class MapServiceShape(documentation: Option[String], 28 | key: StructureInstance, 29 | value: StructureInstance) 30 | extends ServiceShape 31 | case class StringServiceShape(documentation: Option[String], 32 | enum: Option[List[String]], 33 | max: Option[Int]) 34 | extends ServiceShape 35 | case class StructureServiceShape(documentation: Option[String], 36 | required: Option[List[String]], 37 | members: ListMap[String, StructureInstance]) 38 | extends ServiceShape 39 | case class TimestampServiceShape(documentation: Option[String]) 40 | extends ServiceShape 41 | 42 | object ServiceShape { 43 | implicit val shapeDecoder: Decoder[ServiceShape] = new Decoder[ServiceShape] { 44 | override def apply(c: HCursor): Decoder.Result[ServiceShape] = { 45 | c.downField("type").as[String].flatMap { 46 | case "blob" => 47 | c.as[BlobServiceShape] 48 | case "boolean" => 49 | c.as[BooleanServiceShape] 50 | case "double" => 51 | c.as[DoubleServiceShape] 52 | case "float" => 53 | c.as[FloatServiceShape] 54 | case "integer" => 55 | c.as[IntegerServiceShape] 56 | case "list" => 57 | c.as[ListServiceShape] 58 | case "long" => 59 | c.as[LongServiceShape] 60 | case "map" => 61 | c.as[MapServiceShape] 62 | case "string" => 63 | c.as[StringServiceShape] 64 | case "structure" => 65 | c.as[StructureServiceShape] 66 | case "timestamp" => 67 | c.as[TimestampServiceShape] 68 | } 69 | } 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /services/emr/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.emr 2 | trait Amazonemr[F[_]] { 3 | def modifyInstanceFleet(input: avias.emr.models.ModifyInstanceFleetInput): F[scala.Unit] 4 | def deleteSecurityConfiguration(input: avias.emr.models.DeleteSecurityConfigurationInput): F[scala.Unit] 5 | def listSecurityConfigurations(input: avias.emr.models.ListSecurityConfigurationsInput): F[avias.emr.models.ListSecurityConfigurationsOutput] 6 | def modifyInstanceGroups(input: avias.emr.models.ModifyInstanceGroupsInput): F[scala.Unit] 7 | def describeSecurityConfiguration(input: avias.emr.models.DescribeSecurityConfigurationInput): F[avias.emr.models.DescribeSecurityConfigurationOutput] 8 | def putAutoScalingPolicy(input: avias.emr.models.PutAutoScalingPolicyInput): F[avias.emr.models.PutAutoScalingPolicyOutput] 9 | def listSteps(input: avias.emr.models.ListStepsInput): F[avias.emr.models.ListStepsOutput] 10 | def addJobFlowSteps(input: avias.emr.models.AddJobFlowStepsInput): F[avias.emr.models.AddJobFlowStepsOutput] 11 | def cancelSteps(input: avias.emr.models.CancelStepsInput): F[avias.emr.models.CancelStepsOutput] 12 | def listInstanceFleets(input: avias.emr.models.ListInstanceFleetsInput): F[avias.emr.models.ListInstanceFleetsOutput] 13 | def addInstanceFleet(input: avias.emr.models.AddInstanceFleetInput): F[avias.emr.models.AddInstanceFleetOutput] 14 | def listClusters(input: avias.emr.models.ListClustersInput): F[avias.emr.models.ListClustersOutput] 15 | def runJobFlow(input: avias.emr.models.RunJobFlowInput): F[avias.emr.models.RunJobFlowOutput] 16 | def listInstances(input: avias.emr.models.ListInstancesInput): F[avias.emr.models.ListInstancesOutput] 17 | def describeStep(input: avias.emr.models.DescribeStepInput): F[avias.emr.models.DescribeStepOutput] 18 | def setVisibleToAllUsers(input: avias.emr.models.SetVisibleToAllUsersInput): F[scala.Unit] 19 | def describeCluster(input: avias.emr.models.DescribeClusterInput): F[avias.emr.models.DescribeClusterOutput] 20 | def terminateJobFlows(input: avias.emr.models.TerminateJobFlowsInput): F[scala.Unit] 21 | def removeAutoScalingPolicy(input: avias.emr.models.RemoveAutoScalingPolicyInput): F[scala.Unit] 22 | def addInstanceGroups(input: avias.emr.models.AddInstanceGroupsInput): F[avias.emr.models.AddInstanceGroupsOutput] 23 | def listInstanceGroups(input: avias.emr.models.ListInstanceGroupsInput): F[avias.emr.models.ListInstanceGroupsOutput] 24 | def addTags(input: avias.emr.models.AddTagsInput): F[scala.Unit] 25 | def createSecurityConfiguration(input: avias.emr.models.CreateSecurityConfigurationInput): F[avias.emr.models.CreateSecurityConfigurationOutput] 26 | def removeTags(input: avias.emr.models.RemoveTagsInput): F[scala.Unit] 27 | def listBootstrapActions(input: avias.emr.models.ListBootstrapActionsInput): F[avias.emr.models.ListBootstrapActionsOutput] 28 | def setTerminationProtection(input: avias.emr.models.SetTerminationProtectionInput): F[scala.Unit] 29 | def describeJobFlows(input: avias.emr.models.DescribeJobFlowsInput): F[avias.emr.models.DescribeJobFlowsOutput] 30 | } -------------------------------------------------------------------------------- /services/kinesisfirehose/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.kinesisfirehose.http4s 2 | import org.http4s.Method._ 3 | import avias.kinesisfirehose.circe._ 4 | import avias.kinesisfirehose.models 5 | class AmazonkinesisfirehoseClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.kinesisfirehose.Amazonkinesisfirehose[F] { 6 | private[this] final val ServiceType: String = "firehose" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("Firehose_20150804") 8 | override def updateDestination(input: avias.kinesisfirehose.models.UpdateDestinationInput): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.kinesisfirehose.models.UpdateDestinationInput](client, awsData, ServiceType, ServiceAndPrefix, "UpdateDestination", POST, "/", input) 9 | override def describeDeliveryStream(input: avias.kinesisfirehose.models.DescribeDeliveryStreamInput): F[avias.kinesisfirehose.models.DescribeDeliveryStreamOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.kinesisfirehose.models.DescribeDeliveryStreamOutput, avias.kinesisfirehose.models.DescribeDeliveryStreamInput](client, awsData, ServiceType, ServiceAndPrefix, "DescribeDeliveryStream", POST, "/", input) 10 | override def putRecord(input: avias.kinesisfirehose.models.PutRecordInput): F[avias.kinesisfirehose.models.PutRecordOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.kinesisfirehose.models.PutRecordOutput, avias.kinesisfirehose.models.PutRecordInput](client, awsData, ServiceType, ServiceAndPrefix, "PutRecord", POST, "/", input) 11 | override def listDeliveryStreams(input: avias.kinesisfirehose.models.ListDeliveryStreamsInput): F[avias.kinesisfirehose.models.ListDeliveryStreamsOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.kinesisfirehose.models.ListDeliveryStreamsOutput, avias.kinesisfirehose.models.ListDeliveryStreamsInput](client, awsData, ServiceType, ServiceAndPrefix, "ListDeliveryStreams", POST, "/", input) 12 | override def createDeliveryStream(input: avias.kinesisfirehose.models.CreateDeliveryStreamInput): F[avias.kinesisfirehose.models.CreateDeliveryStreamOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.kinesisfirehose.models.CreateDeliveryStreamOutput, avias.kinesisfirehose.models.CreateDeliveryStreamInput](client, awsData, ServiceType, ServiceAndPrefix, "CreateDeliveryStream", POST, "/", input) 13 | override def deleteDeliveryStream(input: avias.kinesisfirehose.models.DeleteDeliveryStreamInput): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.kinesisfirehose.models.DeleteDeliveryStreamInput](client, awsData, ServiceType, ServiceAndPrefix, "DeleteDeliveryStream", POST, "/", input) 14 | override def putRecordBatch(input: avias.kinesisfirehose.models.PutRecordBatchInput): F[avias.kinesisfirehose.models.PutRecordBatchOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.kinesisfirehose.models.PutRecordBatchOutput, avias.kinesisfirehose.models.PutRecordBatchInput](client, awsData, ServiceType, ServiceAndPrefix, "PutRecordBatch", POST, "/", input) 15 | } -------------------------------------------------------------------------------- /services/shield/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.shield.http4s 2 | import org.http4s.Method._ 3 | import avias.shield.circe._ 4 | import avias.shield.models 5 | class AmazonshieldClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.shield.Amazonshield[F] { 6 | private[this] final val ServiceType: String = "shield" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("AWSShield_20160616") 8 | override def describeSubscription: F[avias.shield.models.DescribeSubscriptionResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.shield.models.DescribeSubscriptionResponse, scala.Unit](client, awsData, ServiceType, ServiceAndPrefix, "DescribeSubscription", POST, "/", ()) 9 | override def describeAttack(input: avias.shield.models.DescribeAttackRequest): F[avias.shield.models.DescribeAttackResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.shield.models.DescribeAttackResponse, avias.shield.models.DescribeAttackRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeAttack", POST, "/", input) 10 | override def deleteSubscription: F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, scala.Unit](client, awsData, ServiceType, ServiceAndPrefix, "DeleteSubscription", POST, "/", ()) 11 | override def createSubscription: F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, scala.Unit](client, awsData, ServiceType, ServiceAndPrefix, "CreateSubscription", POST, "/", ()) 12 | override def createProtection(input: avias.shield.models.CreateProtectionRequest): F[avias.shield.models.CreateProtectionResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.shield.models.CreateProtectionResponse, avias.shield.models.CreateProtectionRequest](client, awsData, ServiceType, ServiceAndPrefix, "CreateProtection", POST, "/", input) 13 | override def describeProtection(input: avias.shield.models.DescribeProtectionRequest): F[avias.shield.models.DescribeProtectionResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.shield.models.DescribeProtectionResponse, avias.shield.models.DescribeProtectionRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeProtection", POST, "/", input) 14 | override def listProtections(input: avias.shield.models.ListProtectionsRequest): F[avias.shield.models.ListProtectionsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.shield.models.ListProtectionsResponse, avias.shield.models.ListProtectionsRequest](client, awsData, ServiceType, ServiceAndPrefix, "ListProtections", POST, "/", input) 15 | override def deleteProtection(input: avias.shield.models.DeleteProtectionRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.shield.models.DeleteProtectionRequest](client, awsData, ServiceType, ServiceAndPrefix, "DeleteProtection", POST, "/", input) 16 | override def listAttacks(input: avias.shield.models.ListAttacksRequest): F[avias.shield.models.ListAttacksResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.shield.models.ListAttacksResponse, avias.shield.models.ListAttacksRequest](client, awsData, ServiceType, ServiceAndPrefix, "ListAttacks", POST, "/", input) 17 | } -------------------------------------------------------------------------------- /services/codepipeline/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.codepipeline 2 | trait Amazoncodepipeline[F[_]] { 3 | def listPipelineExecutions(input: avias.codepipeline.models.ListPipelineExecutionsInput): F[avias.codepipeline.models.ListPipelineExecutionsOutput] 4 | def createCustomActionType(input: avias.codepipeline.models.CreateCustomActionTypeInput): F[avias.codepipeline.models.CreateCustomActionTypeOutput] 5 | def putActionRevision(input: avias.codepipeline.models.PutActionRevisionInput): F[avias.codepipeline.models.PutActionRevisionOutput] 6 | def acknowledgeJob(input: avias.codepipeline.models.AcknowledgeJobInput): F[avias.codepipeline.models.AcknowledgeJobOutput] 7 | def putApprovalResult(input: avias.codepipeline.models.PutApprovalResultInput): F[avias.codepipeline.models.PutApprovalResultOutput] 8 | def putJobFailureResult(input: avias.codepipeline.models.PutJobFailureResultInput): F[scala.Unit] 9 | def listActionTypes(input: avias.codepipeline.models.ListActionTypesInput): F[avias.codepipeline.models.ListActionTypesOutput] 10 | def putThirdPartyJobSuccessResult(input: avias.codepipeline.models.PutThirdPartyJobSuccessResultInput): F[scala.Unit] 11 | def pollForJobs(input: avias.codepipeline.models.PollForJobsInput): F[avias.codepipeline.models.PollForJobsOutput] 12 | def acknowledgeThirdPartyJob(input: avias.codepipeline.models.AcknowledgeThirdPartyJobInput): F[avias.codepipeline.models.AcknowledgeThirdPartyJobOutput] 13 | def deleteCustomActionType(input: avias.codepipeline.models.DeleteCustomActionTypeInput): F[scala.Unit] 14 | def putThirdPartyJobFailureResult(input: avias.codepipeline.models.PutThirdPartyJobFailureResultInput): F[scala.Unit] 15 | def listPipelines(input: avias.codepipeline.models.ListPipelinesInput): F[avias.codepipeline.models.ListPipelinesOutput] 16 | def startPipelineExecution(input: avias.codepipeline.models.StartPipelineExecutionInput): F[avias.codepipeline.models.StartPipelineExecutionOutput] 17 | def getThirdPartyJobDetails(input: avias.codepipeline.models.GetThirdPartyJobDetailsInput): F[avias.codepipeline.models.GetThirdPartyJobDetailsOutput] 18 | def deletePipeline(input: avias.codepipeline.models.DeletePipelineInput): F[scala.Unit] 19 | def enableStageTransition(input: avias.codepipeline.models.EnableStageTransitionInput): F[scala.Unit] 20 | def createPipeline(input: avias.codepipeline.models.CreatePipelineInput): F[avias.codepipeline.models.CreatePipelineOutput] 21 | def getPipeline(input: avias.codepipeline.models.GetPipelineInput): F[avias.codepipeline.models.GetPipelineOutput] 22 | def pollForThirdPartyJobs(input: avias.codepipeline.models.PollForThirdPartyJobsInput): F[avias.codepipeline.models.PollForThirdPartyJobsOutput] 23 | def getPipelineExecution(input: avias.codepipeline.models.GetPipelineExecutionInput): F[avias.codepipeline.models.GetPipelineExecutionOutput] 24 | def updatePipeline(input: avias.codepipeline.models.UpdatePipelineInput): F[avias.codepipeline.models.UpdatePipelineOutput] 25 | def retryStageExecution(input: avias.codepipeline.models.RetryStageExecutionInput): F[avias.codepipeline.models.RetryStageExecutionOutput] 26 | def getJobDetails(input: avias.codepipeline.models.GetJobDetailsInput): F[avias.codepipeline.models.GetJobDetailsOutput] 27 | def disableStageTransition(input: avias.codepipeline.models.DisableStageTransitionInput): F[scala.Unit] 28 | def getPipelineState(input: avias.codepipeline.models.GetPipelineStateInput): F[avias.codepipeline.models.GetPipelineStateOutput] 29 | def putJobSuccessResult(input: avias.codepipeline.models.PutJobSuccessResultInput): F[scala.Unit] 30 | } -------------------------------------------------------------------------------- /services/route53domains/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.route53domains 2 | trait Amazonroute53domains[F[_]] { 3 | def updateDomainContact(input: avias.route53domains.models.UpdateDomainContactRequest): F[avias.route53domains.models.UpdateDomainContactResponse] 4 | def updateTagsForDomain(input: avias.route53domains.models.UpdateTagsForDomainRequest): F[scala.Unit] 5 | def listOperations(input: avias.route53domains.models.ListOperationsRequest): F[avias.route53domains.models.ListOperationsResponse] 6 | def disableDomainTransferLock(input: avias.route53domains.models.DisableDomainTransferLockRequest): F[avias.route53domains.models.DisableDomainTransferLockResponse] 7 | def updateDomainContactPrivacy(input: avias.route53domains.models.UpdateDomainContactPrivacyRequest): F[avias.route53domains.models.UpdateDomainContactPrivacyResponse] 8 | def transferDomain(input: avias.route53domains.models.TransferDomainRequest): F[avias.route53domains.models.TransferDomainResponse] 9 | def getDomainDetail(input: avias.route53domains.models.GetDomainDetailRequest): F[avias.route53domains.models.GetDomainDetailResponse] 10 | def retrieveDomainAuthCode(input: avias.route53domains.models.RetrieveDomainAuthCodeRequest): F[avias.route53domains.models.RetrieveDomainAuthCodeResponse] 11 | def listTagsForDomain(input: avias.route53domains.models.ListTagsForDomainRequest): F[avias.route53domains.models.ListTagsForDomainResponse] 12 | def resendContactReachabilityEmail(input: avias.route53domains.models.ResendContactReachabilityEmailRequest): F[avias.route53domains.models.ResendContactReachabilityEmailResponse] 13 | def checkDomainAvailability(input: avias.route53domains.models.CheckDomainAvailabilityRequest): F[avias.route53domains.models.CheckDomainAvailabilityResponse] 14 | def getDomainSuggestions(input: avias.route53domains.models.GetDomainSuggestionsRequest): F[avias.route53domains.models.GetDomainSuggestionsResponse] 15 | def getOperationDetail(input: avias.route53domains.models.GetOperationDetailRequest): F[avias.route53domains.models.GetOperationDetailResponse] 16 | def viewBilling(input: avias.route53domains.models.ViewBillingRequest): F[avias.route53domains.models.ViewBillingResponse] 17 | def renewDomain(input: avias.route53domains.models.RenewDomainRequest): F[avias.route53domains.models.RenewDomainResponse] 18 | def checkDomainTransferability(input: avias.route53domains.models.CheckDomainTransferabilityRequest): F[avias.route53domains.models.CheckDomainTransferabilityResponse] 19 | def deleteTagsForDomain(input: avias.route53domains.models.DeleteTagsForDomainRequest): F[scala.Unit] 20 | def disableDomainAutoRenew(input: avias.route53domains.models.DisableDomainAutoRenewRequest): F[scala.Unit] 21 | def enableDomainAutoRenew(input: avias.route53domains.models.EnableDomainAutoRenewRequest): F[scala.Unit] 22 | def registerDomain(input: avias.route53domains.models.RegisterDomainRequest): F[avias.route53domains.models.RegisterDomainResponse] 23 | def enableDomainTransferLock(input: avias.route53domains.models.EnableDomainTransferLockRequest): F[avias.route53domains.models.EnableDomainTransferLockResponse] 24 | def getContactReachabilityStatus(input: avias.route53domains.models.GetContactReachabilityStatusRequest): F[avias.route53domains.models.GetContactReachabilityStatusResponse] 25 | def listDomains(input: avias.route53domains.models.ListDomainsRequest): F[avias.route53domains.models.ListDomainsResponse] 26 | def updateDomainNameservers(input: avias.route53domains.models.UpdateDomainNameserversRequest): F[avias.route53domains.models.UpdateDomainNameserversResponse] 27 | } -------------------------------------------------------------------------------- /services/appstream/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.appstream 2 | trait Amazonappstream[F[_]] { 3 | def createStreamingURL(input: avias.appstream.models.CreateStreamingURLRequest): F[avias.appstream.models.CreateStreamingURLResult] 4 | def describeSessions(input: avias.appstream.models.DescribeSessionsRequest): F[avias.appstream.models.DescribeSessionsResult] 5 | def describeStacks(input: avias.appstream.models.DescribeStacksRequest): F[avias.appstream.models.DescribeStacksResult] 6 | def associateFleet(input: avias.appstream.models.AssociateFleetRequest): F[scala.Unit] 7 | def deleteStack(input: avias.appstream.models.DeleteStackRequest): F[scala.Unit] 8 | def disassociateFleet(input: avias.appstream.models.DisassociateFleetRequest): F[scala.Unit] 9 | def stopImageBuilder(input: avias.appstream.models.StopImageBuilderRequest): F[avias.appstream.models.StopImageBuilderResult] 10 | def describeImages(input: avias.appstream.models.DescribeImagesRequest): F[avias.appstream.models.DescribeImagesResult] 11 | def describeDirectoryConfigs(input: avias.appstream.models.DescribeDirectoryConfigsRequest): F[avias.appstream.models.DescribeDirectoryConfigsResult] 12 | def updateStack(input: avias.appstream.models.UpdateStackRequest): F[avias.appstream.models.UpdateStackResult] 13 | def listAssociatedFleets(input: avias.appstream.models.ListAssociatedFleetsRequest): F[avias.appstream.models.ListAssociatedFleetsResult] 14 | def updateDirectoryConfig(input: avias.appstream.models.UpdateDirectoryConfigRequest): F[avias.appstream.models.UpdateDirectoryConfigResult] 15 | def createStack(input: avias.appstream.models.CreateStackRequest): F[avias.appstream.models.CreateStackResult] 16 | def listAssociatedStacks(input: avias.appstream.models.ListAssociatedStacksRequest): F[avias.appstream.models.ListAssociatedStacksResult] 17 | def deleteImage(input: avias.appstream.models.DeleteImageRequest): F[avias.appstream.models.DeleteImageResult] 18 | def updateFleet(input: avias.appstream.models.UpdateFleetRequest): F[avias.appstream.models.UpdateFleetResult] 19 | def createDirectoryConfig(input: avias.appstream.models.CreateDirectoryConfigRequest): F[avias.appstream.models.CreateDirectoryConfigResult] 20 | def deleteImageBuilder(input: avias.appstream.models.DeleteImageBuilderRequest): F[avias.appstream.models.DeleteImageBuilderResult] 21 | def deleteFleet(input: avias.appstream.models.DeleteFleetRequest): F[scala.Unit] 22 | def describeImageBuilders(input: avias.appstream.models.DescribeImageBuildersRequest): F[avias.appstream.models.DescribeImageBuildersResult] 23 | def createFleet(input: avias.appstream.models.CreateFleetRequest): F[avias.appstream.models.CreateFleetResult] 24 | def createImageBuilder(input: avias.appstream.models.CreateImageBuilderRequest): F[avias.appstream.models.CreateImageBuilderResult] 25 | def startFleet(input: avias.appstream.models.StartFleetRequest): F[scala.Unit] 26 | def deleteDirectoryConfig(input: avias.appstream.models.DeleteDirectoryConfigRequest): F[scala.Unit] 27 | def expireSession(input: avias.appstream.models.ExpireSessionRequest): F[scala.Unit] 28 | def describeFleets(input: avias.appstream.models.DescribeFleetsRequest): F[avias.appstream.models.DescribeFleetsResult] 29 | def createImageBuilderStreamingURL(input: avias.appstream.models.CreateImageBuilderStreamingURLRequest): F[avias.appstream.models.CreateImageBuilderStreamingURLResult] 30 | def stopFleet(input: avias.appstream.models.StopFleetRequest): F[scala.Unit] 31 | def startImageBuilder(input: avias.appstream.models.StartImageBuilderRequest): F[avias.appstream.models.StartImageBuilderResult] 32 | } -------------------------------------------------------------------------------- /services/kms/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.kms 2 | trait Amazonkms[F[_]] { 3 | def enableKey(input: avias.kms.models.EnableKeyRequest): F[scala.Unit] 4 | def getKeyPolicy(input: avias.kms.models.GetKeyPolicyRequest): F[avias.kms.models.GetKeyPolicyResponse] 5 | def generateRandom(input: avias.kms.models.GenerateRandomRequest): F[avias.kms.models.GenerateRandomResponse] 6 | def scheduleKeyDeletion(input: avias.kms.models.ScheduleKeyDeletionRequest): F[avias.kms.models.ScheduleKeyDeletionResponse] 7 | def disableKey(input: avias.kms.models.DisableKeyRequest): F[scala.Unit] 8 | def revokeGrant(input: avias.kms.models.RevokeGrantRequest): F[scala.Unit] 9 | def retireGrant(input: avias.kms.models.RetireGrantRequest): F[scala.Unit] 10 | def reEncrypt(input: avias.kms.models.ReEncryptRequest): F[avias.kms.models.ReEncryptResponse] 11 | def generateDataKeyWithoutPlaintext(input: avias.kms.models.GenerateDataKeyWithoutPlaintextRequest): F[avias.kms.models.GenerateDataKeyWithoutPlaintextResponse] 12 | def deleteImportedKeyMaterial(input: avias.kms.models.DeleteImportedKeyMaterialRequest): F[scala.Unit] 13 | def tagResource(input: avias.kms.models.TagResourceRequest): F[scala.Unit] 14 | def describeKey(input: avias.kms.models.DescribeKeyRequest): F[avias.kms.models.DescribeKeyResponse] 15 | def generateDataKey(input: avias.kms.models.GenerateDataKeyRequest): F[avias.kms.models.GenerateDataKeyResponse] 16 | def listRetirableGrants(input: avias.kms.models.ListRetirableGrantsRequest): F[avias.kms.models.ListGrantsResponse] 17 | def listResourceTags(input: avias.kms.models.ListResourceTagsRequest): F[avias.kms.models.ListResourceTagsResponse] 18 | def updateKeyDescription(input: avias.kms.models.UpdateKeyDescriptionRequest): F[scala.Unit] 19 | def encrypt(input: avias.kms.models.EncryptRequest): F[avias.kms.models.EncryptResponse] 20 | def createGrant(input: avias.kms.models.CreateGrantRequest): F[avias.kms.models.CreateGrantResponse] 21 | def cancelKeyDeletion(input: avias.kms.models.CancelKeyDeletionRequest): F[avias.kms.models.CancelKeyDeletionResponse] 22 | def putKeyPolicy(input: avias.kms.models.PutKeyPolicyRequest): F[scala.Unit] 23 | def deleteAlias(input: avias.kms.models.DeleteAliasRequest): F[scala.Unit] 24 | def listAliases(input: avias.kms.models.ListAliasesRequest): F[avias.kms.models.ListAliasesResponse] 25 | def getKeyRotationStatus(input: avias.kms.models.GetKeyRotationStatusRequest): F[avias.kms.models.GetKeyRotationStatusResponse] 26 | def getParametersForImport(input: avias.kms.models.GetParametersForImportRequest): F[avias.kms.models.GetParametersForImportResponse] 27 | def enableKeyRotation(input: avias.kms.models.EnableKeyRotationRequest): F[scala.Unit] 28 | def updateAlias(input: avias.kms.models.UpdateAliasRequest): F[scala.Unit] 29 | def listKeys(input: avias.kms.models.ListKeysRequest): F[avias.kms.models.ListKeysResponse] 30 | def createAlias(input: avias.kms.models.CreateAliasRequest): F[scala.Unit] 31 | def decrypt(input: avias.kms.models.DecryptRequest): F[avias.kms.models.DecryptResponse] 32 | def untagResource(input: avias.kms.models.UntagResourceRequest): F[scala.Unit] 33 | def createKey(input: avias.kms.models.CreateKeyRequest): F[avias.kms.models.CreateKeyResponse] 34 | def listKeyPolicies(input: avias.kms.models.ListKeyPoliciesRequest): F[avias.kms.models.ListKeyPoliciesResponse] 35 | def listGrants(input: avias.kms.models.ListGrantsRequest): F[avias.kms.models.ListGrantsResponse] 36 | def importKeyMaterial(input: avias.kms.models.ImportKeyMaterialRequest): F[scala.Unit] 37 | def disableKeyRotation(input: avias.kms.models.DisableKeyRotationRequest): F[scala.Unit] 38 | } -------------------------------------------------------------------------------- /services/logs/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.logs 2 | trait Amazonlogs[F[_]] { 3 | def putRetentionPolicy(input: avias.logs.models.PutRetentionPolicyRequest): F[scala.Unit] 4 | def disassociateKmsKey(input: avias.logs.models.DisassociateKmsKeyRequest): F[scala.Unit] 5 | def putLogEvents(input: avias.logs.models.PutLogEventsRequest): F[avias.logs.models.PutLogEventsResponse] 6 | def describeResourcePolicies(input: avias.logs.models.DescribeResourcePoliciesRequest): F[avias.logs.models.DescribeResourcePoliciesResponse] 7 | def describeExportTasks(input: avias.logs.models.DescribeExportTasksRequest): F[avias.logs.models.DescribeExportTasksResponse] 8 | def putDestination(input: avias.logs.models.PutDestinationRequest): F[avias.logs.models.PutDestinationResponse] 9 | def describeSubscriptionFilters(input: avias.logs.models.DescribeSubscriptionFiltersRequest): F[avias.logs.models.DescribeSubscriptionFiltersResponse] 10 | def listTagsLogGroup(input: avias.logs.models.ListTagsLogGroupRequest): F[avias.logs.models.ListTagsLogGroupResponse] 11 | def tagLogGroup(input: avias.logs.models.TagLogGroupRequest): F[scala.Unit] 12 | def deleteResourcePolicy(input: avias.logs.models.DeleteResourcePolicyRequest): F[scala.Unit] 13 | def createExportTask(input: avias.logs.models.CreateExportTaskRequest): F[avias.logs.models.CreateExportTaskResponse] 14 | def deleteDestination(input: avias.logs.models.DeleteDestinationRequest): F[scala.Unit] 15 | def deleteRetentionPolicy(input: avias.logs.models.DeleteRetentionPolicyRequest): F[scala.Unit] 16 | def deleteLogStream(input: avias.logs.models.DeleteLogStreamRequest): F[scala.Unit] 17 | def deleteLogGroup(input: avias.logs.models.DeleteLogGroupRequest): F[scala.Unit] 18 | def getLogEvents(input: avias.logs.models.GetLogEventsRequest): F[avias.logs.models.GetLogEventsResponse] 19 | def describeMetricFilters(input: avias.logs.models.DescribeMetricFiltersRequest): F[avias.logs.models.DescribeMetricFiltersResponse] 20 | def putDestinationPolicy(input: avias.logs.models.PutDestinationPolicyRequest): F[scala.Unit] 21 | def putSubscriptionFilter(input: avias.logs.models.PutSubscriptionFilterRequest): F[scala.Unit] 22 | def describeLogStreams(input: avias.logs.models.DescribeLogStreamsRequest): F[avias.logs.models.DescribeLogStreamsResponse] 23 | def associateKmsKey(input: avias.logs.models.AssociateKmsKeyRequest): F[scala.Unit] 24 | def filterLogEvents(input: avias.logs.models.FilterLogEventsRequest): F[avias.logs.models.FilterLogEventsResponse] 25 | def describeDestinations(input: avias.logs.models.DescribeDestinationsRequest): F[avias.logs.models.DescribeDestinationsResponse] 26 | def createLogStream(input: avias.logs.models.CreateLogStreamRequest): F[scala.Unit] 27 | def cancelExportTask(input: avias.logs.models.CancelExportTaskRequest): F[scala.Unit] 28 | def deleteSubscriptionFilter(input: avias.logs.models.DeleteSubscriptionFilterRequest): F[scala.Unit] 29 | def untagLogGroup(input: avias.logs.models.UntagLogGroupRequest): F[scala.Unit] 30 | def deleteMetricFilter(input: avias.logs.models.DeleteMetricFilterRequest): F[scala.Unit] 31 | def testMetricFilter(input: avias.logs.models.TestMetricFilterRequest): F[avias.logs.models.TestMetricFilterResponse] 32 | def putResourcePolicy(input: avias.logs.models.PutResourcePolicyRequest): F[avias.logs.models.PutResourcePolicyResponse] 33 | def putMetricFilter(input: avias.logs.models.PutMetricFilterRequest): F[scala.Unit] 34 | def createLogGroup(input: avias.logs.models.CreateLogGroupRequest): F[scala.Unit] 35 | def describeLogGroups(input: avias.logs.models.DescribeLogGroupsRequest): F[avias.logs.models.DescribeLogGroupsResponse] 36 | } -------------------------------------------------------------------------------- /services/acm/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.acm.http4s 2 | import org.http4s.Method._ 3 | import avias.acm.circe._ 4 | import avias.acm.models 5 | class AmazonacmClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.acm.Amazonacm[F] { 6 | private[this] final val ServiceType: String = "acm" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("CertificateManager") 8 | override def deleteCertificate(input: avias.acm.models.DeleteCertificateRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.acm.models.DeleteCertificateRequest](client, awsData, ServiceType, ServiceAndPrefix, "DeleteCertificate", POST, "/", input) 9 | override def addTagsToCertificate(input: avias.acm.models.AddTagsToCertificateRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.acm.models.AddTagsToCertificateRequest](client, awsData, ServiceType, ServiceAndPrefix, "AddTagsToCertificate", POST, "/", input) 10 | override def listTagsForCertificate(input: avias.acm.models.ListTagsForCertificateRequest): F[avias.acm.models.ListTagsForCertificateResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.acm.models.ListTagsForCertificateResponse, avias.acm.models.ListTagsForCertificateRequest](client, awsData, ServiceType, ServiceAndPrefix, "ListTagsForCertificate", POST, "/", input) 11 | override def removeTagsFromCertificate(input: avias.acm.models.RemoveTagsFromCertificateRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.acm.models.RemoveTagsFromCertificateRequest](client, awsData, ServiceType, ServiceAndPrefix, "RemoveTagsFromCertificate", POST, "/", input) 12 | override def importCertificate(input: avias.acm.models.ImportCertificateRequest): F[avias.acm.models.ImportCertificateResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.acm.models.ImportCertificateResponse, avias.acm.models.ImportCertificateRequest](client, awsData, ServiceType, ServiceAndPrefix, "ImportCertificate", POST, "/", input) 13 | override def listCertificates(input: avias.acm.models.ListCertificatesRequest): F[avias.acm.models.ListCertificatesResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.acm.models.ListCertificatesResponse, avias.acm.models.ListCertificatesRequest](client, awsData, ServiceType, ServiceAndPrefix, "ListCertificates", POST, "/", input) 14 | override def describeCertificate(input: avias.acm.models.DescribeCertificateRequest): F[avias.acm.models.DescribeCertificateResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.acm.models.DescribeCertificateResponse, avias.acm.models.DescribeCertificateRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeCertificate", POST, "/", input) 15 | override def getCertificate(input: avias.acm.models.GetCertificateRequest): F[avias.acm.models.GetCertificateResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.acm.models.GetCertificateResponse, avias.acm.models.GetCertificateRequest](client, awsData, ServiceType, ServiceAndPrefix, "GetCertificate", POST, "/", input) 16 | override def requestCertificate(input: avias.acm.models.RequestCertificateRequest): F[avias.acm.models.RequestCertificateResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.acm.models.RequestCertificateResponse, avias.acm.models.RequestCertificateRequest](client, awsData, ServiceType, ServiceAndPrefix, "RequestCertificate", POST, "/", input) 17 | override def resendValidationEmail(input: avias.acm.models.ResendValidationEmailRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.acm.models.ResendValidationEmailRequest](client, awsData, ServiceType, ServiceAndPrefix, "ResendValidationEmail", POST, "/", input) 18 | } -------------------------------------------------------------------------------- /services/config/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.config 2 | trait Amazonconfig[F[_]] { 3 | def describeConfigRuleEvaluationStatus(input: avias.config.models.DescribeConfigRuleEvaluationStatusRequest): F[avias.config.models.DescribeConfigRuleEvaluationStatusResponse] 4 | def deleteEvaluationResults(input: avias.config.models.DeleteEvaluationResultsRequest): F[scala.Unit] 5 | def deleteDeliveryChannel(input: avias.config.models.DeleteDeliveryChannelRequest): F[scala.Unit] 6 | def deliverConfigSnapshot(input: avias.config.models.DeliverConfigSnapshotRequest): F[avias.config.models.DeliverConfigSnapshotResponse] 7 | def describeDeliveryChannels(input: avias.config.models.DescribeDeliveryChannelsRequest): F[avias.config.models.DescribeDeliveryChannelsResponse] 8 | def deleteConfigRule(input: avias.config.models.DeleteConfigRuleRequest): F[scala.Unit] 9 | def describeDeliveryChannelStatus(input: avias.config.models.DescribeDeliveryChannelStatusRequest): F[avias.config.models.DescribeDeliveryChannelStatusResponse] 10 | def putConfigRule(input: avias.config.models.PutConfigRuleRequest): F[scala.Unit] 11 | def getResourceConfigHistory(input: avias.config.models.GetResourceConfigHistoryRequest): F[avias.config.models.GetResourceConfigHistoryResponse] 12 | def getComplianceDetailsByConfigRule(input: avias.config.models.GetComplianceDetailsByConfigRuleRequest): F[avias.config.models.GetComplianceDetailsByConfigRuleResponse] 13 | def getDiscoveredResourceCounts(input: avias.config.models.GetDiscoveredResourceCountsRequest): F[avias.config.models.GetDiscoveredResourceCountsResponse] 14 | def describeConfigurationRecorderStatus(input: avias.config.models.DescribeConfigurationRecorderStatusRequest): F[avias.config.models.DescribeConfigurationRecorderStatusResponse] 15 | def listDiscoveredResources(input: avias.config.models.ListDiscoveredResourcesRequest): F[avias.config.models.ListDiscoveredResourcesResponse] 16 | def stopConfigurationRecorder(input: avias.config.models.StopConfigurationRecorderRequest): F[scala.Unit] 17 | def describeComplianceByResource(input: avias.config.models.DescribeComplianceByResourceRequest): F[avias.config.models.DescribeComplianceByResourceResponse] 18 | def describeComplianceByConfigRule(input: avias.config.models.DescribeComplianceByConfigRuleRequest): F[avias.config.models.DescribeComplianceByConfigRuleResponse] 19 | def deleteConfigurationRecorder(input: avias.config.models.DeleteConfigurationRecorderRequest): F[scala.Unit] 20 | def startConfigRulesEvaluation(input: avias.config.models.StartConfigRulesEvaluationRequest): F[scala.Unit] 21 | def putDeliveryChannel(input: avias.config.models.PutDeliveryChannelRequest): F[scala.Unit] 22 | def getComplianceDetailsByResource(input: avias.config.models.GetComplianceDetailsByResourceRequest): F[avias.config.models.GetComplianceDetailsByResourceResponse] 23 | def startConfigurationRecorder(input: avias.config.models.StartConfigurationRecorderRequest): F[scala.Unit] 24 | def describeConfigurationRecorders(input: avias.config.models.DescribeConfigurationRecordersRequest): F[avias.config.models.DescribeConfigurationRecordersResponse] 25 | def describeConfigRules(input: avias.config.models.DescribeConfigRulesRequest): F[avias.config.models.DescribeConfigRulesResponse] 26 | def getComplianceSummaryByResourceType(input: avias.config.models.GetComplianceSummaryByResourceTypeRequest): F[avias.config.models.GetComplianceSummaryByResourceTypeResponse] 27 | def putConfigurationRecorder(input: avias.config.models.PutConfigurationRecorderRequest): F[scala.Unit] 28 | def getComplianceSummaryByConfigRule: F[avias.config.models.GetComplianceSummaryByConfigRuleResponse] 29 | def putEvaluations(input: avias.config.models.PutEvaluationsRequest): F[avias.config.models.PutEvaluationsResponse] 30 | } -------------------------------------------------------------------------------- /services/ecs/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.ecs 2 | trait Amazonecs[F[_]] { 3 | def submitContainerStateChange(input: avias.ecs.models.SubmitContainerStateChangeRequest): F[avias.ecs.models.SubmitContainerStateChangeResponse] 4 | def describeTaskDefinition(input: avias.ecs.models.DescribeTaskDefinitionRequest): F[avias.ecs.models.DescribeTaskDefinitionResponse] 5 | def listAttributes(input: avias.ecs.models.ListAttributesRequest): F[avias.ecs.models.ListAttributesResponse] 6 | def listContainerInstances(input: avias.ecs.models.ListContainerInstancesRequest): F[avias.ecs.models.ListContainerInstancesResponse] 7 | def deregisterContainerInstance(input: avias.ecs.models.DeregisterContainerInstanceRequest): F[avias.ecs.models.DeregisterContainerInstanceResponse] 8 | def deleteService(input: avias.ecs.models.DeleteServiceRequest): F[avias.ecs.models.DeleteServiceResponse] 9 | def runTask(input: avias.ecs.models.RunTaskRequest): F[avias.ecs.models.RunTaskResponse] 10 | def describeClusters(input: avias.ecs.models.DescribeClustersRequest): F[avias.ecs.models.DescribeClustersResponse] 11 | def putAttributes(input: avias.ecs.models.PutAttributesRequest): F[avias.ecs.models.PutAttributesResponse] 12 | def describeServices(input: avias.ecs.models.DescribeServicesRequest): F[avias.ecs.models.DescribeServicesResponse] 13 | def createService(input: avias.ecs.models.CreateServiceRequest): F[avias.ecs.models.CreateServiceResponse] 14 | def listTasks(input: avias.ecs.models.ListTasksRequest): F[avias.ecs.models.ListTasksResponse] 15 | def listTaskDefinitions(input: avias.ecs.models.ListTaskDefinitionsRequest): F[avias.ecs.models.ListTaskDefinitionsResponse] 16 | def describeContainerInstances(input: avias.ecs.models.DescribeContainerInstancesRequest): F[avias.ecs.models.DescribeContainerInstancesResponse] 17 | def listClusters(input: avias.ecs.models.ListClustersRequest): F[avias.ecs.models.ListClustersResponse] 18 | def deleteCluster(input: avias.ecs.models.DeleteClusterRequest): F[avias.ecs.models.DeleteClusterResponse] 19 | def updateContainerInstancesState(input: avias.ecs.models.UpdateContainerInstancesStateRequest): F[avias.ecs.models.UpdateContainerInstancesStateResponse] 20 | def deregisterTaskDefinition(input: avias.ecs.models.DeregisterTaskDefinitionRequest): F[avias.ecs.models.DeregisterTaskDefinitionResponse] 21 | def stopTask(input: avias.ecs.models.StopTaskRequest): F[avias.ecs.models.StopTaskResponse] 22 | def updateService(input: avias.ecs.models.UpdateServiceRequest): F[avias.ecs.models.UpdateServiceResponse] 23 | def startTask(input: avias.ecs.models.StartTaskRequest): F[avias.ecs.models.StartTaskResponse] 24 | def registerContainerInstance(input: avias.ecs.models.RegisterContainerInstanceRequest): F[avias.ecs.models.RegisterContainerInstanceResponse] 25 | def registerTaskDefinition(input: avias.ecs.models.RegisterTaskDefinitionRequest): F[avias.ecs.models.RegisterTaskDefinitionResponse] 26 | def deleteAttributes(input: avias.ecs.models.DeleteAttributesRequest): F[avias.ecs.models.DeleteAttributesResponse] 27 | def submitTaskStateChange(input: avias.ecs.models.SubmitTaskStateChangeRequest): F[avias.ecs.models.SubmitTaskStateChangeResponse] 28 | def discoverPollEndpoint(input: avias.ecs.models.DiscoverPollEndpointRequest): F[avias.ecs.models.DiscoverPollEndpointResponse] 29 | def createCluster(input: avias.ecs.models.CreateClusterRequest): F[avias.ecs.models.CreateClusterResponse] 30 | def updateContainerAgent(input: avias.ecs.models.UpdateContainerAgentRequest): F[avias.ecs.models.UpdateContainerAgentResponse] 31 | def describeTasks(input: avias.ecs.models.DescribeTasksRequest): F[avias.ecs.models.DescribeTasksResponse] 32 | def listTaskDefinitionFamilies(input: avias.ecs.models.ListTaskDefinitionFamiliesRequest): F[avias.ecs.models.ListTaskDefinitionFamiliesResponse] 33 | def listServices(input: avias.ecs.models.ListServicesRequest): F[avias.ecs.models.ListServicesResponse] 34 | } -------------------------------------------------------------------------------- /services/machinelearning/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.machinelearning 2 | trait Amazonmachinelearning[F[_]] { 3 | def describeTags(input: avias.machinelearning.models.DescribeTagsInput): F[avias.machinelearning.models.DescribeTagsOutput] 4 | def createEvaluation(input: avias.machinelearning.models.CreateEvaluationInput): F[avias.machinelearning.models.CreateEvaluationOutput] 5 | def createDataSourceFromRedshift(input: avias.machinelearning.models.CreateDataSourceFromRedshiftInput): F[avias.machinelearning.models.CreateDataSourceFromRedshiftOutput] 6 | def describeBatchPredictions(input: avias.machinelearning.models.DescribeBatchPredictionsInput): F[avias.machinelearning.models.DescribeBatchPredictionsOutput] 7 | def createDataSourceFromRDS(input: avias.machinelearning.models.CreateDataSourceFromRDSInput): F[avias.machinelearning.models.CreateDataSourceFromRDSOutput] 8 | def createBatchPrediction(input: avias.machinelearning.models.CreateBatchPredictionInput): F[avias.machinelearning.models.CreateBatchPredictionOutput] 9 | def addTags(input: avias.machinelearning.models.AddTagsInput): F[avias.machinelearning.models.AddTagsOutput] 10 | def updateDataSource(input: avias.machinelearning.models.UpdateDataSourceInput): F[avias.machinelearning.models.UpdateDataSourceOutput] 11 | def deleteMLModel(input: avias.machinelearning.models.DeleteMLModelInput): F[avias.machinelearning.models.DeleteMLModelOutput] 12 | def deleteEvaluation(input: avias.machinelearning.models.DeleteEvaluationInput): F[avias.machinelearning.models.DeleteEvaluationOutput] 13 | def describeEvaluations(input: avias.machinelearning.models.DescribeEvaluationsInput): F[avias.machinelearning.models.DescribeEvaluationsOutput] 14 | def predict(input: avias.machinelearning.models.PredictInput): F[avias.machinelearning.models.PredictOutput] 15 | def describeDataSources(input: avias.machinelearning.models.DescribeDataSourcesInput): F[avias.machinelearning.models.DescribeDataSourcesOutput] 16 | def createDataSourceFromS3(input: avias.machinelearning.models.CreateDataSourceFromS3Input): F[avias.machinelearning.models.CreateDataSourceFromS3Output] 17 | def deleteDataSource(input: avias.machinelearning.models.DeleteDataSourceInput): F[avias.machinelearning.models.DeleteDataSourceOutput] 18 | def getBatchPrediction(input: avias.machinelearning.models.GetBatchPredictionInput): F[avias.machinelearning.models.GetBatchPredictionOutput] 19 | def deleteRealtimeEndpoint(input: avias.machinelearning.models.DeleteRealtimeEndpointInput): F[avias.machinelearning.models.DeleteRealtimeEndpointOutput] 20 | def describeMLModels(input: avias.machinelearning.models.DescribeMLModelsInput): F[avias.machinelearning.models.DescribeMLModelsOutput] 21 | def deleteBatchPrediction(input: avias.machinelearning.models.DeleteBatchPredictionInput): F[avias.machinelearning.models.DeleteBatchPredictionOutput] 22 | def createMLModel(input: avias.machinelearning.models.CreateMLModelInput): F[avias.machinelearning.models.CreateMLModelOutput] 23 | def updateBatchPrediction(input: avias.machinelearning.models.UpdateBatchPredictionInput): F[avias.machinelearning.models.UpdateBatchPredictionOutput] 24 | def getMLModel(input: avias.machinelearning.models.GetMLModelInput): F[avias.machinelearning.models.GetMLModelOutput] 25 | def updateMLModel(input: avias.machinelearning.models.UpdateMLModelInput): F[avias.machinelearning.models.UpdateMLModelOutput] 26 | def getEvaluation(input: avias.machinelearning.models.GetEvaluationInput): F[avias.machinelearning.models.GetEvaluationOutput] 27 | def createRealtimeEndpoint(input: avias.machinelearning.models.CreateRealtimeEndpointInput): F[avias.machinelearning.models.CreateRealtimeEndpointOutput] 28 | def updateEvaluation(input: avias.machinelearning.models.UpdateEvaluationInput): F[avias.machinelearning.models.UpdateEvaluationOutput] 29 | def deleteTags(input: avias.machinelearning.models.DeleteTagsInput): F[avias.machinelearning.models.DeleteTagsOutput] 30 | def getDataSource(input: avias.machinelearning.models.GetDataSourceInput): F[avias.machinelearning.models.GetDataSourceOutput] 31 | } -------------------------------------------------------------------------------- /services/simpleworkflow/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.simpleworkflow 2 | trait Amazonsimpleworkflow[F[_]] { 3 | def countClosedWorkflowExecutions(input: avias.simpleworkflow.models.CountClosedWorkflowExecutionsInput): F[avias.simpleworkflow.models.WorkflowExecutionCount] 4 | def listClosedWorkflowExecutions(input: avias.simpleworkflow.models.ListClosedWorkflowExecutionsInput): F[avias.simpleworkflow.models.WorkflowExecutionInfos] 5 | def deprecateActivityType(input: avias.simpleworkflow.models.DeprecateActivityTypeInput): F[scala.Unit] 6 | def registerWorkflowType(input: avias.simpleworkflow.models.RegisterWorkflowTypeInput): F[scala.Unit] 7 | def listDomains(input: avias.simpleworkflow.models.ListDomainsInput): F[avias.simpleworkflow.models.DomainInfos] 8 | def respondActivityTaskFailed(input: avias.simpleworkflow.models.RespondActivityTaskFailedInput): F[scala.Unit] 9 | def listWorkflowTypes(input: avias.simpleworkflow.models.ListWorkflowTypesInput): F[avias.simpleworkflow.models.WorkflowTypeInfos] 10 | def describeWorkflowType(input: avias.simpleworkflow.models.DescribeWorkflowTypeInput): F[avias.simpleworkflow.models.WorkflowTypeDetail] 11 | def listActivityTypes(input: avias.simpleworkflow.models.ListActivityTypesInput): F[avias.simpleworkflow.models.ActivityTypeInfos] 12 | def countPendingActivityTasks(input: avias.simpleworkflow.models.CountPendingActivityTasksInput): F[avias.simpleworkflow.models.PendingTaskCount] 13 | def startWorkflowExecution(input: avias.simpleworkflow.models.StartWorkflowExecutionInput): F[avias.simpleworkflow.models.Run] 14 | def registerDomain(input: avias.simpleworkflow.models.RegisterDomainInput): F[scala.Unit] 15 | def recordActivityTaskHeartbeat(input: avias.simpleworkflow.models.RecordActivityTaskHeartbeatInput): F[avias.simpleworkflow.models.ActivityTaskStatus] 16 | def describeActivityType(input: avias.simpleworkflow.models.DescribeActivityTypeInput): F[avias.simpleworkflow.models.ActivityTypeDetail] 17 | def getWorkflowExecutionHistory(input: avias.simpleworkflow.models.GetWorkflowExecutionHistoryInput): F[avias.simpleworkflow.models.History] 18 | def pollForDecisionTask(input: avias.simpleworkflow.models.PollForDecisionTaskInput): F[avias.simpleworkflow.models.DecisionTask] 19 | def countOpenWorkflowExecutions(input: avias.simpleworkflow.models.CountOpenWorkflowExecutionsInput): F[avias.simpleworkflow.models.WorkflowExecutionCount] 20 | def listOpenWorkflowExecutions(input: avias.simpleworkflow.models.ListOpenWorkflowExecutionsInput): F[avias.simpleworkflow.models.WorkflowExecutionInfos] 21 | def pollForActivityTask(input: avias.simpleworkflow.models.PollForActivityTaskInput): F[avias.simpleworkflow.models.ActivityTask] 22 | def terminateWorkflowExecution(input: avias.simpleworkflow.models.TerminateWorkflowExecutionInput): F[scala.Unit] 23 | def describeDomain(input: avias.simpleworkflow.models.DescribeDomainInput): F[avias.simpleworkflow.models.DomainDetail] 24 | def respondDecisionTaskCompleted(input: avias.simpleworkflow.models.RespondDecisionTaskCompletedInput): F[scala.Unit] 25 | def deprecateWorkflowType(input: avias.simpleworkflow.models.DeprecateWorkflowTypeInput): F[scala.Unit] 26 | def signalWorkflowExecution(input: avias.simpleworkflow.models.SignalWorkflowExecutionInput): F[scala.Unit] 27 | def describeWorkflowExecution(input: avias.simpleworkflow.models.DescribeWorkflowExecutionInput): F[avias.simpleworkflow.models.WorkflowExecutionDetail] 28 | def respondActivityTaskCompleted(input: avias.simpleworkflow.models.RespondActivityTaskCompletedInput): F[scala.Unit] 29 | def countPendingDecisionTasks(input: avias.simpleworkflow.models.CountPendingDecisionTasksInput): F[avias.simpleworkflow.models.PendingTaskCount] 30 | def registerActivityType(input: avias.simpleworkflow.models.RegisterActivityTypeInput): F[scala.Unit] 31 | def respondActivityTaskCanceled(input: avias.simpleworkflow.models.RespondActivityTaskCanceledInput): F[scala.Unit] 32 | def deprecateDomain(input: avias.simpleworkflow.models.DeprecateDomainInput): F[scala.Unit] 33 | def requestCancelWorkflowExecution(input: avias.simpleworkflow.models.RequestCancelWorkflowExecutionInput): F[scala.Unit] 34 | } -------------------------------------------------------------------------------- /services/athena/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.athena.http4s 2 | import org.http4s.Method._ 3 | import avias.athena.circe._ 4 | import avias.athena.models 5 | class AmazonathenaClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.athena.Amazonathena[F] { 6 | private[this] final val ServiceType: String = "athena" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("AmazonAthena") 8 | override def listQueryExecutions(input: avias.athena.models.ListQueryExecutionsInput): F[avias.athena.models.ListQueryExecutionsOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.athena.models.ListQueryExecutionsOutput, avias.athena.models.ListQueryExecutionsInput](client, awsData, ServiceType, ServiceAndPrefix, "ListQueryExecutions", POST, "/", input) 9 | override def getQueryExecution(input: avias.athena.models.GetQueryExecutionInput): F[avias.athena.models.GetQueryExecutionOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.athena.models.GetQueryExecutionOutput, avias.athena.models.GetQueryExecutionInput](client, awsData, ServiceType, ServiceAndPrefix, "GetQueryExecution", POST, "/", input) 10 | override def deleteNamedQuery(input: avias.athena.models.DeleteNamedQueryInput): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.athena.models.DeleteNamedQueryInput](client, awsData, ServiceType, ServiceAndPrefix, "DeleteNamedQuery", POST, "/", input) 11 | override def batchGetQueryExecution(input: avias.athena.models.BatchGetQueryExecutionInput): F[avias.athena.models.BatchGetQueryExecutionOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.athena.models.BatchGetQueryExecutionOutput, avias.athena.models.BatchGetQueryExecutionInput](client, awsData, ServiceType, ServiceAndPrefix, "BatchGetQueryExecution", POST, "/", input) 12 | override def getNamedQuery(input: avias.athena.models.GetNamedQueryInput): F[avias.athena.models.GetNamedQueryOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.athena.models.GetNamedQueryOutput, avias.athena.models.GetNamedQueryInput](client, awsData, ServiceType, ServiceAndPrefix, "GetNamedQuery", POST, "/", input) 13 | override def stopQueryExecution(input: avias.athena.models.StopQueryExecutionInput): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.athena.models.StopQueryExecutionInput](client, awsData, ServiceType, ServiceAndPrefix, "StopQueryExecution", POST, "/", input) 14 | override def getQueryResults(input: avias.athena.models.GetQueryResultsInput): F[avias.athena.models.GetQueryResultsOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.athena.models.GetQueryResultsOutput, avias.athena.models.GetQueryResultsInput](client, awsData, ServiceType, ServiceAndPrefix, "GetQueryResults", POST, "/", input) 15 | override def createNamedQuery(input: avias.athena.models.CreateNamedQueryInput): F[avias.athena.models.CreateNamedQueryOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.athena.models.CreateNamedQueryOutput, avias.athena.models.CreateNamedQueryInput](client, awsData, ServiceType, ServiceAndPrefix, "CreateNamedQuery", POST, "/", input) 16 | override def startQueryExecution(input: avias.athena.models.StartQueryExecutionInput): F[avias.athena.models.StartQueryExecutionOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.athena.models.StartQueryExecutionOutput, avias.athena.models.StartQueryExecutionInput](client, awsData, ServiceType, ServiceAndPrefix, "StartQueryExecution", POST, "/", input) 17 | override def batchGetNamedQuery(input: avias.athena.models.BatchGetNamedQueryInput): F[avias.athena.models.BatchGetNamedQueryOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.athena.models.BatchGetNamedQueryOutput, avias.athena.models.BatchGetNamedQueryInput](client, awsData, ServiceType, ServiceAndPrefix, "BatchGetNamedQuery", POST, "/", input) 18 | override def listNamedQueries(input: avias.athena.models.ListNamedQueriesInput): F[avias.athena.models.ListNamedQueriesOutput] = avias.common.http4s.ClientUtils.doRequest[F, avias.athena.models.ListNamedQueriesOutput, avias.athena.models.ListNamedQueriesInput](client, awsData, ServiceType, ServiceAndPrefix, "ListNamedQueries", POST, "/", input) 19 | } -------------------------------------------------------------------------------- /services/servermigration/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.servermigration.http4s 2 | import org.http4s.Method._ 3 | import avias.servermigration.circe._ 4 | import avias.servermigration.models 5 | class AmazonservermigrationClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.servermigration.Amazonservermigration[F] { 6 | private[this] final val ServiceType: String = "sms" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("AWSServerMigrationService_V2016_10_24") 8 | override def getReplicationRuns(input: avias.servermigration.models.GetReplicationRunsRequest): F[avias.servermigration.models.GetReplicationRunsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.servermigration.models.GetReplicationRunsResponse, avias.servermigration.models.GetReplicationRunsRequest](client, awsData, ServiceType, ServiceAndPrefix, "GetReplicationRuns", POST, "/", input) 9 | override def updateReplicationJob(input: avias.servermigration.models.UpdateReplicationJobRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.servermigration.models.UpdateReplicationJobRequest](client, awsData, ServiceType, ServiceAndPrefix, "UpdateReplicationJob", POST, "/", input) 10 | override def getServers(input: avias.servermigration.models.GetServersRequest): F[avias.servermigration.models.GetServersResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.servermigration.models.GetServersResponse, avias.servermigration.models.GetServersRequest](client, awsData, ServiceType, ServiceAndPrefix, "GetServers", POST, "/", input) 11 | override def getConnectors(input: avias.servermigration.models.GetConnectorsRequest): F[avias.servermigration.models.GetConnectorsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.servermigration.models.GetConnectorsResponse, avias.servermigration.models.GetConnectorsRequest](client, awsData, ServiceType, ServiceAndPrefix, "GetConnectors", POST, "/", input) 12 | override def startOnDemandReplicationRun(input: avias.servermigration.models.StartOnDemandReplicationRunRequest): F[avias.servermigration.models.StartOnDemandReplicationRunResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.servermigration.models.StartOnDemandReplicationRunResponse, avias.servermigration.models.StartOnDemandReplicationRunRequest](client, awsData, ServiceType, ServiceAndPrefix, "StartOnDemandReplicationRun", POST, "/", input) 13 | override def deleteReplicationJob(input: avias.servermigration.models.DeleteReplicationJobRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.servermigration.models.DeleteReplicationJobRequest](client, awsData, ServiceType, ServiceAndPrefix, "DeleteReplicationJob", POST, "/", input) 14 | override def disassociateConnector(input: avias.servermigration.models.DisassociateConnectorRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.servermigration.models.DisassociateConnectorRequest](client, awsData, ServiceType, ServiceAndPrefix, "DisassociateConnector", POST, "/", input) 15 | override def getReplicationJobs(input: avias.servermigration.models.GetReplicationJobsRequest): F[avias.servermigration.models.GetReplicationJobsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.servermigration.models.GetReplicationJobsResponse, avias.servermigration.models.GetReplicationJobsRequest](client, awsData, ServiceType, ServiceAndPrefix, "GetReplicationJobs", POST, "/", input) 16 | override def deleteServerCatalog: F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, scala.Unit](client, awsData, ServiceType, ServiceAndPrefix, "DeleteServerCatalog", POST, "/", ()) 17 | override def importServerCatalog: F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, scala.Unit](client, awsData, ServiceType, ServiceAndPrefix, "ImportServerCatalog", POST, "/", ()) 18 | override def createReplicationJob(input: avias.servermigration.models.CreateReplicationJobRequest): F[avias.servermigration.models.CreateReplicationJobResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.servermigration.models.CreateReplicationJobResponse, avias.servermigration.models.CreateReplicationJobRequest](client, awsData, ServiceType, ServiceAndPrefix, "CreateReplicationJob", POST, "/", input) 19 | } -------------------------------------------------------------------------------- /services/marketplacecommerceanalytics/circe/src/main/scala/avias/CirceImplicits.scala: -------------------------------------------------------------------------------- 1 | package avias.marketplacecommerceanalytics 2 | import cats.implicits._ 3 | import io.circe._ 4 | import io.circe.syntax._ 5 | object circe extends avias.common.DefaultCodecs { 6 | final implicit val GenerateDataSetRequestEncoder: io.circe.Encoder[avias.marketplacecommerceanalytics.models.GenerateDataSetRequest] = io.circe.Encoder.instance { o => 7 | Json.obj("dataSetPublicationDate" -> o.dataSetPublicationDate.asJson, "roleNameArn" -> o.roleNameArn.asJson, "snsTopicArn" -> o.snsTopicArn.asJson, "destinationS3BucketName" -> o.destinationS3BucketName.asJson, "dataSetType" -> o.dataSetType.asJson, "destinationS3Prefix" -> o.destinationS3Prefix.asJson, "customerDefinedValues" -> o.customerDefinedValues.asJson) 8 | } 9 | final implicit val StartSupportDataExportRequestEncoder: io.circe.Encoder[avias.marketplacecommerceanalytics.models.StartSupportDataExportRequest] = io.circe.Encoder.instance { o => 10 | Json.obj("dataSetType" -> o.dataSetType.asJson, "roleNameArn" -> o.roleNameArn.asJson, "snsTopicArn" -> o.snsTopicArn.asJson, "destinationS3BucketName" -> o.destinationS3BucketName.asJson, "fromDate" -> o.fromDate.asJson, "destinationS3Prefix" -> o.destinationS3Prefix.asJson, "customerDefinedValues" -> o.customerDefinedValues.asJson) 11 | } 12 | final implicit val MarketplaceCommerceAnalyticsExceptionEncoder: io.circe.Encoder[avias.marketplacecommerceanalytics.models.MarketplaceCommerceAnalyticsException] = io.circe.Encoder.instance { o => 13 | Json.obj("message" -> o.message.asJson) 14 | } 15 | final implicit val StartSupportDataExportResultEncoder: io.circe.Encoder[avias.marketplacecommerceanalytics.models.StartSupportDataExportResult] = io.circe.Encoder.instance { o => 16 | Json.obj("dataSetRequestId" -> o.dataSetRequestId.asJson) 17 | } 18 | final implicit val GenerateDataSetResultEncoder: io.circe.Encoder[avias.marketplacecommerceanalytics.models.GenerateDataSetResult] = io.circe.Encoder.instance { o => 19 | Json.obj("dataSetRequestId" -> o.dataSetRequestId.asJson) 20 | } 21 | final implicit val GenerateDataSetRequestDecoder: io.circe.Decoder[avias.marketplacecommerceanalytics.models.GenerateDataSetRequest] = io.circe.Decoder.instance { o => 22 | (o.get[java.time.Instant]("dataSetPublicationDate"), o.get[java.lang.String]("roleNameArn"), o.get[java.lang.String]("snsTopicArn"), o.get[java.lang.String]("destinationS3BucketName"), o.get[java.lang.String]("dataSetType"), o.get[scala.Option[java.lang.String]]("destinationS3Prefix"), o.get[scala.Option[scala.collection.immutable.Map[java.lang.String, java.lang.String]]]("customerDefinedValues")).mapN(avias.marketplacecommerceanalytics.models.GenerateDataSetRequest.apply _) 23 | } 24 | final implicit val StartSupportDataExportRequestDecoder: io.circe.Decoder[avias.marketplacecommerceanalytics.models.StartSupportDataExportRequest] = io.circe.Decoder.instance { o => 25 | (o.get[java.lang.String]("dataSetType"), o.get[java.lang.String]("roleNameArn"), o.get[java.lang.String]("snsTopicArn"), o.get[java.lang.String]("destinationS3BucketName"), o.get[java.time.Instant]("fromDate"), o.get[scala.Option[java.lang.String]]("destinationS3Prefix"), o.get[scala.Option[scala.collection.immutable.Map[java.lang.String, java.lang.String]]]("customerDefinedValues")).mapN(avias.marketplacecommerceanalytics.models.StartSupportDataExportRequest.apply _) 26 | } 27 | final implicit val MarketplaceCommerceAnalyticsExceptionDecoder: io.circe.Decoder[avias.marketplacecommerceanalytics.models.MarketplaceCommerceAnalyticsException] = io.circe.Decoder.instance { o => 28 | o.get[scala.Option[java.lang.String]]("message").map(avias.marketplacecommerceanalytics.models.MarketplaceCommerceAnalyticsException.apply _) 29 | } 30 | final implicit val StartSupportDataExportResultDecoder: io.circe.Decoder[avias.marketplacecommerceanalytics.models.StartSupportDataExportResult] = io.circe.Decoder.instance { o => 31 | o.get[scala.Option[java.lang.String]]("dataSetRequestId").map(avias.marketplacecommerceanalytics.models.StartSupportDataExportResult.apply _) 32 | } 33 | final implicit val GenerateDataSetResultDecoder: io.circe.Decoder[avias.marketplacecommerceanalytics.models.GenerateDataSetResult] = io.circe.Decoder.instance { o => 34 | o.get[scala.Option[java.lang.String]]("dataSetRequestId").map(avias.marketplacecommerceanalytics.models.GenerateDataSetResult.apply _) 35 | } 36 | } -------------------------------------------------------------------------------- /services/inspector/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.inspector 2 | trait Amazoninspector[F[_]] { 3 | def createAssessmentTemplate(input: avias.inspector.models.CreateAssessmentTemplateRequest): F[avias.inspector.models.CreateAssessmentTemplateResponse] 4 | def removeAttributesFromFindings(input: avias.inspector.models.RemoveAttributesFromFindingsRequest): F[avias.inspector.models.RemoveAttributesFromFindingsResponse] 5 | def listEventSubscriptions(input: avias.inspector.models.ListEventSubscriptionsRequest): F[avias.inspector.models.ListEventSubscriptionsResponse] 6 | def setTagsForResource(input: avias.inspector.models.SetTagsForResourceRequest): F[scala.Unit] 7 | def listFindings(input: avias.inspector.models.ListFindingsRequest): F[avias.inspector.models.ListFindingsResponse] 8 | def listTagsForResource(input: avias.inspector.models.ListTagsForResourceRequest): F[avias.inspector.models.ListTagsForResourceResponse] 9 | def unsubscribeFromEvent(input: avias.inspector.models.UnsubscribeFromEventRequest): F[scala.Unit] 10 | def describeRulesPackages(input: avias.inspector.models.DescribeRulesPackagesRequest): F[avias.inspector.models.DescribeRulesPackagesResponse] 11 | def addAttributesToFindings(input: avias.inspector.models.AddAttributesToFindingsRequest): F[avias.inspector.models.AddAttributesToFindingsResponse] 12 | def updateAssessmentTarget(input: avias.inspector.models.UpdateAssessmentTargetRequest): F[scala.Unit] 13 | def listRulesPackages(input: avias.inspector.models.ListRulesPackagesRequest): F[avias.inspector.models.ListRulesPackagesResponse] 14 | def describeAssessmentTemplates(input: avias.inspector.models.DescribeAssessmentTemplatesRequest): F[avias.inspector.models.DescribeAssessmentTemplatesResponse] 15 | def listAssessmentRuns(input: avias.inspector.models.ListAssessmentRunsRequest): F[avias.inspector.models.ListAssessmentRunsResponse] 16 | def describeFindings(input: avias.inspector.models.DescribeFindingsRequest): F[avias.inspector.models.DescribeFindingsResponse] 17 | def listAssessmentTargets(input: avias.inspector.models.ListAssessmentTargetsRequest): F[avias.inspector.models.ListAssessmentTargetsResponse] 18 | def describeResourceGroups(input: avias.inspector.models.DescribeResourceGroupsRequest): F[avias.inspector.models.DescribeResourceGroupsResponse] 19 | def getTelemetryMetadata(input: avias.inspector.models.GetTelemetryMetadataRequest): F[avias.inspector.models.GetTelemetryMetadataResponse] 20 | def deleteAssessmentTarget(input: avias.inspector.models.DeleteAssessmentTargetRequest): F[scala.Unit] 21 | def describeAssessmentRuns(input: avias.inspector.models.DescribeAssessmentRunsRequest): F[avias.inspector.models.DescribeAssessmentRunsResponse] 22 | def previewAgents(input: avias.inspector.models.PreviewAgentsRequest): F[avias.inspector.models.PreviewAgentsResponse] 23 | def registerCrossAccountAccessRole(input: avias.inspector.models.RegisterCrossAccountAccessRoleRequest): F[scala.Unit] 24 | def describeAssessmentTargets(input: avias.inspector.models.DescribeAssessmentTargetsRequest): F[avias.inspector.models.DescribeAssessmentTargetsResponse] 25 | def deleteAssessmentRun(input: avias.inspector.models.DeleteAssessmentRunRequest): F[scala.Unit] 26 | def listAssessmentRunAgents(input: avias.inspector.models.ListAssessmentRunAgentsRequest): F[avias.inspector.models.ListAssessmentRunAgentsResponse] 27 | def getAssessmentReport(input: avias.inspector.models.GetAssessmentReportRequest): F[avias.inspector.models.GetAssessmentReportResponse] 28 | def describeCrossAccountAccessRole: F[avias.inspector.models.DescribeCrossAccountAccessRoleResponse] 29 | def startAssessmentRun(input: avias.inspector.models.StartAssessmentRunRequest): F[avias.inspector.models.StartAssessmentRunResponse] 30 | def deleteAssessmentTemplate(input: avias.inspector.models.DeleteAssessmentTemplateRequest): F[scala.Unit] 31 | def createResourceGroup(input: avias.inspector.models.CreateResourceGroupRequest): F[avias.inspector.models.CreateResourceGroupResponse] 32 | def subscribeToEvent(input: avias.inspector.models.SubscribeToEventRequest): F[scala.Unit] 33 | def createAssessmentTarget(input: avias.inspector.models.CreateAssessmentTargetRequest): F[avias.inspector.models.CreateAssessmentTargetResponse] 34 | def stopAssessmentRun(input: avias.inspector.models.StopAssessmentRunRequest): F[scala.Unit] 35 | def listAssessmentTemplates(input: avias.inspector.models.ListAssessmentTemplatesRequest): F[avias.inspector.models.ListAssessmentTemplatesResponse] 36 | } -------------------------------------------------------------------------------- /services/applicationautoscaling/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.applicationautoscaling.http4s 2 | import org.http4s.Method._ 3 | import avias.applicationautoscaling.circe._ 4 | import avias.applicationautoscaling.models 5 | class AmazonapplicationautoscalingClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.applicationautoscaling.Amazonapplicationautoscaling[F] { 6 | private[this] final val ServiceType: String = "autoscaling" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("AnyScaleFrontendService") 8 | override def deregisterScalableTarget(input: avias.applicationautoscaling.models.DeregisterScalableTargetRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.applicationautoscaling.models.DeregisterScalableTargetRequest](client, awsData, ServiceType, ServiceAndPrefix, "DeregisterScalableTarget", POST, "/", input) 9 | override def registerScalableTarget(input: avias.applicationautoscaling.models.RegisterScalableTargetRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.applicationautoscaling.models.RegisterScalableTargetRequest](client, awsData, ServiceType, ServiceAndPrefix, "RegisterScalableTarget", POST, "/", input) 10 | override def describeScalingActivities(input: avias.applicationautoscaling.models.DescribeScalingActivitiesRequest): F[avias.applicationautoscaling.models.DescribeScalingActivitiesResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.applicationautoscaling.models.DescribeScalingActivitiesResponse, avias.applicationautoscaling.models.DescribeScalingActivitiesRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeScalingActivities", POST, "/", input) 11 | override def deleteScalingPolicy(input: avias.applicationautoscaling.models.DeleteScalingPolicyRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.applicationautoscaling.models.DeleteScalingPolicyRequest](client, awsData, ServiceType, ServiceAndPrefix, "DeleteScalingPolicy", POST, "/", input) 12 | override def deleteScheduledAction(input: avias.applicationautoscaling.models.DeleteScheduledActionRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.applicationautoscaling.models.DeleteScheduledActionRequest](client, awsData, ServiceType, ServiceAndPrefix, "DeleteScheduledAction", POST, "/", input) 13 | override def putScalingPolicy(input: avias.applicationautoscaling.models.PutScalingPolicyRequest): F[avias.applicationautoscaling.models.PutScalingPolicyResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.applicationautoscaling.models.PutScalingPolicyResponse, avias.applicationautoscaling.models.PutScalingPolicyRequest](client, awsData, ServiceType, ServiceAndPrefix, "PutScalingPolicy", POST, "/", input) 14 | override def describeScalableTargets(input: avias.applicationautoscaling.models.DescribeScalableTargetsRequest): F[avias.applicationautoscaling.models.DescribeScalableTargetsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.applicationautoscaling.models.DescribeScalableTargetsResponse, avias.applicationautoscaling.models.DescribeScalableTargetsRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeScalableTargets", POST, "/", input) 15 | override def putScheduledAction(input: avias.applicationautoscaling.models.PutScheduledActionRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.applicationautoscaling.models.PutScheduledActionRequest](client, awsData, ServiceType, ServiceAndPrefix, "PutScheduledAction", POST, "/", input) 16 | override def describeScalingPolicies(input: avias.applicationautoscaling.models.DescribeScalingPoliciesRequest): F[avias.applicationautoscaling.models.DescribeScalingPoliciesResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.applicationautoscaling.models.DescribeScalingPoliciesResponse, avias.applicationautoscaling.models.DescribeScalingPoliciesRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeScalingPolicies", POST, "/", input) 17 | override def describeScheduledActions(input: avias.applicationautoscaling.models.DescribeScheduledActionsRequest): F[avias.applicationautoscaling.models.DescribeScheduledActionsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.applicationautoscaling.models.DescribeScheduledActionsResponse, avias.applicationautoscaling.models.DescribeScheduledActionsRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeScheduledActions", POST, "/", input) 18 | } -------------------------------------------------------------------------------- /services/budgets/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.budgets.http4s 2 | import org.http4s.Method._ 3 | import avias.budgets.circe._ 4 | import avias.budgets.models 5 | class AmazonbudgetsClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.budgets.Amazonbudgets[F] { 6 | private[this] final val ServiceType: String = "budgets" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("AWSBudgetServiceGateway") 8 | override def describeSubscribersForNotification(input: avias.budgets.models.DescribeSubscribersForNotificationRequest): F[avias.budgets.models.DescribeSubscribersForNotificationResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.budgets.models.DescribeSubscribersForNotificationResponse, avias.budgets.models.DescribeSubscribersForNotificationRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeSubscribersForNotification", POST, "/", input) 9 | override def createSubscriber(input: avias.budgets.models.CreateSubscriberRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.budgets.models.CreateSubscriberRequest](client, awsData, ServiceType, ServiceAndPrefix, "CreateSubscriber", POST, "/", input) 10 | override def deleteSubscriber(input: avias.budgets.models.DeleteSubscriberRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.budgets.models.DeleteSubscriberRequest](client, awsData, ServiceType, ServiceAndPrefix, "DeleteSubscriber", POST, "/", input) 11 | override def createBudget(input: avias.budgets.models.CreateBudgetRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.budgets.models.CreateBudgetRequest](client, awsData, ServiceType, ServiceAndPrefix, "CreateBudget", POST, "/", input) 12 | override def describeBudget(input: avias.budgets.models.DescribeBudgetRequest): F[avias.budgets.models.DescribeBudgetResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.budgets.models.DescribeBudgetResponse, avias.budgets.models.DescribeBudgetRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeBudget", POST, "/", input) 13 | override def deleteBudget(input: avias.budgets.models.DeleteBudgetRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.budgets.models.DeleteBudgetRequest](client, awsData, ServiceType, ServiceAndPrefix, "DeleteBudget", POST, "/", input) 14 | override def updateSubscriber(input: avias.budgets.models.UpdateSubscriberRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.budgets.models.UpdateSubscriberRequest](client, awsData, ServiceType, ServiceAndPrefix, "UpdateSubscriber", POST, "/", input) 15 | override def describeNotificationsForBudget(input: avias.budgets.models.DescribeNotificationsForBudgetRequest): F[avias.budgets.models.DescribeNotificationsForBudgetResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.budgets.models.DescribeNotificationsForBudgetResponse, avias.budgets.models.DescribeNotificationsForBudgetRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeNotificationsForBudget", POST, "/", input) 16 | override def describeBudgets(input: avias.budgets.models.DescribeBudgetsRequest): F[avias.budgets.models.DescribeBudgetsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.budgets.models.DescribeBudgetsResponse, avias.budgets.models.DescribeBudgetsRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeBudgets", POST, "/", input) 17 | override def updateBudget(input: avias.budgets.models.UpdateBudgetRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.budgets.models.UpdateBudgetRequest](client, awsData, ServiceType, ServiceAndPrefix, "UpdateBudget", POST, "/", input) 18 | override def deleteNotification(input: avias.budgets.models.DeleteNotificationRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.budgets.models.DeleteNotificationRequest](client, awsData, ServiceType, ServiceAndPrefix, "DeleteNotification", POST, "/", input) 19 | override def createNotification(input: avias.budgets.models.CreateNotificationRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.budgets.models.CreateNotificationRequest](client, awsData, ServiceType, ServiceAndPrefix, "CreateNotification", POST, "/", input) 20 | override def updateNotification(input: avias.budgets.models.UpdateNotificationRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.budgets.models.UpdateNotificationRequest](client, awsData, ServiceType, ServiceAndPrefix, "UpdateNotification", POST, "/", input) 21 | } -------------------------------------------------------------------------------- /services/codecommit/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.codecommit 2 | trait Amazoncodecommit[F[_]] { 3 | def getDifferences(input: avias.codecommit.models.GetDifferencesInput): F[avias.codecommit.models.GetDifferencesOutput] 4 | def deleteRepository(input: avias.codecommit.models.DeleteRepositoryInput): F[avias.codecommit.models.DeleteRepositoryOutput] 5 | def deleteCommentContent(input: avias.codecommit.models.DeleteCommentContentInput): F[avias.codecommit.models.DeleteCommentContentOutput] 6 | def getBlob(input: avias.codecommit.models.GetBlobInput): F[avias.codecommit.models.GetBlobOutput] 7 | def getBranch(input: avias.codecommit.models.GetBranchInput): F[avias.codecommit.models.GetBranchOutput] 8 | def getPullRequest(input: avias.codecommit.models.GetPullRequestInput): F[avias.codecommit.models.GetPullRequestOutput] 9 | def describePullRequestEvents(input: avias.codecommit.models.DescribePullRequestEventsInput): F[avias.codecommit.models.DescribePullRequestEventsOutput] 10 | def getComment(input: avias.codecommit.models.GetCommentInput): F[avias.codecommit.models.GetCommentOutput] 11 | def getRepositoryTriggers(input: avias.codecommit.models.GetRepositoryTriggersInput): F[avias.codecommit.models.GetRepositoryTriggersOutput] 12 | def updatePullRequestTitle(input: avias.codecommit.models.UpdatePullRequestTitleInput): F[avias.codecommit.models.UpdatePullRequestTitleOutput] 13 | def updateComment(input: avias.codecommit.models.UpdateCommentInput): F[avias.codecommit.models.UpdateCommentOutput] 14 | def postCommentReply(input: avias.codecommit.models.PostCommentReplyInput): F[avias.codecommit.models.PostCommentReplyOutput] 15 | def getRepository(input: avias.codecommit.models.GetRepositoryInput): F[avias.codecommit.models.GetRepositoryOutput] 16 | def createBranch(input: avias.codecommit.models.CreateBranchInput): F[scala.Unit] 17 | def updateRepositoryDescription(input: avias.codecommit.models.UpdateRepositoryDescriptionInput): F[scala.Unit] 18 | def getCommentsForComparedCommit(input: avias.codecommit.models.GetCommentsForComparedCommitInput): F[avias.codecommit.models.GetCommentsForComparedCommitOutput] 19 | def getMergeConflicts(input: avias.codecommit.models.GetMergeConflictsInput): F[avias.codecommit.models.GetMergeConflictsOutput] 20 | def createRepository(input: avias.codecommit.models.CreateRepositoryInput): F[avias.codecommit.models.CreateRepositoryOutput] 21 | def listRepositories(input: avias.codecommit.models.ListRepositoriesInput): F[avias.codecommit.models.ListRepositoriesOutput] 22 | def getCommentsForPullRequest(input: avias.codecommit.models.GetCommentsForPullRequestInput): F[avias.codecommit.models.GetCommentsForPullRequestOutput] 23 | def putRepositoryTriggers(input: avias.codecommit.models.PutRepositoryTriggersInput): F[avias.codecommit.models.PutRepositoryTriggersOutput] 24 | def listPullRequests(input: avias.codecommit.models.ListPullRequestsInput): F[avias.codecommit.models.ListPullRequestsOutput] 25 | def createPullRequest(input: avias.codecommit.models.CreatePullRequestInput): F[avias.codecommit.models.CreatePullRequestOutput] 26 | def updatePullRequestDescription(input: avias.codecommit.models.UpdatePullRequestDescriptionInput): F[avias.codecommit.models.UpdatePullRequestDescriptionOutput] 27 | def postCommentForPullRequest(input: avias.codecommit.models.PostCommentForPullRequestInput): F[avias.codecommit.models.PostCommentForPullRequestOutput] 28 | def getCommit(input: avias.codecommit.models.GetCommitInput): F[avias.codecommit.models.GetCommitOutput] 29 | def testRepositoryTriggers(input: avias.codecommit.models.TestRepositoryTriggersInput): F[avias.codecommit.models.TestRepositoryTriggersOutput] 30 | def batchGetRepositories(input: avias.codecommit.models.BatchGetRepositoriesInput): F[avias.codecommit.models.BatchGetRepositoriesOutput] 31 | def updateRepositoryName(input: avias.codecommit.models.UpdateRepositoryNameInput): F[scala.Unit] 32 | def mergePullRequestByFastForward(input: avias.codecommit.models.MergePullRequestByFastForwardInput): F[avias.codecommit.models.MergePullRequestByFastForwardOutput] 33 | def postCommentForComparedCommit(input: avias.codecommit.models.PostCommentForComparedCommitInput): F[avias.codecommit.models.PostCommentForComparedCommitOutput] 34 | def updatePullRequestStatus(input: avias.codecommit.models.UpdatePullRequestStatusInput): F[avias.codecommit.models.UpdatePullRequestStatusOutput] 35 | def deleteBranch(input: avias.codecommit.models.DeleteBranchInput): F[avias.codecommit.models.DeleteBranchOutput] 36 | def listBranches(input: avias.codecommit.models.ListBranchesInput): F[avias.codecommit.models.ListBranchesOutput] 37 | def updateDefaultBranch(input: avias.codecommit.models.UpdateDefaultBranchInput): F[scala.Unit] 38 | } -------------------------------------------------------------------------------- /services/directory/core/src/main/scala/avias/MyTrait.scala: -------------------------------------------------------------------------------- 1 | package avias.directory 2 | trait Amazondirectory[F[_]] { 3 | def connectDirectory(input: avias.directory.models.ConnectDirectoryRequest): F[avias.directory.models.ConnectDirectoryResult] 4 | def removeIpRoutes(input: avias.directory.models.RemoveIpRoutesRequest): F[scala.Unit] 5 | def deregisterEventTopic(input: avias.directory.models.DeregisterEventTopicRequest): F[scala.Unit] 6 | def createAlias(input: avias.directory.models.CreateAliasRequest): F[avias.directory.models.CreateAliasResult] 7 | def restoreFromSnapshot(input: avias.directory.models.RestoreFromSnapshotRequest): F[scala.Unit] 8 | def disableSso(input: avias.directory.models.DisableSsoRequest): F[scala.Unit] 9 | def createTrust(input: avias.directory.models.CreateTrustRequest): F[avias.directory.models.CreateTrustResult] 10 | def disableRadius(input: avias.directory.models.DisableRadiusRequest): F[scala.Unit] 11 | def updateConditionalForwarder(input: avias.directory.models.UpdateConditionalForwarderRequest): F[scala.Unit] 12 | def deleteDirectory(input: avias.directory.models.DeleteDirectoryRequest): F[avias.directory.models.DeleteDirectoryResult] 13 | def describeTrusts(input: avias.directory.models.DescribeTrustsRequest): F[avias.directory.models.DescribeTrustsResult] 14 | def cancelSchemaExtension(input: avias.directory.models.CancelSchemaExtensionRequest): F[scala.Unit] 15 | def listIpRoutes(input: avias.directory.models.ListIpRoutesRequest): F[avias.directory.models.ListIpRoutesResult] 16 | def getSnapshotLimits(input: avias.directory.models.GetSnapshotLimitsRequest): F[avias.directory.models.GetSnapshotLimitsResult] 17 | def createDirectory(input: avias.directory.models.CreateDirectoryRequest): F[avias.directory.models.CreateDirectoryResult] 18 | def describeEventTopics(input: avias.directory.models.DescribeEventTopicsRequest): F[avias.directory.models.DescribeEventTopicsResult] 19 | def describeSnapshots(input: avias.directory.models.DescribeSnapshotsRequest): F[avias.directory.models.DescribeSnapshotsResult] 20 | def deleteSnapshot(input: avias.directory.models.DeleteSnapshotRequest): F[avias.directory.models.DeleteSnapshotResult] 21 | def enableSso(input: avias.directory.models.EnableSsoRequest): F[scala.Unit] 22 | def createConditionalForwarder(input: avias.directory.models.CreateConditionalForwarderRequest): F[scala.Unit] 23 | def addTagsToResource(input: avias.directory.models.AddTagsToResourceRequest): F[scala.Unit] 24 | def getDirectoryLimits: F[avias.directory.models.GetDirectoryLimitsResult] 25 | def listTagsForResource(input: avias.directory.models.ListTagsForResourceRequest): F[avias.directory.models.ListTagsForResourceResult] 26 | def describeDirectories(input: avias.directory.models.DescribeDirectoriesRequest): F[avias.directory.models.DescribeDirectoriesResult] 27 | def removeTagsFromResource(input: avias.directory.models.RemoveTagsFromResourceRequest): F[scala.Unit] 28 | def createComputer(input: avias.directory.models.CreateComputerRequest): F[avias.directory.models.CreateComputerResult] 29 | def registerEventTopic(input: avias.directory.models.RegisterEventTopicRequest): F[scala.Unit] 30 | def deleteTrust(input: avias.directory.models.DeleteTrustRequest): F[avias.directory.models.DeleteTrustResult] 31 | def createMicrosoftAD(input: avias.directory.models.CreateMicrosoftADRequest): F[avias.directory.models.CreateMicrosoftADResult] 32 | def verifyTrust(input: avias.directory.models.VerifyTrustRequest): F[avias.directory.models.VerifyTrustResult] 33 | def deleteConditionalForwarder(input: avias.directory.models.DeleteConditionalForwarderRequest): F[scala.Unit] 34 | def startSchemaExtension(input: avias.directory.models.StartSchemaExtensionRequest): F[avias.directory.models.StartSchemaExtensionResult] 35 | def createSnapshot(input: avias.directory.models.CreateSnapshotRequest): F[avias.directory.models.CreateSnapshotResult] 36 | def describeConditionalForwarders(input: avias.directory.models.DescribeConditionalForwardersRequest): F[avias.directory.models.DescribeConditionalForwardersResult] 37 | def describeDomainControllers(input: avias.directory.models.DescribeDomainControllersRequest): F[avias.directory.models.DescribeDomainControllersResult] 38 | def listSchemaExtensions(input: avias.directory.models.ListSchemaExtensionsRequest): F[avias.directory.models.ListSchemaExtensionsResult] 39 | def updateRadius(input: avias.directory.models.UpdateRadiusRequest): F[scala.Unit] 40 | def enableRadius(input: avias.directory.models.EnableRadiusRequest): F[scala.Unit] 41 | def updateNumberOfDomainControllers(input: avias.directory.models.UpdateNumberOfDomainControllersRequest): F[scala.Unit] 42 | def addIpRoutes(input: avias.directory.models.AddIpRoutesRequest): F[scala.Unit] 43 | } -------------------------------------------------------------------------------- /gen/src/main/scala/avias/gen/generator/Structure.scala: -------------------------------------------------------------------------------- 1 | package avias.gen.generator 2 | 3 | import scala.meta.{Defn, Enumerator, Lit, Pat, Term, Type} 4 | import scala.meta.quasiquotes._ 5 | 6 | case class StructureField(name: String, typ: Type, isOptional: Boolean) { 7 | val scalaLiteral = Lit.String(name) 8 | 9 | val scalaName: Term.Name = { 10 | val upper = name.takeWhile(_.isUpper) 11 | val afterUpper = name.dropWhile(_.isUpper) 12 | Term.Name(upper.toLowerCase + afterUpper) 13 | } 14 | 15 | val scalaType: Type = { 16 | if (isOptional) 17 | Type.Apply(Type.Name("scala.Option"), List(typ)) 18 | else 19 | typ 20 | } 21 | 22 | val scalaMethodParam: Term.Param = { 23 | if (isOptional) 24 | Term.Param(List.empty, scalaName, Some(scalaType), Some(Term.Name("scala.None"))) 25 | else 26 | Term.Param(List.empty, scalaName, Some(scalaType), None) 27 | } 28 | } 29 | 30 | trait Structure { 31 | def typeName: String 32 | def scalaType: Type 33 | def decoder: Defn.Val 34 | def encoder: Defn.Val 35 | def definition: Defn 36 | def params: List[StructureField] 37 | } 38 | 39 | object Structure { 40 | def apply(typePackage: String, typeName: String, isError: Boolean, params: List[StructureField]): Structure = { 41 | if (params.isEmpty) 42 | ObjectStructure(typePackage, typeName, isError) 43 | else 44 | ClassStructure(typePackage, typeName, isError, params) 45 | } 46 | } 47 | 48 | case class ObjectStructure(typePackage: String, typeName: String, isError: Boolean) 49 | extends Structure { 50 | val scalaType = Type.Select(Term.Name(typePackage), Type.Name(typeName + ".type")) 51 | val scalaObjectName = Term.Select(Term.Name(typePackage), Term.Name(typeName)) 52 | val params: List[StructureField] = List.empty 53 | 54 | def decoder: Defn.Val = { 55 | val decoderName = Pat.Var(Term.Name(typeName + "Decoder")) 56 | q"final implicit val $decoderName: io.circe.Decoder[$scalaType] = io.circe.Decoder.decodeUnit.as($scalaObjectName)" 57 | } 58 | 59 | def encoder: Defn.Val = { 60 | val encoderName = Pat.Var(Term.Name(typeName + "Encoder")) 61 | q"final implicit val $encoderName: io.circe.Encoder[$scalaType] = io.circe.Encoder.instance { o => Json.obj() }" 62 | } 63 | 64 | def definition: Defn = { 65 | q"case object ${Term.Name(typeName)}" 66 | } 67 | } 68 | 69 | case class ClassStructure(typePackage: String, typeName: String, 70 | isError: Boolean, 71 | params: List[StructureField]) 72 | extends Structure { 73 | val scalaType = Type.Select(Term.Name(typePackage), Type.Name(typeName)) 74 | val scalaObjectName = Term.Select(Term.Name(typePackage), Term.Name(typeName)) 75 | 76 | def decoder: Defn.Val = { 77 | def monadicDecoder: Term.ForYield = { 78 | def extractItem(item: StructureField): Enumerator.Generator = { 79 | enumerator"${p"${item.scalaName}"} <- o.get[${item.scalaType}](${item.scalaLiteral})" 80 | } 81 | 82 | val enumeratorsnel = params.map(extractItem) 83 | val fields = params.map(_.scalaName) 84 | 85 | q"for (..$enumeratorsnel) yield $scalaObjectName(..$fields)" 86 | } 87 | 88 | def applicativeDecoder: Term.Apply = { 89 | def extractItem(item: StructureField): Term = { 90 | q"o.get[${item.scalaType}](${item.scalaLiteral})" 91 | } 92 | val fields = params.map(extractItem) 93 | 94 | q"(..$fields).mapN($scalaObjectName.apply _)" 95 | } 96 | 97 | def singleFieldDecoder(item: StructureField): Term.Apply = { 98 | q"o.get[${item.scalaType}](${item.scalaLiteral}).map($scalaObjectName.apply _)" 99 | } 100 | 101 | def decoderInstance: Term = { 102 | if (params.size == 1) 103 | singleFieldDecoder(params.head) 104 | else if (params.size >= 23) 105 | monadicDecoder 106 | else 107 | applicativeDecoder 108 | } 109 | 110 | val decoderName = Pat.Var(Term.Name(typeName + "Decoder")) 111 | 112 | q"final implicit val $decoderName: io.circe.Decoder[$scalaType] = io.circe.Decoder.instance { o => $decoderInstance }" 113 | } 114 | 115 | def encoder: Defn.Val = { 116 | val encoderInstance: Term.Apply = { 117 | val fields = params.map(i => q"${i.scalaLiteral} -> o.${i.scalaName}.asJson") 118 | q"Json.obj(..$fields)" 119 | } 120 | 121 | val encoderName = Pat.Var(Term.Name(typeName + "Encoder")) 122 | 123 | q"final implicit val $encoderName: io.circe.Encoder[$scalaType] = io.circe.Encoder.instance { o => $encoderInstance }" 124 | } 125 | 126 | def definition: Defn = { 127 | q"final case class ${Type.Name(typeName)}(..${params.map(_.scalaMethodParam)})" 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /gen/src/main/scala/avias/gen/graph/ServiceNode.scala: -------------------------------------------------------------------------------- 1 | package avias.gen.graph 2 | 3 | import avias.gen.parse.service.HttpOperation 4 | import quiver.Graph 5 | 6 | import scala.meta.{Term, Type} 7 | import scala.meta.quasiquotes._ 8 | 9 | sealed trait ServiceNode extends Product with Serializable 10 | 11 | case class OperationNode(item: String, 12 | http: HttpOperation, 13 | documentation: Option[String]) 14 | extends ServiceNode 15 | 16 | trait ShapeNode extends ServiceNode { 17 | def name: String 18 | def documentation: Option[String] 19 | def getType(modelPackage: String, 20 | graph: Graph[ServiceNode, NodeName, EdgeLabel]): Type 21 | } 22 | 23 | case class BlobNode(name: String, documentation: Option[String]) 24 | extends ShapeNode { 25 | def getType(modelPackage: String, 26 | graph: Graph[ServiceNode, NodeName, EdgeLabel]): Type = 27 | t"scala.Array[scala.Byte]" 28 | } 29 | 30 | case class BooleanNode(name: String, documentation: Option[String]) 31 | extends ShapeNode { 32 | def getType(modelPackage: String, 33 | graph: Graph[ServiceNode, NodeName, EdgeLabel]): Type = 34 | t"scala.Boolean" 35 | } 36 | 37 | case class DoubleNode(name: String, documentation: Option[String]) 38 | extends ShapeNode { 39 | def getType(modelPackage: String, 40 | graph: Graph[ServiceNode, NodeName, EdgeLabel]): Type = 41 | t"scala.Double" 42 | } 43 | 44 | case class FloatNode(name: String, documentation: Option[String]) 45 | extends ShapeNode { 46 | def getType(modelPackage: String, 47 | graph: Graph[ServiceNode, NodeName, EdgeLabel]): Type = 48 | t"scala.Float" 49 | } 50 | 51 | case class StructureNode(name: String, 52 | hasZeroMembers: Boolean, 53 | documentation: Option[String]) 54 | extends ShapeNode { 55 | def getType(modelPackage: String, 56 | graph: Graph[ServiceNode, NodeName, EdgeLabel]): Type = 57 | t"${Term.Name(modelPackage)}.${Type.Name(name)}" 58 | } 59 | 60 | case class IntegerNode(name: String, 61 | documentation: Option[String], 62 | min: Option[Int], 63 | max: Option[Int]) 64 | extends ShapeNode { 65 | def getType(modelPackage: String, 66 | graph: Graph[ServiceNode, NodeName, EdgeLabel]): Type = 67 | t"scala.Int" 68 | } 69 | 70 | case class ListNode(name: String, 71 | documentation: Option[String], 72 | min: Option[Int]) 73 | extends ShapeNode { 74 | def getType(modelPackage: String, 75 | graph: Graph[ServiceNode, NodeName, EdgeLabel]): Type = { 76 | graph.outs(this).collectFirst { 77 | case (ShapeForList, s: ShapeNode) => 78 | val listType = s.getType(modelPackage, graph) 79 | t"scala.List[$listType]" 80 | } getOrElse sys.error( 81 | "Should have output type for a list node: " + name + " " + graph.outs( 82 | this)) 83 | } 84 | } 85 | case class LongNode(name: String, 86 | documentation: Option[String], 87 | min: Option[Long], 88 | max: Option[Long]) 89 | extends ShapeNode { 90 | def getType(modelPackage: String, 91 | graph: Graph[ServiceNode, NodeName, EdgeLabel]): Type = 92 | t"scala.Long" 93 | } 94 | 95 | case class MapNode(name: String, documentation: Option[String]) 96 | extends ShapeNode { 97 | def getType(modelPackage: String, 98 | graph: Graph[ServiceNode, NodeName, EdgeLabel]): Type = { 99 | val outs = graph.outs(this) 100 | 101 | val k = outs.collectFirst { 102 | case (KeyForMap, s: ShapeNode) => 103 | s.getType(modelPackage, graph) 104 | } getOrElse sys.error( 105 | "Should have key type for a map node: " + name + " " + graph.outs(this)) 106 | 107 | val v = outs.collectFirst { 108 | case (ValueForMap, s: ShapeNode) => 109 | s.getType(modelPackage, graph) 110 | } getOrElse sys.error( 111 | "Should have a value type for a map node: " + name + " " + graph.outs( 112 | this)) 113 | 114 | t"scala.collection.immutable.Map[$k, $v]" 115 | } 116 | } 117 | 118 | case class StringNode(name: String, 119 | documentation: Option[String], 120 | enum: Option[Set[String]], 121 | max: Option[Int]) 122 | extends ShapeNode { 123 | def getType(modelPackage: String, 124 | graph: Graph[ServiceNode, NodeName, EdgeLabel]): Type = 125 | t"java.lang.String" 126 | } 127 | 128 | case class TimestampNode(name: String, documentation: Option[String]) 129 | extends ShapeNode { 130 | def getType(modelPackage: String, 131 | graph: Graph[ServiceNode, NodeName, EdgeLabel]): Type = 132 | t"java.time.Instant" 133 | } 134 | -------------------------------------------------------------------------------- /services/marketplaceentitlement/circe/src/main/scala/avias/CirceImplicits.scala: -------------------------------------------------------------------------------- 1 | package avias.marketplaceentitlement 2 | import cats.implicits._ 3 | import io.circe._ 4 | import io.circe.syntax._ 5 | object circe extends avias.common.DefaultCodecs { 6 | final implicit val EntitlementEncoder: io.circe.Encoder[avias.marketplaceentitlement.models.Entitlement] = io.circe.Encoder.instance { o => 7 | Json.obj("ProductCode" -> o.productCode.asJson, "Dimension" -> o.dimension.asJson, "CustomerIdentifier" -> o.customerIdentifier.asJson, "Value" -> o.value.asJson, "ExpirationDate" -> o.expirationDate.asJson) 8 | } 9 | final implicit val GetEntitlementsRequestEncoder: io.circe.Encoder[avias.marketplaceentitlement.models.GetEntitlementsRequest] = io.circe.Encoder.instance { o => 10 | Json.obj("ProductCode" -> o.productCode.asJson, "Filter" -> o.filter.asJson, "NextToken" -> o.nextToken.asJson, "MaxResults" -> o.maxResults.asJson) 11 | } 12 | final implicit val InternalServiceErrorExceptionEncoder: io.circe.Encoder[avias.marketplaceentitlement.models.InternalServiceErrorException] = io.circe.Encoder.instance { o => 13 | Json.obj("message" -> o.message.asJson) 14 | } 15 | final implicit val EntitlementValueEncoder: io.circe.Encoder[avias.marketplaceentitlement.models.EntitlementValue] = io.circe.Encoder.instance { o => 16 | Json.obj("IntegerValue" -> o.integerValue.asJson, "DoubleValue" -> o.doubleValue.asJson, "BooleanValue" -> o.booleanValue.asJson, "StringValue" -> o.stringValue.asJson) 17 | } 18 | final implicit val InvalidParameterExceptionEncoder: io.circe.Encoder[avias.marketplaceentitlement.models.InvalidParameterException] = io.circe.Encoder.instance { o => 19 | Json.obj("message" -> o.message.asJson) 20 | } 21 | final implicit val ThrottlingExceptionEncoder: io.circe.Encoder[avias.marketplaceentitlement.models.ThrottlingException] = io.circe.Encoder.instance { o => 22 | Json.obj("message" -> o.message.asJson) 23 | } 24 | final implicit val GetEntitlementsResultEncoder: io.circe.Encoder[avias.marketplaceentitlement.models.GetEntitlementsResult] = io.circe.Encoder.instance { o => 25 | Json.obj("Entitlements" -> o.entitlements.asJson, "NextToken" -> o.nextToken.asJson) 26 | } 27 | final implicit val EntitlementDecoder: io.circe.Decoder[avias.marketplaceentitlement.models.Entitlement] = io.circe.Decoder.instance { o => 28 | (o.get[scala.Option[java.lang.String]]("ProductCode"), o.get[scala.Option[java.lang.String]]("Dimension"), o.get[scala.Option[java.lang.String]]("CustomerIdentifier"), o.get[scala.Option[avias.marketplaceentitlement.models.EntitlementValue]]("Value"), o.get[scala.Option[java.time.Instant]]("ExpirationDate")).mapN(avias.marketplaceentitlement.models.Entitlement.apply _) 29 | } 30 | final implicit val GetEntitlementsRequestDecoder: io.circe.Decoder[avias.marketplaceentitlement.models.GetEntitlementsRequest] = io.circe.Decoder.instance { o => 31 | (o.get[java.lang.String]("ProductCode"), o.get[scala.Option[scala.collection.immutable.Map[java.lang.String, scala.List[java.lang.String]]]]("Filter"), o.get[scala.Option[java.lang.String]]("NextToken"), o.get[scala.Option[scala.Int]]("MaxResults")).mapN(avias.marketplaceentitlement.models.GetEntitlementsRequest.apply _) 32 | } 33 | final implicit val InternalServiceErrorExceptionDecoder: io.circe.Decoder[avias.marketplaceentitlement.models.InternalServiceErrorException] = io.circe.Decoder.instance { o => 34 | o.get[scala.Option[java.lang.String]]("message").map(avias.marketplaceentitlement.models.InternalServiceErrorException.apply _) 35 | } 36 | final implicit val EntitlementValueDecoder: io.circe.Decoder[avias.marketplaceentitlement.models.EntitlementValue] = io.circe.Decoder.instance { o => 37 | (o.get[scala.Option[scala.Int]]("IntegerValue"), o.get[scala.Option[scala.Double]]("DoubleValue"), o.get[scala.Option[scala.Boolean]]("BooleanValue"), o.get[scala.Option[java.lang.String]]("StringValue")).mapN(avias.marketplaceentitlement.models.EntitlementValue.apply _) 38 | } 39 | final implicit val InvalidParameterExceptionDecoder: io.circe.Decoder[avias.marketplaceentitlement.models.InvalidParameterException] = io.circe.Decoder.instance { o => 40 | o.get[scala.Option[java.lang.String]]("message").map(avias.marketplaceentitlement.models.InvalidParameterException.apply _) 41 | } 42 | final implicit val ThrottlingExceptionDecoder: io.circe.Decoder[avias.marketplaceentitlement.models.ThrottlingException] = io.circe.Decoder.instance { o => 43 | o.get[scala.Option[java.lang.String]]("message").map(avias.marketplaceentitlement.models.ThrottlingException.apply _) 44 | } 45 | final implicit val GetEntitlementsResultDecoder: io.circe.Decoder[avias.marketplaceentitlement.models.GetEntitlementsResult] = io.circe.Decoder.instance { o => 46 | (o.get[scala.Option[scala.List[avias.marketplaceentitlement.models.Entitlement]]]("Entitlements"), o.get[scala.Option[java.lang.String]]("NextToken")).mapN(avias.marketplaceentitlement.models.GetEntitlementsResult.apply _) 47 | } 48 | } -------------------------------------------------------------------------------- /services/cloudtrail/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.cloudtrail.http4s 2 | import org.http4s.Method._ 3 | import avias.cloudtrail.circe._ 4 | import avias.cloudtrail.models 5 | class AmazoncloudtrailClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.cloudtrail.Amazoncloudtrail[F] { 6 | private[this] final val ServiceType: String = "cloudtrail" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101") 8 | override def addTags(input: avias.cloudtrail.models.AddTagsRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.cloudtrail.models.AddTagsRequest](client, awsData, ServiceType, ServiceAndPrefix, "AddTags", POST, "/", input) 9 | override def listTags(input: avias.cloudtrail.models.ListTagsRequest): F[avias.cloudtrail.models.ListTagsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.cloudtrail.models.ListTagsResponse, avias.cloudtrail.models.ListTagsRequest](client, awsData, ServiceType, ServiceAndPrefix, "ListTags", POST, "/", input) 10 | override def createTrail(input: avias.cloudtrail.models.CreateTrailRequest): F[avias.cloudtrail.models.CreateTrailResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.cloudtrail.models.CreateTrailResponse, avias.cloudtrail.models.CreateTrailRequest](client, awsData, ServiceType, ServiceAndPrefix, "CreateTrail", POST, "/", input) 11 | override def describeTrails(input: avias.cloudtrail.models.DescribeTrailsRequest): F[avias.cloudtrail.models.DescribeTrailsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.cloudtrail.models.DescribeTrailsResponse, avias.cloudtrail.models.DescribeTrailsRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeTrails", POST, "/", input) 12 | override def startLogging(input: avias.cloudtrail.models.StartLoggingRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.cloudtrail.models.StartLoggingRequest](client, awsData, ServiceType, ServiceAndPrefix, "StartLogging", POST, "/", input) 13 | override def lookupEvents(input: avias.cloudtrail.models.LookupEventsRequest): F[avias.cloudtrail.models.LookupEventsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.cloudtrail.models.LookupEventsResponse, avias.cloudtrail.models.LookupEventsRequest](client, awsData, ServiceType, ServiceAndPrefix, "LookupEvents", POST, "/", input) 14 | override def stopLogging(input: avias.cloudtrail.models.StopLoggingRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.cloudtrail.models.StopLoggingRequest](client, awsData, ServiceType, ServiceAndPrefix, "StopLogging", POST, "/", input) 15 | override def removeTags(input: avias.cloudtrail.models.RemoveTagsRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.cloudtrail.models.RemoveTagsRequest](client, awsData, ServiceType, ServiceAndPrefix, "RemoveTags", POST, "/", input) 16 | override def deleteTrail(input: avias.cloudtrail.models.DeleteTrailRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.cloudtrail.models.DeleteTrailRequest](client, awsData, ServiceType, ServiceAndPrefix, "DeleteTrail", POST, "/", input) 17 | override def updateTrail(input: avias.cloudtrail.models.UpdateTrailRequest): F[avias.cloudtrail.models.UpdateTrailResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.cloudtrail.models.UpdateTrailResponse, avias.cloudtrail.models.UpdateTrailRequest](client, awsData, ServiceType, ServiceAndPrefix, "UpdateTrail", POST, "/", input) 18 | override def putEventSelectors(input: avias.cloudtrail.models.PutEventSelectorsRequest): F[avias.cloudtrail.models.PutEventSelectorsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.cloudtrail.models.PutEventSelectorsResponse, avias.cloudtrail.models.PutEventSelectorsRequest](client, awsData, ServiceType, ServiceAndPrefix, "PutEventSelectors", POST, "/", input) 19 | override def getEventSelectors(input: avias.cloudtrail.models.GetEventSelectorsRequest): F[avias.cloudtrail.models.GetEventSelectorsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.cloudtrail.models.GetEventSelectorsResponse, avias.cloudtrail.models.GetEventSelectorsRequest](client, awsData, ServiceType, ServiceAndPrefix, "GetEventSelectors", POST, "/", input) 20 | override def getTrailStatus(input: avias.cloudtrail.models.GetTrailStatusRequest): F[avias.cloudtrail.models.GetTrailStatusResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.cloudtrail.models.GetTrailStatusResponse, avias.cloudtrail.models.GetTrailStatusRequest](client, awsData, ServiceType, ServiceAndPrefix, "GetTrailStatus", POST, "/", input) 21 | override def listPublicKeys(input: avias.cloudtrail.models.ListPublicKeysRequest): F[avias.cloudtrail.models.ListPublicKeysResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.cloudtrail.models.ListPublicKeysResponse, avias.cloudtrail.models.ListPublicKeysRequest](client, awsData, ServiceType, ServiceAndPrefix, "ListPublicKeys", POST, "/", input) 22 | } -------------------------------------------------------------------------------- /services/events/http4s/src/main/scala/avias/Http4sImpl.scala: -------------------------------------------------------------------------------- 1 | package avias.events.http4s 2 | import org.http4s.Method._ 3 | import avias.events.circe._ 4 | import avias.events.models 5 | class AmazoneventsClient[F[_]: cats.effect.Sync](client: org.http4s.client.Client[F], awsData: avias.common.AwsData[F]) extends avias.events.Amazonevents[F] { 6 | private[this] final val ServiceType: String = "events" 7 | private[this] final val ServiceAndPrefix: Option[String] = Some("AWSEvents") 8 | override def putEvents(input: avias.events.models.PutEventsRequest): F[avias.events.models.PutEventsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.events.models.PutEventsResponse, avias.events.models.PutEventsRequest](client, awsData, ServiceType, ServiceAndPrefix, "PutEvents", POST, "/", input) 9 | override def removePermission(input: avias.events.models.RemovePermissionRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.events.models.RemovePermissionRequest](client, awsData, ServiceType, ServiceAndPrefix, "RemovePermission", POST, "/", input) 10 | override def describeEventBus: F[avias.events.models.DescribeEventBusResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.events.models.DescribeEventBusResponse, scala.Unit](client, awsData, ServiceType, ServiceAndPrefix, "DescribeEventBus", POST, "/", ()) 11 | override def describeRule(input: avias.events.models.DescribeRuleRequest): F[avias.events.models.DescribeRuleResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.events.models.DescribeRuleResponse, avias.events.models.DescribeRuleRequest](client, awsData, ServiceType, ServiceAndPrefix, "DescribeRule", POST, "/", input) 12 | override def disableRule(input: avias.events.models.DisableRuleRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.events.models.DisableRuleRequest](client, awsData, ServiceType, ServiceAndPrefix, "DisableRule", POST, "/", input) 13 | override def testEventPattern(input: avias.events.models.TestEventPatternRequest): F[avias.events.models.TestEventPatternResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.events.models.TestEventPatternResponse, avias.events.models.TestEventPatternRequest](client, awsData, ServiceType, ServiceAndPrefix, "TestEventPattern", POST, "/", input) 14 | override def enableRule(input: avias.events.models.EnableRuleRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.events.models.EnableRuleRequest](client, awsData, ServiceType, ServiceAndPrefix, "EnableRule", POST, "/", input) 15 | override def listTargetsByRule(input: avias.events.models.ListTargetsByRuleRequest): F[avias.events.models.ListTargetsByRuleResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.events.models.ListTargetsByRuleResponse, avias.events.models.ListTargetsByRuleRequest](client, awsData, ServiceType, ServiceAndPrefix, "ListTargetsByRule", POST, "/", input) 16 | override def deleteRule(input: avias.events.models.DeleteRuleRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.events.models.DeleteRuleRequest](client, awsData, ServiceType, ServiceAndPrefix, "DeleteRule", POST, "/", input) 17 | override def removeTargets(input: avias.events.models.RemoveTargetsRequest): F[avias.events.models.RemoveTargetsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.events.models.RemoveTargetsResponse, avias.events.models.RemoveTargetsRequest](client, awsData, ServiceType, ServiceAndPrefix, "RemoveTargets", POST, "/", input) 18 | override def putRule(input: avias.events.models.PutRuleRequest): F[avias.events.models.PutRuleResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.events.models.PutRuleResponse, avias.events.models.PutRuleRequest](client, awsData, ServiceType, ServiceAndPrefix, "PutRule", POST, "/", input) 19 | override def putPermission(input: avias.events.models.PutPermissionRequest): F[scala.Unit] = avias.common.http4s.ClientUtils.doRequest[F, scala.Unit, avias.events.models.PutPermissionRequest](client, awsData, ServiceType, ServiceAndPrefix, "PutPermission", POST, "/", input) 20 | override def listRuleNamesByTarget(input: avias.events.models.ListRuleNamesByTargetRequest): F[avias.events.models.ListRuleNamesByTargetResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.events.models.ListRuleNamesByTargetResponse, avias.events.models.ListRuleNamesByTargetRequest](client, awsData, ServiceType, ServiceAndPrefix, "ListRuleNamesByTarget", POST, "/", input) 21 | override def putTargets(input: avias.events.models.PutTargetsRequest): F[avias.events.models.PutTargetsResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.events.models.PutTargetsResponse, avias.events.models.PutTargetsRequest](client, awsData, ServiceType, ServiceAndPrefix, "PutTargets", POST, "/", input) 22 | override def listRules(input: avias.events.models.ListRulesRequest): F[avias.events.models.ListRulesResponse] = avias.common.http4s.ClientUtils.doRequest[F, avias.events.models.ListRulesResponse, avias.events.models.ListRulesRequest](client, awsData, ServiceType, ServiceAndPrefix, "ListRules", POST, "/", input) 23 | } -------------------------------------------------------------------------------- /gen/src/main/scala/avias/gen/graph/ServiceGraph.scala: -------------------------------------------------------------------------------- 1 | package avias.gen.graph 2 | 3 | import cats.implicits._ 4 | import avias.gen.parse.service._ 5 | import quiver._ 6 | 7 | object ServiceGraph { 8 | def apply(service: Service): Graph[ServiceNode, NodeName, EdgeLabel] = { 9 | val operationNodes = 10 | service.operations.map { 11 | case (k, v) => 12 | k -> LNode(OperationNode(v.name, v.http, v.documentation), 13 | NodeName(k)) 14 | } 15 | 16 | val shapeNodes = 17 | service.shapes.map { 18 | case (k, v) => 19 | val n = v match { 20 | case BlobServiceShape(documentation) => 21 | BlobNode(k, documentation) 22 | case BooleanServiceShape(documentation) => 23 | BooleanNode(k, documentation) 24 | case DoubleServiceShape(documentation) => 25 | DoubleNode(k, documentation) 26 | case FloatServiceShape(documentation) => 27 | FloatNode(k, documentation) 28 | case IntegerServiceShape(documentation, min, max) => 29 | IntegerNode(k, documentation, min, max) 30 | case ListServiceShape(documentation, shape, min) => 31 | ListNode(k, documentation, min) 32 | case LongServiceShape(documentation, min, max) => 33 | LongNode(k, documentation, min, max) 34 | case MapServiceShape(documentation, kShape, vShape) => 35 | MapNode(k, documentation) 36 | case StringServiceShape(documentation, enum, max) => 37 | StringNode(k, documentation, enum.map(_.toSet), max) 38 | case StructureServiceShape(documentation, required, members) => 39 | StructureNode(k, members.isEmpty, documentation) 40 | case TimestampServiceShape(documentation) => 41 | TimestampNode(k, documentation) 42 | } 43 | k -> LNode(n, NodeName(k)) 44 | } 45 | 46 | val nodes = 47 | (operationNodes.valuesIterator ++ shapeNodes.valuesIterator).toList 48 | 49 | val operationEdges = service.operations.flatMap { 50 | case (k, v) => 51 | val src = operationNodes(k).vertex 52 | 53 | v.input 54 | .map { i => 55 | 56 | LEdge(src, shapeNodes(i.shape).vertex, InputForOperation) } 57 | .toSeq ++ 58 | v.output 59 | .map( 60 | o => 61 | LEdge(src, 62 | shapeNodes(o.shape).vertex, 63 | OutputForOperation)) 64 | .toSeq ++ 65 | v.errors 66 | .getOrElse(List.empty) 67 | .map( 68 | e => 69 | LEdge(src, 70 | shapeNodes(e.shape).vertex, 71 | ErrorForOperation)) 72 | } toList 73 | 74 | val shapeEdges = 75 | service.shapes.flatMap { 76 | case (k, BlobServiceShape(_)) => 77 | Seq.empty 78 | case (k, BooleanServiceShape(_)) => 79 | Seq.empty 80 | case (k, DoubleServiceShape(_)) => 81 | Seq.empty 82 | case (k, FloatServiceShape(_)) => 83 | Seq.empty 84 | case (k, IntegerServiceShape(_, _, _)) => 85 | Seq.empty 86 | case (k, ListServiceShape(_, a, b)) => 87 | val src = shapeNodes(k).vertex 88 | Seq(LEdge(src, shapeNodes(a.shape).vertex, ShapeForList)) 89 | case (k, LongServiceShape(_, _, _)) => 90 | Seq.empty 91 | case (k, MapServiceShape(_, kShape, vShape)) => 92 | val src = shapeNodes(k).vertex 93 | Seq( 94 | LEdge(src, shapeNodes(kShape.shape).vertex, KeyForMap), 95 | LEdge(src, shapeNodes(vShape.shape).vertex, ValueForMap)) 96 | case (k, StringServiceShape(_, _, _)) => 97 | Seq.empty 98 | case (k, StructureServiceShape(_, required, members)) => 99 | val src = shapeNodes(k).vertex 100 | val reqKeys = required.toList.flatten.toSet 101 | val req = members 102 | .filterKeys(k => reqKeys.contains(k.repr)) 103 | .map { 104 | case (k, v) => 105 | LEdge(src, 106 | shapeNodes(v.shape).vertex, 107 | ItemForStructure(k, required = true)) 108 | } 109 | val notreq = members 110 | .filterKeys(k => !reqKeys.contains(k.repr)) 111 | .map { 112 | case (k, v) => 113 | LEdge(src, 114 | shapeNodes(v.shape).vertex, 115 | ItemForStructure(k, required = false)) 116 | } 117 | 118 | req ++ notreq 119 | 120 | case (k, TimestampServiceShape(_)) => 121 | Seq.empty 122 | } toList 123 | 124 | val edges = operationEdges ++ shapeEdges 125 | 126 | quiver.mkGraph(nodes.asInstanceOf[List[LNode[ServiceNode, NodeName]]], edges.asInstanceOf[List[LEdge[ServiceNode, EdgeLabel]]]) 127 | } 128 | } 129 | -------------------------------------------------------------------------------- /services/dynamodbstreams/core/src/main/scala/avias/Models.scala: -------------------------------------------------------------------------------- 1 | package avias.dynamodbstreams.models 2 | final case class KeySchemaElement(attributeName: java.lang.String, keyType: java.lang.String) 3 | final case class ListStreamsInput(tableName: scala.Option[java.lang.String] = scala.None, limit: scala.Option[scala.Int] = scala.None, exclusiveStartStreamArn: scala.Option[java.lang.String] = scala.None) 4 | final case class GetRecordsInput(shardIterator: java.lang.String, limit: scala.Option[scala.Int] = scala.None) 5 | final case class LimitExceededException(message: scala.Option[java.lang.String] = scala.None) 6 | final case class AttributeValue(bs: scala.Option[scala.List[scala.Array[scala.Byte]]] = scala.None, ss: scala.Option[scala.List[java.lang.String]] = scala.None, m: scala.Option[scala.collection.immutable.Map[java.lang.String, avias.dynamodbstreams.models.AttributeValue]] = scala.None, `null`: scala.Option[scala.Boolean] = scala.None, b: scala.Option[scala.Array[scala.Byte]] = scala.None, s: scala.Option[java.lang.String] = scala.None, n: scala.Option[java.lang.String] = scala.None, ns: scala.Option[scala.List[java.lang.String]] = scala.None, bool: scala.Option[scala.Boolean] = scala.None, l: scala.Option[scala.List[avias.dynamodbstreams.models.AttributeValue]] = scala.None) 7 | final case class SequenceNumberRange(startingSequenceNumber: scala.Option[java.lang.String] = scala.None, endingSequenceNumber: scala.Option[java.lang.String] = scala.None) 8 | final case class Stream(streamArn: scala.Option[java.lang.String] = scala.None, tableName: scala.Option[java.lang.String] = scala.None, streamLabel: scala.Option[java.lang.String] = scala.None) 9 | final case class Record(eventID: scala.Option[java.lang.String] = scala.None, eventVersion: scala.Option[java.lang.String] = scala.None, eventSource: scala.Option[java.lang.String] = scala.None, awsRegion: scala.Option[java.lang.String] = scala.None, eventName: scala.Option[java.lang.String] = scala.None, dynamodb: scala.Option[avias.dynamodbstreams.models.StreamRecord] = scala.None, userIdentity: scala.Option[avias.dynamodbstreams.models.Identity] = scala.None) 10 | final case class GetShardIteratorOutput(shardIterator: scala.Option[java.lang.String] = scala.None) 11 | final case class StreamRecord(keys: scala.Option[scala.collection.immutable.Map[java.lang.String, avias.dynamodbstreams.models.AttributeValue]] = scala.None, newImage: scala.Option[scala.collection.immutable.Map[java.lang.String, avias.dynamodbstreams.models.AttributeValue]] = scala.None, oldImage: scala.Option[scala.collection.immutable.Map[java.lang.String, avias.dynamodbstreams.models.AttributeValue]] = scala.None, sequenceNumber: scala.Option[java.lang.String] = scala.None, streamViewType: scala.Option[java.lang.String] = scala.None, sizeBytes: scala.Option[scala.Long] = scala.None, approximateCreationDateTime: scala.Option[java.time.Instant] = scala.None) 12 | final case class Identity(principalId: scala.Option[java.lang.String] = scala.None, `type`: scala.Option[java.lang.String] = scala.None) 13 | final case class DescribeStreamInput(streamArn: java.lang.String, limit: scala.Option[scala.Int] = scala.None, exclusiveStartShardId: scala.Option[java.lang.String] = scala.None) 14 | final case class Shard(shardId: scala.Option[java.lang.String] = scala.None, parentShardId: scala.Option[java.lang.String] = scala.None, sequenceNumberRange: scala.Option[avias.dynamodbstreams.models.SequenceNumberRange] = scala.None) 15 | final case class StreamDescription(streamStatus: scala.Option[java.lang.String] = scala.None, tableName: scala.Option[java.lang.String] = scala.None, streamLabel: scala.Option[java.lang.String] = scala.None, streamArn: scala.Option[java.lang.String] = scala.None, streamViewType: scala.Option[java.lang.String] = scala.None, lastEvaluatedShardId: scala.Option[java.lang.String] = scala.None, keySchema: scala.Option[scala.List[avias.dynamodbstreams.models.KeySchemaElement]] = scala.None, shards: scala.Option[scala.List[avias.dynamodbstreams.models.Shard]] = scala.None, creationRequestDateTime: scala.Option[java.time.Instant] = scala.None) 16 | final case class TrimmedDataAccessException(message: scala.Option[java.lang.String] = scala.None) 17 | final case class GetRecordsOutput(records: scala.Option[scala.List[avias.dynamodbstreams.models.Record]] = scala.None, nextShardIterator: scala.Option[java.lang.String] = scala.None) 18 | final case class ResourceNotFoundException(message: scala.Option[java.lang.String] = scala.None) 19 | final case class DescribeStreamOutput(streamDescription: scala.Option[avias.dynamodbstreams.models.StreamDescription] = scala.None) 20 | final case class GetShardIteratorInput(streamArn: java.lang.String, shardId: java.lang.String, shardIteratorType: java.lang.String, sequenceNumber: scala.Option[java.lang.String] = scala.None) 21 | final case class ListStreamsOutput(streams: scala.Option[scala.List[avias.dynamodbstreams.models.Stream]] = scala.None, lastEvaluatedStreamArn: scala.Option[java.lang.String] = scala.None) 22 | final case class InternalServerError(message: scala.Option[java.lang.String] = scala.None) 23 | final case class ExpiredIteratorException(message: scala.Option[java.lang.String] = scala.None) --------------------------------------------------------------------------------