AWS SDK

AWS SDK

rev. 2493670155f3f484f4055f00c7816463c1a2ced2..ac5e22252d1e170d05dd8b11ceb2a7a284cd7f2e (ignoring whitespace)

Files changed:

tmp-codegen-diff/services/ec2/generated-src/main/kotlin/aws/sdk/kotlin/services/ec2/model/VpnTunnelProvisioningStatus.kt

@@ -15,15 +51,51 @@
   35     35   
            "failed" -> Failed
   36     36   
            "pending" -> Pending
   37     37   
            else -> SdkUnknown(value)
   38     38   
        }
   39     39   
   40     40   
        /**
   41     41   
         * Get a list of all possible variants
   42     42   
         */
   43     43   
        public fun values(): kotlin.collections.List<aws.sdk.kotlin.services.ec2.model.VpnTunnelProvisioningStatus> = values
   44     44   
   45         -
        private val values: kotlin.collections.List<aws.sdk.kotlin.services.ec2.model.VpnTunnelProvisioningStatus> = listOf(
          45  +
        private val values: kotlin.collections.List<aws.sdk.kotlin.services.ec2.model.VpnTunnelProvisioningStatus> by lazy { listOf(
   46     46   
            Available,
   47     47   
            Failed,
   48     48   
            Pending,
   49         -
        )
          49  +
        ) }
   50     50   
    }
   51     51   
}

tmp-codegen-diff/services/ec2/generated-src/main/kotlin/aws/sdk/kotlin/services/ec2/model/WeekDay.kt

@@ -39,39 +79,79 @@
   59     59   
            "tuesday" -> Tuesday
   60     60   
            "wednesday" -> Wednesday
   61     61   
            else -> SdkUnknown(value)
   62     62   
        }
   63     63   
   64     64   
        /**
   65     65   
         * Get a list of all possible variants
   66     66   
         */
   67     67   
        public fun values(): kotlin.collections.List<aws.sdk.kotlin.services.ec2.model.WeekDay> = values
   68     68   
   69         -
        private val values: kotlin.collections.List<aws.sdk.kotlin.services.ec2.model.WeekDay> = listOf(
          69  +
        private val values: kotlin.collections.List<aws.sdk.kotlin.services.ec2.model.WeekDay> by lazy { listOf(
   70     70   
            Friday,
   71     71   
            Monday,
   72     72   
            Saturday,
   73     73   
            Sunday,
   74     74   
            Thursday,
   75     75   
            Tuesday,
   76     76   
            Wednesday,
   77         -
        )
          77  +
        ) }
   78     78   
    }
   79     79   
}

tmp-codegen-diff/services/ec2/generated-src/main/kotlin/aws/sdk/kotlin/services/ec2/paginators/Paginators.kt

@@ -1,1 +48,49 @@
    9      9   
import aws.sdk.kotlin.services.ec2.model.AllowedPrincipal
   10     10   
import aws.sdk.kotlin.services.ec2.model.AuthorizationRule
   11     11   
import aws.sdk.kotlin.services.ec2.model.ByoipCidr
   12     12   
import aws.sdk.kotlin.services.ec2.model.CapacityBlock
   13     13   
import aws.sdk.kotlin.services.ec2.model.CapacityBlockExtension
   14     14   
import aws.sdk.kotlin.services.ec2.model.CapacityBlockExtensionOffering
   15     15   
import aws.sdk.kotlin.services.ec2.model.CapacityBlockOffering
   16     16   
import aws.sdk.kotlin.services.ec2.model.CapacityBlockStatus
   17     17   
import aws.sdk.kotlin.services.ec2.model.CapacityManagerDataExportResponse
   18     18   
import aws.sdk.kotlin.services.ec2.model.CapacityManagerDimension
          19  +
import aws.sdk.kotlin.services.ec2.model.CapacityManagerMonitoredTagKey
   19     20   
import aws.sdk.kotlin.services.ec2.model.CapacityReservation
   20     21   
import aws.sdk.kotlin.services.ec2.model.CapacityReservationBillingRequest
   21     22   
import aws.sdk.kotlin.services.ec2.model.CapacityReservationFleet
   22     23   
import aws.sdk.kotlin.services.ec2.model.CapacityReservationGroup
   23     24   
import aws.sdk.kotlin.services.ec2.model.CarrierGateway
   24     25   
import aws.sdk.kotlin.services.ec2.model.ClassicLinkDnsSupport
   25     26   
import aws.sdk.kotlin.services.ec2.model.ClassicLinkInstance
   26     27   
import aws.sdk.kotlin.services.ec2.model.ClientVpnConnection
   27     28   
import aws.sdk.kotlin.services.ec2.model.ClientVpnEndpoint
   28     29   
import aws.sdk.kotlin.services.ec2.model.ClientVpnRoute
@@ -289,290 +348,351 @@
  309    310   
import aws.sdk.kotlin.services.ec2.model.FlowLog
  310    311   
import aws.sdk.kotlin.services.ec2.model.FpgaImage
  311    312   
import aws.sdk.kotlin.services.ec2.model.GetAssociatedIpv6PoolCidrsRequest
  312    313   
import aws.sdk.kotlin.services.ec2.model.GetAssociatedIpv6PoolCidrsResponse
  313    314   
import aws.sdk.kotlin.services.ec2.model.GetAwsNetworkPerformanceDataRequest
  314    315   
import aws.sdk.kotlin.services.ec2.model.GetAwsNetworkPerformanceDataResponse
  315    316   
import aws.sdk.kotlin.services.ec2.model.GetCapacityManagerMetricDataRequest
  316    317   
import aws.sdk.kotlin.services.ec2.model.GetCapacityManagerMetricDataResponse
  317    318   
import aws.sdk.kotlin.services.ec2.model.GetCapacityManagerMetricDimensionsRequest
  318    319   
import aws.sdk.kotlin.services.ec2.model.GetCapacityManagerMetricDimensionsResponse
         320  +
import aws.sdk.kotlin.services.ec2.model.GetCapacityManagerMonitoredTagKeysRequest
         321  +
import aws.sdk.kotlin.services.ec2.model.GetCapacityManagerMonitoredTagKeysResponse
  319    322   
import aws.sdk.kotlin.services.ec2.model.GetGroupsForCapacityReservationRequest
  320    323   
import aws.sdk.kotlin.services.ec2.model.GetGroupsForCapacityReservationResponse
  321    324   
import aws.sdk.kotlin.services.ec2.model.GetInstanceTypesFromInstanceRequirementsRequest
  322    325   
import aws.sdk.kotlin.services.ec2.model.GetInstanceTypesFromInstanceRequirementsResponse
  323    326   
import aws.sdk.kotlin.services.ec2.model.GetIpamAddressHistoryRequest
  324    327   
import aws.sdk.kotlin.services.ec2.model.GetIpamAddressHistoryResponse
  325    328   
import aws.sdk.kotlin.services.ec2.model.GetIpamDiscoveredAccountsRequest
  326    329   
import aws.sdk.kotlin.services.ec2.model.GetIpamDiscoveredAccountsResponse
  327    330   
import aws.sdk.kotlin.services.ec2.model.GetIpamDiscoveredResourceCidrsRequest
  328    331   
import aws.sdk.kotlin.services.ec2.model.GetIpamDiscoveredResourceCidrsResponse
@@ -7989,7992 +8048,8105 @@
 8009   8012   
 * @return A [kotlinx.coroutines.flow.Flow] that can collect [CapacityManagerDimension]
 8010   8013   
 */
 8011   8014   
@JvmName("getCapacityManagerMetricDimensionsResponseCapacityManagerDimension")
 8012   8015   
public fun Flow<GetCapacityManagerMetricDimensionsResponse>.metricDimensionResults(): Flow<CapacityManagerDimension> =
 8013   8016   
    transform() { response ->
 8014   8017   
        response.metricDimensionResults?.forEach {
 8015   8018   
            emit(it)
 8016   8019   
        }
 8017   8020   
    }
 8018   8021   
        8022  +
/**
        8023  +
 * Paginate over [GetCapacityManagerMonitoredTagKeysResponse] results.
        8024  +
 *
        8025  +
 * When this operation is called, a [kotlinx.coroutines.Flow] is created. Flows are lazy (cold) so no service
        8026  +
 * calls are made until the flow is collected. This also means there is no guarantee that the request is valid
        8027  +
 * until then. Once you start collecting the flow, the SDK will lazily load response pages by making service
        8028  +
 * calls until there are no pages left or the flow is cancelled. If there are errors in your request, you will
        8029  +
 * see the failures only after you start collection.
        8030  +
 * @param initialRequest A [GetCapacityManagerMonitoredTagKeysRequest] to start pagination
        8031  +
 * @return A [kotlinx.coroutines.flow.Flow] that can collect [GetCapacityManagerMonitoredTagKeysResponse]
        8032  +
 */
        8033  +
public fun Ec2Client.getCapacityManagerMonitoredTagKeysPaginated(initialRequest: GetCapacityManagerMonitoredTagKeysRequest = GetCapacityManagerMonitoredTagKeysRequest { }): Flow<GetCapacityManagerMonitoredTagKeysResponse> =
        8034  +
    flow {
        8035  +
        var cursor: kotlin.String? = initialRequest.nextToken
        8036  +
        var hasNextPage: Boolean = true
        8037  +
        8038  +
        while (hasNextPage) {
        8039  +
            val req = initialRequest.copy {
        8040  +
                this.nextToken = cursor
        8041  +
            }
        8042  +
            val result = this@getCapacityManagerMonitoredTagKeysPaginated.getCapacityManagerMonitoredTagKeys(req)
        8043  +
            cursor = result.nextToken
        8044  +
            hasNextPage = cursor?.isNotEmpty() == true
        8045  +
            emit(result)
        8046  +
        }
        8047  +
    }
        8048  +
        8049  +
/**
        8050  +
 * Paginate over [GetCapacityManagerMonitoredTagKeysResponse] results.
        8051  +
 *
        8052  +
 * When this operation is called, a [kotlinx.coroutines.Flow] is created. Flows are lazy (cold) so no service
        8053  +
 * calls are made until the flow is collected. This also means there is no guarantee that the request is valid
        8054  +
 * until then. Once you start collecting the flow, the SDK will lazily load response pages by making service
        8055  +
 * calls until there are no pages left or the flow is cancelled. If there are errors in your request, you will
        8056  +
 * see the failures only after you start collection.
        8057  +
 * @param block A builder block used for DSL-style invocation of the operation
        8058  +
 * @return A [kotlinx.coroutines.flow.Flow] that can collect [GetCapacityManagerMonitoredTagKeysResponse]
        8059  +
 */
        8060  +
public fun Ec2Client.getCapacityManagerMonitoredTagKeysPaginated(block: GetCapacityManagerMonitoredTagKeysRequest.Builder.() -> Unit): Flow<GetCapacityManagerMonitoredTagKeysResponse> =
        8061  +
    getCapacityManagerMonitoredTagKeysPaginated(GetCapacityManagerMonitoredTagKeysRequest.Builder().apply(block).build())
        8062  +
        8063  +
/**
        8064  +
 * This paginator transforms the flow returned by [getCapacityManagerMonitoredTagKeysPaginated]
        8065  +
 * to access the nested member [CapacityManagerMonitoredTagKey]
        8066  +
 * @return A [kotlinx.coroutines.flow.Flow] that can collect [CapacityManagerMonitoredTagKey]
        8067  +
 */
        8068  +
@JvmName("getCapacityManagerMonitoredTagKeysResponseCapacityManagerMonitoredTagKey")
        8069  +
public fun Flow<GetCapacityManagerMonitoredTagKeysResponse>.capacityManagerTagKeys(): Flow<CapacityManagerMonitoredTagKey> =
        8070  +
    transform() { response ->
        8071  +
        response.capacityManagerTagKeys?.forEach {
        8072  +
            emit(it)
        8073  +
        }
        8074  +
    }
        8075  +
 8019   8076   
/**
 8020   8077   
 * Paginate over [GetGroupsForCapacityReservationResponse] results.
 8021   8078   
 *
 8022   8079   
 * When this operation is called, a [kotlinx.coroutines.Flow] is created. Flows are lazy (cold) so no service
 8023   8080   
 * calls are made until the flow is collected. This also means there is no guarantee that the request is valid
 8024   8081   
 * until then. Once you start collecting the flow, the SDK will lazily load response pages by making service
 8025   8082   
 * calls until there are no pages left or the flow is cancelled. If there are errors in your request, you will
 8026   8083   
 * see the failures only after you start collection.
 8027   8084   
 * @param initialRequest A [GetGroupsForCapacityReservationRequest] to start pagination
 8028   8085   
 * @return A [kotlinx.coroutines.flow.Flow] that can collect [GetGroupsForCapacityReservationResponse]

tmp-codegen-diff/services/ec2/generated-src/main/kotlin/aws/sdk/kotlin/services/ec2/serde/AssociateClientVpnTargetNetworkOperationSerializer.kt

@@ -19,19 +70,76 @@
   39     39   
        builder.body = HttpBody.fromBytes(payload)
   40     40   
        if (builder.body !is HttpBody.Empty) {
   41     41   
            builder.headers.setMissing("Content-Type", "application/x-www-form-urlencoded")
   42     42   
        }
   43     43   
        return builder
   44     44   
    }
   45     45   
}
   46     46   
   47     47   
private fun serializeAssociateClientVpnTargetNetworkOperationBody(context: ExecutionContext, input: AssociateClientVpnTargetNetworkRequest): ByteArray {
   48     48   
    val serializer = FormUrlSerializer()
          49  +
    val AVAILABILITYZONE_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, FormUrlSerialName("AvailabilityZone"))
          50  +
    val AVAILABILITYZONEID_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, FormUrlSerialName("AvailabilityZoneId"))
   49     51   
    val CLIENTTOKEN_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, FormUrlSerialName("ClientToken"))
   50     52   
    val CLIENTVPNENDPOINTID_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, FormUrlSerialName("ClientVpnEndpointId"))
   51     53   
    val DRYRUN_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Boolean, FormUrlSerialName("DryRun"))
   52     54   
    val SUBNETID_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, FormUrlSerialName("SubnetId"))
   53     55   
    val OBJ_DESCRIPTOR = SdkObjectDescriptor.build {
   54     56   
        trait(FormUrlSerialName("AssociateClientVpnTargetNetworkRequest"))
   55     57   
        trait(QueryLiteral("Action", "AssociateClientVpnTargetNetwork"))
   56     58   
        trait(QueryLiteral("Version", "2016-11-15"))
          59  +
        field(AVAILABILITYZONE_DESCRIPTOR)
          60  +
        field(AVAILABILITYZONEID_DESCRIPTOR)
   57     61   
        field(CLIENTTOKEN_DESCRIPTOR)
   58     62   
        field(CLIENTVPNENDPOINTID_DESCRIPTOR)
   59     63   
        field(DRYRUN_DESCRIPTOR)
   60     64   
        field(SUBNETID_DESCRIPTOR)
   61     65   
    }
   62     66   
   63     67   
    serializer.serializeStruct(OBJ_DESCRIPTOR) {
          68  +
        input.availabilityZone?.let { field(AVAILABILITYZONE_DESCRIPTOR, it) }
          69  +
        input.availabilityZoneId?.let { field(AVAILABILITYZONEID_DESCRIPTOR, it) }
   64     70   
        input.clientToken?.let { field(CLIENTTOKEN_DESCRIPTOR, it) } ?: field(CLIENTTOKEN_DESCRIPTOR, context.idempotencyTokenProvider.generateToken())
   65     71   
        input.clientVpnEndpointId?.let { field(CLIENTVPNENDPOINTID_DESCRIPTOR, it) }
   66     72   
        input.dryRun?.let { field(DRYRUN_DESCRIPTOR, it) }
   67     73   
        input.subnetId?.let { field(SUBNETID_DESCRIPTOR, it) }
   68     74   
    }
   69     75   
    return serializer.toByteArray()
   70     76   
}

tmp-codegen-diff/services/ec2/generated-src/main/kotlin/aws/sdk/kotlin/services/ec2/serde/CapacityManagerDimensionDocumentDeserializer.kt

@@ -2,2 +87,92 @@
   22     22   
        when (curr.tagName) {
   23     23   
            // ResourceRegion com.amazonaws.ec2#CapacityManagerDimension$ResourceRegion
   24     24   
            "resourceRegion" -> builder.resourceRegion = curr.tryData()
   25     25   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
   26     26   
            // AvailabilityZoneId com.amazonaws.ec2#CapacityManagerDimension$AvailabilityZoneId
   27     27   
            "availabilityZoneId" -> builder.availabilityZoneId = curr.tryData()
   28     28   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
   29     29   
            // AccountId com.amazonaws.ec2#CapacityManagerDimension$AccountId
   30     30   
            "accountId" -> builder.accountId = curr.tryData()
   31     31   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
          32  +
            // AccountName com.amazonaws.ec2#CapacityManagerDimension$AccountName
          33  +
            "accountName" -> builder.accountName = curr.tryData()
          34  +
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
   32     35   
            // InstanceFamily com.amazonaws.ec2#CapacityManagerDimension$InstanceFamily
   33     36   
            "instanceFamily" -> builder.instanceFamily = curr.tryData()
   34     37   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
   35     38   
            // InstanceType com.amazonaws.ec2#CapacityManagerDimension$InstanceType
   36     39   
            "instanceType" -> builder.instanceType = curr.tryData()
   37     40   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
   38     41   
            // InstancePlatform com.amazonaws.ec2#CapacityManagerDimension$InstancePlatform
   39     42   
            "instancePlatform" -> builder.instancePlatform = curr.tryData()
   40     43   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
   41     44   
            // ReservationArn com.amazonaws.ec2#CapacityManagerDimension$ReservationArn
   42     45   
            "reservationArn" -> builder.reservationArn = curr.tryData()
   43     46   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
   44     47   
            // ReservationId com.amazonaws.ec2#CapacityManagerDimension$ReservationId
   45     48   
            "reservationId" -> builder.reservationId = curr.tryData()
   46     49   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
   47     50   
            // ReservationType com.amazonaws.ec2#CapacityManagerDimension$ReservationType
   48     51   
            "reservationType" -> builder.reservationType = curr.tryData()
   49     52   
                .parse { ReservationType.fromValue(it) }
   50     53   
                .getOrDeserializeErr { "expected (enum: `com.amazonaws.ec2#ReservationType`)" }
   51     54   
            // ReservationCreateTimestamp com.amazonaws.ec2#CapacityManagerDimension$ReservationCreateTimestamp
   52     55   
            "reservationCreateTimestamp" -> builder.reservationCreateTimestamp = curr.tryData()
   53     56   
                .parseTimestamp(TimestampFormat.ISO_8601)
   54     57   
                .getOrDeserializeErr { "expected (timestamp: `com.amazonaws.ec2#MillisecondDateTime`)" }
   55     58   
            // ReservationStartTimestamp com.amazonaws.ec2#CapacityManagerDimension$ReservationStartTimestamp
   56     59   
            "reservationStartTimestamp" -> builder.reservationStartTimestamp = curr.tryData()
   57     60   
                .parseTimestamp(TimestampFormat.ISO_8601)
   58     61   
                .getOrDeserializeErr { "expected (timestamp: `com.amazonaws.ec2#MillisecondDateTime`)" }
   59     62   
            // ReservationEndTimestamp com.amazonaws.ec2#CapacityManagerDimension$ReservationEndTimestamp
   60     63   
            "reservationEndTimestamp" -> builder.reservationEndTimestamp = curr.tryData()
   61     64   
                .parseTimestamp(TimestampFormat.ISO_8601)
   62     65   
                .getOrDeserializeErr { "expected (timestamp: `com.amazonaws.ec2#MillisecondDateTime`)" }
   63     66   
            // ReservationEndDateType com.amazonaws.ec2#CapacityManagerDimension$ReservationEndDateType
   64     67   
            "reservationEndDateType" -> builder.reservationEndDateType = curr.tryData()
   65     68   
                .parse { ReservationEndDateType.fromValue(it) }
   66     69   
                .getOrDeserializeErr { "expected (enum: `com.amazonaws.ec2#ReservationEndDateType`)" }
   67     70   
            // Tenancy com.amazonaws.ec2#CapacityManagerDimension$Tenancy
   68     71   
            "tenancy" -> builder.tenancy = curr.tryData()
   69     72   
                .parse { CapacityTenancy.fromValue(it) }
   70     73   
                .getOrDeserializeErr { "expected (enum: `com.amazonaws.ec2#CapacityTenancy`)" }
   71     74   
            // ReservationState com.amazonaws.ec2#CapacityManagerDimension$ReservationState
   72     75   
            "reservationState" -> builder.reservationState = curr.tryData()
   73     76   
                .parse { ReservationState.fromValue(it) }
   74     77   
                .getOrDeserializeErr { "expected (enum: `com.amazonaws.ec2#ReservationState`)" }
   75     78   
            // ReservationInstanceMatchCriteria com.amazonaws.ec2#CapacityManagerDimension$ReservationInstanceMatchCriteria
   76     79   
            "reservationInstanceMatchCriteria" -> builder.reservationInstanceMatchCriteria = curr.tryData()
   77     80   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
   78     81   
            // ReservationUnusedFinancialOwner com.amazonaws.ec2#CapacityManagerDimension$ReservationUnusedFinancialOwner
   79     82   
            "reservationUnusedFinancialOwner" -> builder.reservationUnusedFinancialOwner = curr.tryData()
   80     83   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
          84  +
            // Tags com.amazonaws.ec2#CapacityManagerDimension$Tags
          85  +
            "tagSet" -> builder.tags = deserializeCapacityManagerTagDimensionSetShape(curr)
   81     86   
            else -> {}
   82     87   
        }
   83     88   
        curr.drop()
   84     89   
    }
   85     90   
    builder.correctErrors()
   86     91   
    return builder.build()
   87     92   
}

tmp-codegen-diff/services/ec2/generated-src/main/kotlin/aws/sdk/kotlin/services/ec2/serde/ClientVpnEndpointDocumentDeserializer.kt

@@ -72,72 +108,110 @@
   92     92   
                .parseBoolean()
   93     93   
                .getOrDeserializeErr { "expected (boolean: `com.amazonaws.ec2#Boolean`)" }
   94     94   
            // EndpointIpAddressType com.amazonaws.ec2#ClientVpnEndpoint$EndpointIpAddressType
   95     95   
            "endpointIpAddressType" -> builder.endpointIpAddressType = curr.tryData()
   96     96   
                .parse { EndpointIpAddressType.fromValue(it) }
   97     97   
                .getOrDeserializeErr { "expected (enum: `com.amazonaws.ec2#EndpointIpAddressType`)" }
   98     98   
            // TrafficIpAddressType com.amazonaws.ec2#ClientVpnEndpoint$TrafficIpAddressType
   99     99   
            "trafficIpAddressType" -> builder.trafficIpAddressType = curr.tryData()
  100    100   
                .parse { TrafficIpAddressType.fromValue(it) }
  101    101   
                .getOrDeserializeErr { "expected (enum: `com.amazonaws.ec2#TrafficIpAddressType`)" }
         102  +
            // TransitGatewayConfiguration com.amazonaws.ec2#ClientVpnEndpoint$TransitGatewayConfiguration
         103  +
            "transitGatewayConfiguration" -> builder.transitGatewayConfiguration = deserializeTransitGatewayConfigurationDescribeEndpointStructureDocument(curr)
  102    104   
            else -> {}
  103    105   
        }
  104    106   
        curr.drop()
  105    107   
    }
  106    108   
    builder.correctErrors()
  107    109   
    return builder.build()
  108    110   
}

tmp-codegen-diff/services/ec2/generated-src/main/kotlin/aws/sdk/kotlin/services/ec2/serde/ClientVpnRouteDocumentDeserializer.kt

@@ -6,6 +42,45 @@
   26     26   
            "type" -> builder.type = curr.tryData()
   27     27   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
   28     28   
            // Origin com.amazonaws.ec2#ClientVpnRoute$Origin
   29     29   
            "origin" -> builder.origin = curr.tryData()
   30     30   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
   31     31   
            // Status com.amazonaws.ec2#ClientVpnRoute$Status
   32     32   
            "status" -> builder.status = deserializeClientVpnRouteStatusDocument(curr)
   33     33   
            // Description com.amazonaws.ec2#ClientVpnRoute$Description
   34     34   
            "description" -> builder.description = curr.tryData()
   35     35   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
          36  +
            // TransitGatewayAttachmentId com.amazonaws.ec2#ClientVpnRoute$TransitGatewayAttachmentId
          37  +
            "transitGatewayAttachmentId" -> builder.transitGatewayAttachmentId = curr.tryData()
          38  +
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#TransitGatewayAttachmentId`)" }
   36     39   
            else -> {}
   37     40   
        }
   38     41   
        curr.drop()
   39     42   
    }
   40     43   
    builder.correctErrors()
   41     44   
    return builder.build()
   42     45   
}

tmp-codegen-diff/services/ec2/generated-src/main/kotlin/aws/sdk/kotlin/services/ec2/serde/CreateClientVpnEndpointOperationSerializer.kt

@@ -1,1 +44,45 @@
    5      5   
import aws.sdk.kotlin.services.ec2.model.ClientConnectOptions
    6      6   
import aws.sdk.kotlin.services.ec2.model.ClientLoginBannerOptions
    7      7   
import aws.sdk.kotlin.services.ec2.model.ClientRouteEnforcementOptions
    8      8   
import aws.sdk.kotlin.services.ec2.model.ClientVpnAuthenticationRequest
    9      9   
import aws.sdk.kotlin.services.ec2.model.ConnectionLogOptions
   10     10   
import aws.sdk.kotlin.services.ec2.model.CreateClientVpnEndpointRequest
   11     11   
import aws.sdk.kotlin.services.ec2.model.EndpointIpAddressType
   12     12   
import aws.sdk.kotlin.services.ec2.model.SelfServicePortal
   13     13   
import aws.sdk.kotlin.services.ec2.model.TagSpecification
   14     14   
import aws.sdk.kotlin.services.ec2.model.TrafficIpAddressType
          15  +
import aws.sdk.kotlin.services.ec2.model.TransitGatewayConfigurationInputStructure
   15     16   
import aws.sdk.kotlin.services.ec2.model.TransportProtocol
   16     17   
import aws.smithy.kotlin.runtime.client.idempotencyTokenProvider
   17     18   
import aws.smithy.kotlin.runtime.http.HttpBody
   18     19   
import aws.smithy.kotlin.runtime.http.HttpMethod
   19     20   
import aws.smithy.kotlin.runtime.http.operation.HttpSerializer
   20     21   
import aws.smithy.kotlin.runtime.http.request.HttpRequestBuilder
   21     22   
import aws.smithy.kotlin.runtime.http.request.url
   22     23   
import aws.smithy.kotlin.runtime.operation.ExecutionContext
   23     24   
import aws.smithy.kotlin.runtime.serde.SdkFieldDescriptor
   24     25   
import aws.smithy.kotlin.runtime.serde.SdkObjectDescriptor
@@ -49,50 +159,163 @@
   69     70   
    val DNSSERVERS_DESCRIPTOR = SdkFieldDescriptor(SerialKind.List, FormUrlSerialName("DnsServers"), FormUrlFlattened)
   70     71   
    val DRYRUN_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Boolean, FormUrlSerialName("DryRun"))
   71     72   
    val ENDPOINTIPADDRESSTYPE_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Enum, FormUrlSerialName("EndpointIpAddressType"))
   72     73   
    val SECURITYGROUPIDS_DESCRIPTOR = SdkFieldDescriptor(SerialKind.List, FormUrlSerialName("SecurityGroupId"), FormUrlFlattened)
   73     74   
    val SELFSERVICEPORTAL_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Enum, FormUrlSerialName("SelfServicePortal"))
   74     75   
    val SERVERCERTIFICATEARN_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, FormUrlSerialName("ServerCertificateArn"))
   75     76   
    val SESSIONTIMEOUTHOURS_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Integer, FormUrlSerialName("SessionTimeoutHours"))
   76     77   
    val SPLITTUNNEL_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Boolean, FormUrlSerialName("SplitTunnel"))
   77     78   
    val TAGSPECIFICATIONS_DESCRIPTOR = SdkFieldDescriptor(SerialKind.List, FormUrlSerialName("TagSpecification"), FormUrlFlattened)
   78     79   
    val TRAFFICIPADDRESSTYPE_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Enum, FormUrlSerialName("TrafficIpAddressType"))
          80  +
    val TRANSITGATEWAYCONFIGURATION_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Struct, FormUrlSerialName("TransitGatewayConfiguration"))
   79     81   
    val TRANSPORTPROTOCOL_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Enum, FormUrlSerialName("TransportProtocol"))
   80     82   
    val VPCID_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, FormUrlSerialName("VpcId"))
   81     83   
    val VPNPORT_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Integer, FormUrlSerialName("VpnPort"))
   82     84   
    val OBJ_DESCRIPTOR = SdkObjectDescriptor.build {
   83     85   
        trait(FormUrlSerialName("CreateClientVpnEndpointRequest"))
   84     86   
        trait(QueryLiteral("Action", "CreateClientVpnEndpoint"))
   85     87   
        trait(QueryLiteral("Version", "2016-11-15"))
   86     88   
        field(AUTHENTICATIONOPTIONS_DESCRIPTOR)
   87     89   
        field(CLIENTCIDRBLOCK_DESCRIPTOR)
   88     90   
        field(CLIENTCONNECTOPTIONS_DESCRIPTOR)
   89     91   
        field(CLIENTLOGINBANNEROPTIONS_DESCRIPTOR)
   90     92   
        field(CLIENTROUTEENFORCEMENTOPTIONS_DESCRIPTOR)
   91     93   
        field(CLIENTTOKEN_DESCRIPTOR)
   92     94   
        field(CONNECTIONLOGOPTIONS_DESCRIPTOR)
   93     95   
        field(DESCRIPTION_DESCRIPTOR)
   94     96   
        field(DISCONNECTONSESSIONTIMEOUT_DESCRIPTOR)
   95     97   
        field(DNSSERVERS_DESCRIPTOR)
   96     98   
        field(DRYRUN_DESCRIPTOR)
   97     99   
        field(ENDPOINTIPADDRESSTYPE_DESCRIPTOR)
   98    100   
        field(SECURITYGROUPIDS_DESCRIPTOR)
   99    101   
        field(SELFSERVICEPORTAL_DESCRIPTOR)
  100    102   
        field(SERVERCERTIFICATEARN_DESCRIPTOR)
  101    103   
        field(SESSIONTIMEOUTHOURS_DESCRIPTOR)
  102    104   
        field(SPLITTUNNEL_DESCRIPTOR)
  103    105   
        field(TAGSPECIFICATIONS_DESCRIPTOR)
  104    106   
        field(TRAFFICIPADDRESSTYPE_DESCRIPTOR)
         107  +
        field(TRANSITGATEWAYCONFIGURATION_DESCRIPTOR)
  105    108   
        field(TRANSPORTPROTOCOL_DESCRIPTOR)
  106    109   
        field(VPCID_DESCRIPTOR)
  107    110   
        field(VPNPORT_DESCRIPTOR)
  108    111   
    }
  109    112   
  110    113   
    serializer.serializeStruct(OBJ_DESCRIPTOR) {
  111    114   
        if (!input.authenticationOptions.isNullOrEmpty()) {
  112    115   
            listField(AUTHENTICATIONOPTIONS_DESCRIPTOR) {
  113    116   
                for (el0 in input.authenticationOptions) {
  114    117   
                    serializeSdkSerializable(asSdkSerializable(el0, ::serializeClientVpnAuthenticationRequestDocument))
  115    118   
                }
  116    119   
            }
  117    120   
        }
  118    121   
        input.clientCidrBlock?.let { field(CLIENTCIDRBLOCK_DESCRIPTOR, it) }
  119    122   
        input.clientConnectOptions?.let { field(CLIENTCONNECTOPTIONS_DESCRIPTOR, it, ::serializeClientConnectOptionsDocument) }
  120    123   
        input.clientLoginBannerOptions?.let { field(CLIENTLOGINBANNEROPTIONS_DESCRIPTOR, it, ::serializeClientLoginBannerOptionsDocument) }
  121    124   
        input.clientRouteEnforcementOptions?.let { field(CLIENTROUTEENFORCEMENTOPTIONS_DESCRIPTOR, it, ::serializeClientRouteEnforcementOptionsDocument) }
  122    125   
        input.clientToken?.let { field(CLIENTTOKEN_DESCRIPTOR, it) } ?: field(CLIENTTOKEN_DESCRIPTOR, context.idempotencyTokenProvider.generateToken())
  123    126   
        input.connectionLogOptions?.let { field(CONNECTIONLOGOPTIONS_DESCRIPTOR, it, ::serializeConnectionLogOptionsDocument) }
  124    127   
        input.description?.let { field(DESCRIPTION_DESCRIPTOR, it) }
  125    128   
        input.disconnectOnSessionTimeout?.let { field(DISCONNECTONSESSIONTIMEOUT_DESCRIPTOR, it) }
  126    129   
        if (!input.dnsServers.isNullOrEmpty()) {
  127    130   
            listField(DNSSERVERS_DESCRIPTOR) {
  128    131   
                for (el0 in input.dnsServers) {
  129    132   
                    serializeString(el0)
  130    133   
                }
  131    134   
            }
  132    135   
        }
  133    136   
        input.dryRun?.let { field(DRYRUN_DESCRIPTOR, it) }
  134    137   
        input.endpointIpAddressType?.let { field(ENDPOINTIPADDRESSTYPE_DESCRIPTOR, it.value) }
  135    138   
        if (!input.securityGroupIds.isNullOrEmpty()) {
  136    139   
            listField(SECURITYGROUPIDS_DESCRIPTOR) {
  137    140   
                for (el0 in input.securityGroupIds) {
  138    141   
                    serializeString(el0)
  139    142   
                }
  140    143   
            }
  141    144   
        }
  142    145   
        input.selfServicePortal?.let { field(SELFSERVICEPORTAL_DESCRIPTOR, it.value) }
  143    146   
        input.serverCertificateArn?.let { field(SERVERCERTIFICATEARN_DESCRIPTOR, it) }
  144    147   
        input.sessionTimeoutHours?.let { field(SESSIONTIMEOUTHOURS_DESCRIPTOR, it) }
  145    148   
        input.splitTunnel?.let { field(SPLITTUNNEL_DESCRIPTOR, it) }
  146    149   
        if (!input.tagSpecifications.isNullOrEmpty()) {
  147    150   
            listField(TAGSPECIFICATIONS_DESCRIPTOR) {
  148    151   
                for (el0 in input.tagSpecifications) {
  149    152   
                    serializeSdkSerializable(asSdkSerializable(el0, ::serializeTagSpecificationDocument))
  150    153   
                }
  151    154   
            }
  152    155   
        }
  153    156   
        input.trafficIpAddressType?.let { field(TRAFFICIPADDRESSTYPE_DESCRIPTOR, it.value) }
         157  +
        input.transitGatewayConfiguration?.let { field(TRANSITGATEWAYCONFIGURATION_DESCRIPTOR, it, ::serializeTransitGatewayConfigurationInputStructureDocument) }
  154    158   
        input.transportProtocol?.let { field(TRANSPORTPROTOCOL_DESCRIPTOR, it.value) }
  155    159   
        input.vpcId?.let { field(VPCID_DESCRIPTOR, it) }
  156    160   
        input.vpnPort?.let { field(VPNPORT_DESCRIPTOR, it) }
  157    161   
    }
  158    162   
    return serializer.toByteArray()
  159    163   
}

tmp-codegen-diff/services/ec2/generated-src/main/kotlin/aws/sdk/kotlin/services/ec2/serde/ModifyClientVpnEndpointOperationSerializer.kt

@@ -1,1 +118,122 @@
    2      2   
    3      3   
package aws.sdk.kotlin.services.ec2.serde
    4      4   
    5      5   
import aws.sdk.kotlin.services.ec2.model.ClientConnectOptions
    6      6   
import aws.sdk.kotlin.services.ec2.model.ClientLoginBannerOptions
    7      7   
import aws.sdk.kotlin.services.ec2.model.ClientRouteEnforcementOptions
    8      8   
import aws.sdk.kotlin.services.ec2.model.ConnectionLogOptions
    9      9   
import aws.sdk.kotlin.services.ec2.model.DnsServersOptionsModifyStructure
   10     10   
import aws.sdk.kotlin.services.ec2.model.ModifyClientVpnEndpointRequest
   11     11   
import aws.sdk.kotlin.services.ec2.model.SelfServicePortal
          12  +
import aws.sdk.kotlin.services.ec2.model.TransitGatewayConfigurationInputStructure
   12     13   
import aws.smithy.kotlin.runtime.http.HttpBody
   13     14   
import aws.smithy.kotlin.runtime.http.HttpMethod
   14     15   
import aws.smithy.kotlin.runtime.http.operation.HttpSerializer
   15     16   
import aws.smithy.kotlin.runtime.http.request.HttpRequestBuilder
   16     17   
import aws.smithy.kotlin.runtime.http.request.url
   17     18   
import aws.smithy.kotlin.runtime.operation.ExecutionContext
   18     19   
import aws.smithy.kotlin.runtime.serde.SdkFieldDescriptor
   19     20   
import aws.smithy.kotlin.runtime.serde.SdkObjectDescriptor
   20     21   
import aws.smithy.kotlin.runtime.serde.SerialKind
   21     22   
import aws.smithy.kotlin.runtime.serde.asSdkSerializable
   22     23   
import aws.smithy.kotlin.runtime.serde.deserializeList
   23     24   
import aws.smithy.kotlin.runtime.serde.deserializeMap
   24     25   
import aws.smithy.kotlin.runtime.serde.deserializeStruct
   25     26   
import aws.smithy.kotlin.runtime.serde.field
   26     27   
import aws.smithy.kotlin.runtime.serde.formurl.FormUrlFlattened
   27     28   
import aws.smithy.kotlin.runtime.serde.formurl.FormUrlSerialName
   28     29   
import aws.smithy.kotlin.runtime.serde.formurl.FormUrlSerializer
   29     30   
import aws.smithy.kotlin.runtime.serde.formurl.QueryLiteral
   30     31   
import aws.smithy.kotlin.runtime.serde.serializeList
   31     32   
import aws.smithy.kotlin.runtime.serde.serializeMap
   32     33   
import aws.smithy.kotlin.runtime.serde.serializeStruct
   33     34   
   34     35   
   35     36   
internal class ModifyClientVpnEndpointOperationSerializer: HttpSerializer.NonStreaming<ModifyClientVpnEndpointRequest> {
   36     37   
    override fun serialize(context: ExecutionContext, input: ModifyClientVpnEndpointRequest): HttpRequestBuilder {
   37     38   
        val builder = HttpRequestBuilder()
   38     39   
        builder.method = HttpMethod.POST
   39     40   
   40     41   
        builder.url {
   41     42   
            path.encoded = "/"
   42     43   
        }
   43     44   
   44     45   
        val payload = serializeModifyClientVpnEndpointOperationBody(context, input)
   45     46   
        builder.body = HttpBody.fromBytes(payload)
   46     47   
        if (builder.body !is HttpBody.Empty) {
   47     48   
            builder.headers.setMissing("Content-Type", "application/x-www-form-urlencoded")
   48     49   
        }
   49     50   
        return builder
   50     51   
    }
   51     52   
}
   52     53   
   53     54   
private fun serializeModifyClientVpnEndpointOperationBody(context: ExecutionContext, input: ModifyClientVpnEndpointRequest): ByteArray {
   54     55   
    val serializer = FormUrlSerializer()
   55     56   
    val CLIENTCONNECTOPTIONS_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Struct, FormUrlSerialName("ClientConnectOptions"))
   56     57   
    val CLIENTLOGINBANNEROPTIONS_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Struct, FormUrlSerialName("ClientLoginBannerOptions"))
   57     58   
    val CLIENTROUTEENFORCEMENTOPTIONS_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Struct, FormUrlSerialName("ClientRouteEnforcementOptions"))
   58     59   
    val CLIENTVPNENDPOINTID_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, FormUrlSerialName("ClientVpnEndpointId"))
   59     60   
    val CONNECTIONLOGOPTIONS_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Struct, FormUrlSerialName("ConnectionLogOptions"))
   60     61   
    val DESCRIPTION_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, FormUrlSerialName("Description"))
   61     62   
    val DISCONNECTONSESSIONTIMEOUT_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Boolean, FormUrlSerialName("DisconnectOnSessionTimeout"))
   62     63   
    val DNSSERVERS_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Struct, FormUrlSerialName("DnsServers"))
   63     64   
    val DRYRUN_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Boolean, FormUrlSerialName("DryRun"))
   64     65   
    val SECURITYGROUPIDS_DESCRIPTOR = SdkFieldDescriptor(SerialKind.List, FormUrlSerialName("SecurityGroupId"), FormUrlFlattened)
   65     66   
    val SELFSERVICEPORTAL_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Enum, FormUrlSerialName("SelfServicePortal"))
   66     67   
    val SERVERCERTIFICATEARN_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, FormUrlSerialName("ServerCertificateArn"))
   67     68   
    val SESSIONTIMEOUTHOURS_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Integer, FormUrlSerialName("SessionTimeoutHours"))
   68     69   
    val SPLITTUNNEL_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Boolean, FormUrlSerialName("SplitTunnel"))
          70  +
    val TRANSITGATEWAYCONFIGURATION_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Struct, FormUrlSerialName("TransitGatewayConfiguration"))
   69     71   
    val VPCID_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, FormUrlSerialName("VpcId"))
   70     72   
    val VPNPORT_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Integer, FormUrlSerialName("VpnPort"))
   71     73   
    val OBJ_DESCRIPTOR = SdkObjectDescriptor.build {
   72     74   
        trait(FormUrlSerialName("ModifyClientVpnEndpointRequest"))
   73     75   
        trait(QueryLiteral("Action", "ModifyClientVpnEndpoint"))
   74     76   
        trait(QueryLiteral("Version", "2016-11-15"))
   75     77   
        field(CLIENTCONNECTOPTIONS_DESCRIPTOR)
   76     78   
        field(CLIENTLOGINBANNEROPTIONS_DESCRIPTOR)
   77     79   
        field(CLIENTROUTEENFORCEMENTOPTIONS_DESCRIPTOR)
   78     80   
        field(CLIENTVPNENDPOINTID_DESCRIPTOR)
   79     81   
        field(CONNECTIONLOGOPTIONS_DESCRIPTOR)
   80     82   
        field(DESCRIPTION_DESCRIPTOR)
   81     83   
        field(DISCONNECTONSESSIONTIMEOUT_DESCRIPTOR)
   82     84   
        field(DNSSERVERS_DESCRIPTOR)
   83     85   
        field(DRYRUN_DESCRIPTOR)
   84     86   
        field(SECURITYGROUPIDS_DESCRIPTOR)
   85     87   
        field(SELFSERVICEPORTAL_DESCRIPTOR)
   86     88   
        field(SERVERCERTIFICATEARN_DESCRIPTOR)
   87     89   
        field(SESSIONTIMEOUTHOURS_DESCRIPTOR)
   88     90   
        field(SPLITTUNNEL_DESCRIPTOR)
          91  +
        field(TRANSITGATEWAYCONFIGURATION_DESCRIPTOR)
   89     92   
        field(VPCID_DESCRIPTOR)
   90     93   
        field(VPNPORT_DESCRIPTOR)
   91     94   
    }
   92     95   
   93     96   
    serializer.serializeStruct(OBJ_DESCRIPTOR) {
   94     97   
        input.clientConnectOptions?.let { field(CLIENTCONNECTOPTIONS_DESCRIPTOR, it, ::serializeClientConnectOptionsDocument) }
   95     98   
        input.clientLoginBannerOptions?.let { field(CLIENTLOGINBANNEROPTIONS_DESCRIPTOR, it, ::serializeClientLoginBannerOptionsDocument) }
   96     99   
        input.clientRouteEnforcementOptions?.let { field(CLIENTROUTEENFORCEMENTOPTIONS_DESCRIPTOR, it, ::serializeClientRouteEnforcementOptionsDocument) }
   97    100   
        input.clientVpnEndpointId?.let { field(CLIENTVPNENDPOINTID_DESCRIPTOR, it) }
   98    101   
        input.connectionLogOptions?.let { field(CONNECTIONLOGOPTIONS_DESCRIPTOR, it, ::serializeConnectionLogOptionsDocument) }
   99    102   
        input.description?.let { field(DESCRIPTION_DESCRIPTOR, it) }
  100    103   
        input.disconnectOnSessionTimeout?.let { field(DISCONNECTONSESSIONTIMEOUT_DESCRIPTOR, it) }
  101    104   
        input.dnsServers?.let { field(DNSSERVERS_DESCRIPTOR, it, ::serializeDnsServersOptionsModifyStructureDocument) }
  102    105   
        input.dryRun?.let { field(DRYRUN_DESCRIPTOR, it) }
  103    106   
        if (!input.securityGroupIds.isNullOrEmpty()) {
  104    107   
            listField(SECURITYGROUPIDS_DESCRIPTOR) {
  105    108   
                for (el0 in input.securityGroupIds) {
  106    109   
                    serializeString(el0)
  107    110   
                }
  108    111   
            }
  109    112   
        }
  110    113   
        input.selfServicePortal?.let { field(SELFSERVICEPORTAL_DESCRIPTOR, it.value) }
  111    114   
        input.serverCertificateArn?.let { field(SERVERCERTIFICATEARN_DESCRIPTOR, it) }
  112    115   
        input.sessionTimeoutHours?.let { field(SESSIONTIMEOUTHOURS_DESCRIPTOR, it) }
  113    116   
        input.splitTunnel?.let { field(SPLITTUNNEL_DESCRIPTOR, it) }
         117  +
        input.transitGatewayConfiguration?.let { field(TRANSITGATEWAYCONFIGURATION_DESCRIPTOR, it, ::serializeTransitGatewayConfigurationInputStructureDocument) }
  114    118   
        input.vpcId?.let { field(VPCID_DESCRIPTOR, it) }
  115    119   
        input.vpnPort?.let { field(VPNPORT_DESCRIPTOR, it) }
  116    120   
    }
  117    121   
    return serializer.toByteArray()
  118    122   
}

tmp-codegen-diff/services/ec2/generated-src/main/kotlin/aws/sdk/kotlin/services/ec2/serde/TargetNetworkDocumentDeserializer.kt

@@ -2,2 +38,42 @@
   22     22   
            // TargetNetworkId com.amazonaws.ec2#TargetNetwork$TargetNetworkId
   23     23   
            "targetNetworkId" -> builder.targetNetworkId = curr.tryData()
   24     24   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
   25     25   
            // ClientVpnEndpointId com.amazonaws.ec2#TargetNetwork$ClientVpnEndpointId
   26     26   
            "clientVpnEndpointId" -> builder.clientVpnEndpointId = curr.tryData()
   27     27   
                .getOrDeserializeErr { "expected (string: `com.amazonaws.ec2#String`)" }
   28     28   
            // Status com.amazonaws.ec2#TargetNetwork$Status
   29     29   
            "status" -> builder.status = deserializeAssociationStatusDocument(curr)
   30     30   
            // SecurityGroups com.amazonaws.ec2#TargetNetwork$SecurityGroups
   31     31   
            "securityGroups" -> builder.securityGroups = deserializeValueStringListShape(curr)
          32  +
            // AvailabilityZones com.amazonaws.ec2#TargetNetwork$AvailabilityZones
          33  +
            "availabilityZoneSet" -> builder.availabilityZones = deserializeClientVpnAvailabilityZoneSetShape(curr)
          34  +
            // AvailabilityZoneIds com.amazonaws.ec2#TargetNetwork$AvailabilityZoneIds
          35  +
            "availabilityZoneIdSet" -> builder.availabilityZoneIds = deserializeClientVpnAvailabilityZoneIdSetShape(curr)
   32     36   
            else -> {}
   33     37   
        }
   34     38   
        curr.drop()
   35     39   
    }
   36     40   
    builder.correctErrors()
   37     41   
    return builder.build()
   38     42   
}

tmp-codegen-diff/services/kinesis/e2eTest/src/KinesisSubscribeToShardTest.kt

@@ -1,1 +105,106 @@
    1      1   
/*
    2      2   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    3      3   
 * SPDX-License-Identifier: Apache-2.0
    4      4   
 */
    5      5   
package aws.sdk.kotlin.services.kinesis
    6      6   
    7      7   
import aws.sdk.kotlin.services.kinesis.model.*
    8      8   
import aws.sdk.kotlin.services.kinesis.waiters.waitUntilStreamExists
    9      9   
import aws.sdk.kotlin.testing.withAllEngines
   10     10   
import aws.smithy.kotlin.runtime.retries.getOrThrow
          11  +
import aws.smithy.kotlin.runtime.testing.AfterAll
          12  +
import aws.smithy.kotlin.runtime.testing.BeforeAll
          13  +
import aws.smithy.kotlin.runtime.testing.TestInstance
          14  +
import aws.smithy.kotlin.runtime.testing.TestLifecycle
   11     15   
import kotlinx.coroutines.*
   12     16   
import kotlinx.coroutines.flow.first
   13         -
import org.junit.jupiter.api.AfterAll
   14         -
import org.junit.jupiter.api.BeforeAll
   15         -
import org.junit.jupiter.api.TestInstance
   16     17   
import java.util.*
   17     18   
import kotlin.test.Test
   18     19   
import kotlin.test.assertEquals
   19     20   
import kotlin.time.Duration.Companion.seconds
   20     21   
   21     22   
private val WAIT_TIMEOUT = 30.seconds
   22     23   
private val POLLING_RATE = 3.seconds
   23     24   
   24     25   
private val STREAM_NAME_PREFIX = "aws-sdk-kotlin-e2e-test-stream-"
   25     26   
private val STREAM_CONSUMER_NAME_PREFIX = "aws-sdk-kotlin-e2e-test-"
   26     27   
   27     28   
private val TEST_DATA = "Bees, bees, bees, bees!"
   28     29   
   29     30   
/**
   30     31   
 * Tests for Kinesis SubscribeToShard (an RPC-bound protocol)
   31     32   
 */
   32         -
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
          33  +
@TestInstance(TestLifecycle.PER_CLASS)
   33     34   
class KinesisSubscribeToShardTest {
   34     35   
    private val client = KinesisClient { region = "us-east-1" }
   35     36   
   36     37   
    private lateinit var dataStreamArn: String
   37     38   
    private lateinit var dataStreamConsumerArn: String
   38     39   
   39     40   
    /**
   40     41   
     * Create infrastructure required for the test, if it doesn't exist already.
   41     42   
     */
   42     43   
    @BeforeAll
   43     44   
    fun setup(): Unit = runBlocking {
   44     45   
        dataStreamArn = client.getOrCreateStream()
   45     46   
        dataStreamConsumerArn = client.getOrRegisterStreamConsumer()
   46     47   
    }
   47     48   
   48     49   
    /**
   49     50   
     * Delete infrastructure used for the test.
   50     51   
     */
   51     52   
    @AfterAll
   52     53   
    fun cleanUp(): Unit = runBlocking {
   53     54   
        client.deregisterStreamConsumer {
   54     55   
            streamArn = dataStreamArn
   55     56   
            consumerArn = dataStreamConsumerArn
   56     57   
        }
   57     58   
   58     59   
        client.deleteStream {
   59     60   
            streamArn = dataStreamArn
   60     61   
        }
   61     62   
    }
   62     63   
   63     64   
    /**
   64     65   
     * Select the single shard ID associated with the data stream, and subscribe to it.
   65     66   
     * Read one event and make sure the data matches what's expected.
   66     67   
     */
   67     68   
    @Test
   68     69   
    fun testSubscribeToShard(): Unit = runBlocking {
   69     70   
        val dataStreamShardId = client.listShards {
   70     71   
            streamArn = dataStreamArn
   71     72   
        }.shards?.single()!!.shardId
   72     73   
   73         -
        withAllEngines { engine ->
          74  +
        withAllEngines { context ->
   74     75   
            client.withConfig {
   75         -
                httpClient = engine
          76  +
                httpClient = context.engine
   76     77   
            }.use { clientWithTestEngine ->
   77     78   
                clientWithTestEngine.subscribeToShard(
   78     79   
                    SubscribeToShardRequest {
   79     80   
                        consumerArn = dataStreamConsumerArn
   80     81   
                        shardId = dataStreamShardId
   81     82   
                        startingPosition = StartingPosition {
   82     83   
                            type = ShardIteratorType.TrimHorizon
   83     84   
                        }
   84     85   
                    },
   85     86   
                ) {

tmp-codegen-diff/services/polly/build.gradle.kts

@@ -1,1 +60,60 @@
    1      1   
    2      2   
description = "The AWS SDK for Kotlin client for Polly"
    3      3   
project.ext.set("aws.sdk.id", "Polly")
    4      4   
    5      5   
kotlin {
    6      6   
    sourceSets {
    7      7   
        commonMain {
    8      8   
            dependencies {
    9         -
                implementation("aws.smithy.kotlin:aws-credentials:1.6.8-SNAPSHOT")
   10         -
                implementation("aws.smithy.kotlin:aws-event-stream:1.6.8-SNAPSHOT")
           9  +
                implementation("aws.smithy.kotlin:aws-credentials:1.6.13-SNAPSHOT")
          10  +
                implementation("aws.smithy.kotlin:aws-event-stream:1.6.13-SNAPSHOT")
   11     11   
                implementation(project(":aws-runtime:aws-http"))
   12         -
                implementation("aws.smithy.kotlin:aws-json-protocols:1.6.8-SNAPSHOT")
   13         -
                implementation("aws.smithy.kotlin:aws-protocol-core:1.6.8-SNAPSHOT")
   14         -
                implementation("aws.smithy.kotlin:aws-signing-common:1.6.8-SNAPSHOT")
   15         -
                implementation("aws.smithy.kotlin:aws-signing-default:1.6.8-SNAPSHOT")
   16         -
                implementation("aws.smithy.kotlin:http:1.6.8-SNAPSHOT")
   17         -
                implementation("aws.smithy.kotlin:http-auth:1.6.8-SNAPSHOT")
   18         -
                implementation("aws.smithy.kotlin:http-auth-aws:1.6.8-SNAPSHOT")
   19         -
                implementation("aws.smithy.kotlin:http-client-engine-default:1.6.8-SNAPSHOT")
   20         -
                implementation("aws.smithy.kotlin:identity-api:1.6.8-SNAPSHOT")
   21         -
                implementation("aws.smithy.kotlin:serde:1.6.8-SNAPSHOT")
   22         -
                implementation("aws.smithy.kotlin:serde-json:1.6.8-SNAPSHOT")
   23         -
                implementation("aws.smithy.kotlin:telemetry-defaults:1.6.8-SNAPSHOT")
          12  +
                implementation("aws.smithy.kotlin:aws-json-protocols:1.6.13-SNAPSHOT")
          13  +
                implementation("aws.smithy.kotlin:aws-protocol-core:1.6.13-SNAPSHOT")
          14  +
                implementation("aws.smithy.kotlin:aws-signing-common:1.6.13-SNAPSHOT")
          15  +
                implementation("aws.smithy.kotlin:aws-signing-default:1.6.13-SNAPSHOT")
          16  +
                implementation("aws.smithy.kotlin:http:1.6.13-SNAPSHOT")
          17  +
                implementation("aws.smithy.kotlin:http-auth:1.6.13-SNAPSHOT")
          18  +
                implementation("aws.smithy.kotlin:http-auth-aws:1.6.13-SNAPSHOT")
          19  +
                implementation("aws.smithy.kotlin:http-client-engine-default:1.6.13-SNAPSHOT")
          20  +
                implementation("aws.smithy.kotlin:identity-api:1.6.13-SNAPSHOT")
          21  +
                implementation("aws.smithy.kotlin:serde:1.6.13-SNAPSHOT")
          22  +
                implementation("aws.smithy.kotlin:serde-json:1.6.13-SNAPSHOT")
          23  +
                implementation("aws.smithy.kotlin:telemetry-defaults:1.6.13-SNAPSHOT")
   24     24   
                api(project(":aws-runtime:aws-config"))
   25     25   
                api(project(":aws-runtime:aws-core"))
   26     26   
                api(project(":aws-runtime:aws-endpoint"))
   27         -
                api("aws.smithy.kotlin:http-client:1.6.8-SNAPSHOT")
   28         -
                api("aws.smithy.kotlin:runtime-core:1.6.8-SNAPSHOT")
   29         -
                api("aws.smithy.kotlin:smithy-client:1.6.8-SNAPSHOT")
   30         -
                api("aws.smithy.kotlin:telemetry-api:1.6.8-SNAPSHOT")
          27  +
                api("aws.smithy.kotlin:http-client:1.6.13-SNAPSHOT")
          28  +
                api("aws.smithy.kotlin:runtime-core:1.6.13-SNAPSHOT")
          29  +
                api("aws.smithy.kotlin:smithy-client:1.6.13-SNAPSHOT")
          30  +
                api("aws.smithy.kotlin:telemetry-api:1.6.13-SNAPSHOT")
   31     31   
            }
   32     32   
        }
   33     33   
        commonTest {
   34     34   
            dependencies {
   35     35   
                implementation("org.jetbrains.kotlin:kotlin-test:2.3.0")
   36     36   
            }
   37     37   
        }
   38     38   
    }
   39     39   
   40     40   
    jvm {

tmp-codegen-diff/services/polly/build/tmp/jvmJar/MANIFEST.MF

@@ -1,0 +2,0 @@
    1         -
Manifest-Version: 1.0
    2         -

tmp-codegen-diff/services/polly/e2eTest/src/PollyPresignerTest.kt

@@ -1,1 +45,46 @@
    4      4   
 */
    5      5   
package aws.sdk.kotlin.services.polly
    6      6   
    7      7   
import aws.sdk.kotlin.services.polly.model.OutputFormat
    8      8   
import aws.sdk.kotlin.services.polly.model.SynthesizeSpeechRequest
    9      9   
import aws.sdk.kotlin.services.polly.model.VoiceId
   10     10   
import aws.sdk.kotlin.services.polly.presigners.presignSynthesizeSpeech
   11     11   
import aws.sdk.kotlin.testing.withAllEngines
   12     12   
import aws.smithy.kotlin.runtime.http.SdkHttpClient
   13     13   
import aws.smithy.kotlin.runtime.http.complete
          14  +
import aws.smithy.kotlin.runtime.testing.TestInstance
          15  +
import aws.smithy.kotlin.runtime.testing.TestLifecycle
   14     16   
import kotlinx.coroutines.runBlocking
   15         -
import org.junit.jupiter.api.TestInstance
   16     17   
import kotlin.test.Test
   17     18   
import kotlin.test.assertEquals
   18     19   
import kotlin.time.Duration.Companion.seconds
   19     20   
   20     21   
/**
   21     22   
 * Tests for presigner
   22     23   
 */
   23         -
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
          24  +
@TestInstance(TestLifecycle.PER_CLASS)
   24     25   
class PollyPresignerTest {
   25     26   
    @Test
   26     27   
    fun clientBasedPresign() = runBlocking {
   27     28   
        val unsignedRequest = SynthesizeSpeechRequest {
   28     29   
            voiceId = VoiceId.Salli
   29     30   
            outputFormat = OutputFormat.Pcm
   30     31   
            text = "hello world"
   31     32   
        }
   32     33   
   33     34   
        val client = PollyClient { region = "us-east-1" }
   34     35   
        val presignedRequest = client.presignSynthesizeSpeech(unsignedRequest, 10.seconds)
   35     36   
   36         -
        withAllEngines { engine ->
   37         -
            val httpClient = SdkHttpClient(engine)
          37  +
        withAllEngines { context ->
          38  +
            val httpClient = SdkHttpClient(context.engine)
   38     39   
   39     40   
            val call = httpClient.call(presignedRequest)
   40     41   
            call.complete()
   41     42   
   42         -
            assertEquals(200, call.response.status.value, "presigned polly request failed for engine: $engine")
          43  +
            assertEquals(200, call.response.status.value, "presigned Polly request failed for ${context.name} engine")
   43     44   
        }
   44     45   
    }
   45     46   
}

tmp-codegen-diff/services/polly/generated-src/main/kotlin/aws/sdk/kotlin/services/polly/PollyClient.kt

@@ -46,46 +106,106 @@
   66     66   
import aws.smithy.kotlin.runtime.telemetry.TelemetryConfig
   67     67   
import aws.smithy.kotlin.runtime.telemetry.TelemetryProvider
   68     68   
import aws.smithy.kotlin.runtime.util.LazyAsyncValue
   69     69   
import kotlin.collections.List
   70     70   
import kotlin.jvm.JvmStatic
   71     71   
import kotlin.time.Duration
   72     72   
import kotlinx.coroutines.runBlocking
   73     73   
   74     74   
   75     75   
public const val ServiceId: String = "Polly"
   76         -
public const val SdkVersion: String = "1.6.48-SNAPSHOT"
          76  +
public const val SdkVersion: String = "1.6.61-SNAPSHOT"
   77     77   
public const val ServiceApiVersion: String = "2016-06-10"
   78     78   
   79     79   
/**
   80     80   
 * Amazon Polly is a web service that makes it easy to synthesize speech from text.
   81     81   
 *
   82     82   
 * The Amazon Polly service provides API operations for synthesizing high-quality speech from plain text and Speech Synthesis Markup Language (SSML), along with managing pronunciations lexicons that enable you to get the best results for your application domain.
   83     83   
 */
   84     84   
public interface PollyClient : SdkClient {
   85     85   
    /**
   86     86   
     * PollyClient's configuration

tmp-codegen-diff/services/polly/generated-src/main/kotlin/aws/sdk/kotlin/services/polly/model/Engine.kt

@@ -21,21 +58,58 @@
   41     41   
            "neural" -> Neural
   42     42   
            "standard" -> Standard
   43     43   
            else -> SdkUnknown(value)
   44     44   
        }
   45     45   
   46     46   
        /**
   47     47   
         * Get a list of all possible variants
   48     48   
         */
   49     49   
        public fun values(): kotlin.collections.List<aws.sdk.kotlin.services.polly.model.Engine> = values
   50     50   
   51         -
        private val values: kotlin.collections.List<aws.sdk.kotlin.services.polly.model.Engine> = listOf(
          51  +
        private val values: kotlin.collections.List<aws.sdk.kotlin.services.polly.model.Engine> by lazy { listOf(
   52     52   
            Generative,
   53     53   
            LongForm,
   54     54   
            Neural,
   55     55   
            Standard,
   56         -
        )
          56  +
        ) }
   57     57   
    }
   58     58   
}