Ec2AkkaClient

Abstract Value Members

abstract val underlying: Ec2AsyncClient

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def acceptReservedInstancesExchangeQuoteFlow(parallelism: Int = DefaultParallelism): Flow[AcceptReservedInstancesExchangeQuoteRequest, AcceptReservedInstancesExchangeQuoteResponse, NotUsed]
def acceptReservedInstancesExchangeQuoteSource(acceptReservedInstancesExchangeQuoteRequest: AcceptReservedInstancesExchangeQuoteRequest, parallelism: Int = DefaultParallelism): Source[AcceptReservedInstancesExchangeQuoteResponse, NotUsed]
def acceptTransitGatewayPeeringAttachmentFlow(parallelism: Int = DefaultParallelism): Flow[AcceptTransitGatewayPeeringAttachmentRequest, AcceptTransitGatewayPeeringAttachmentResponse, NotUsed]
def acceptTransitGatewayPeeringAttachmentSource(acceptTransitGatewayPeeringAttachmentRequest: AcceptTransitGatewayPeeringAttachmentRequest, parallelism: Int = DefaultParallelism): Source[AcceptTransitGatewayPeeringAttachmentResponse, NotUsed]
def acceptTransitGatewayVpcAttachmentFlow(parallelism: Int = DefaultParallelism): Flow[AcceptTransitGatewayVpcAttachmentRequest, AcceptTransitGatewayVpcAttachmentResponse, NotUsed]
def acceptTransitGatewayVpcAttachmentSource(acceptTransitGatewayVpcAttachmentRequest: AcceptTransitGatewayVpcAttachmentRequest, parallelism: Int = DefaultParallelism): Source[AcceptTransitGatewayVpcAttachmentResponse, NotUsed]
def acceptVpcEndpointConnectionsFlow(parallelism: Int = DefaultParallelism): Flow[AcceptVpcEndpointConnectionsRequest, AcceptVpcEndpointConnectionsResponse, NotUsed]
def acceptVpcEndpointConnectionsSource(acceptVpcEndpointConnectionsRequest: AcceptVpcEndpointConnectionsRequest, parallelism: Int = DefaultParallelism): Source[AcceptVpcEndpointConnectionsResponse, NotUsed]
def acceptVpcPeeringConnectionFlow(parallelism: Int = DefaultParallelism): Flow[AcceptVpcPeeringConnectionRequest, AcceptVpcPeeringConnectionResponse, NotUsed]
def acceptVpcPeeringConnectionSource(acceptVpcPeeringConnectionRequest: AcceptVpcPeeringConnectionRequest, parallelism: Int = DefaultParallelism): Source[AcceptVpcPeeringConnectionResponse, NotUsed]
def advertiseByoipCidrFlow(parallelism: Int = DefaultParallelism): Flow[AdvertiseByoipCidrRequest, AdvertiseByoipCidrResponse, NotUsed]
def advertiseByoipCidrSource(advertiseByoipCidrRequest: AdvertiseByoipCidrRequest, parallelism: Int = DefaultParallelism): Source[AdvertiseByoipCidrResponse, NotUsed]
def allocateAddressFlow(parallelism: Int = DefaultParallelism): Flow[AllocateAddressRequest, AllocateAddressResponse, NotUsed]
def allocateAddressSource(): Source[AllocateAddressResponse, NotUsed]
def allocateAddressSource(allocateAddressRequest: AllocateAddressRequest, parallelism: Int = DefaultParallelism): Source[AllocateAddressResponse, NotUsed]
def allocateHostsFlow(parallelism: Int = DefaultParallelism): Flow[AllocateHostsRequest, AllocateHostsResponse, NotUsed]
def allocateHostsSource(allocateHostsRequest: AllocateHostsRequest, parallelism: Int = DefaultParallelism): Source[AllocateHostsResponse, NotUsed]
def applySecurityGroupsToClientVpnTargetNetworkFlow(parallelism: Int = DefaultParallelism): Flow[ApplySecurityGroupsToClientVpnTargetNetworkRequest, ApplySecurityGroupsToClientVpnTargetNetworkResponse, NotUsed]
def applySecurityGroupsToClientVpnTargetNetworkSource(applySecurityGroupsToClientVpnTargetNetworkRequest: ApplySecurityGroupsToClientVpnTargetNetworkRequest, parallelism: Int = DefaultParallelism): Source[ApplySecurityGroupsToClientVpnTargetNetworkResponse, NotUsed]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def assignIpv6AddressesFlow(parallelism: Int = DefaultParallelism): Flow[AssignIpv6AddressesRequest, AssignIpv6AddressesResponse, NotUsed]
def assignIpv6AddressesSource(assignIpv6AddressesRequest: AssignIpv6AddressesRequest, parallelism: Int = DefaultParallelism): Source[AssignIpv6AddressesResponse, NotUsed]
def assignPrivateIpAddressesFlow(parallelism: Int = DefaultParallelism): Flow[AssignPrivateIpAddressesRequest, AssignPrivateIpAddressesResponse, NotUsed]
def assignPrivateIpAddressesSource(assignPrivateIpAddressesRequest: AssignPrivateIpAddressesRequest, parallelism: Int = DefaultParallelism): Source[AssignPrivateIpAddressesResponse, NotUsed]
def associateAddressFlow(parallelism: Int = DefaultParallelism): Flow[AssociateAddressRequest, AssociateAddressResponse, NotUsed]
def associateAddressSource(): Source[AssociateAddressResponse, NotUsed]
def associateAddressSource(associateAddressRequest: AssociateAddressRequest, parallelism: Int = DefaultParallelism): Source[AssociateAddressResponse, NotUsed]
def associateClientVpnTargetNetworkFlow(parallelism: Int = DefaultParallelism): Flow[AssociateClientVpnTargetNetworkRequest, AssociateClientVpnTargetNetworkResponse, NotUsed]
def associateClientVpnTargetNetworkSource(associateClientVpnTargetNetworkRequest: AssociateClientVpnTargetNetworkRequest, parallelism: Int = DefaultParallelism): Source[AssociateClientVpnTargetNetworkResponse, NotUsed]
def associateDhcpOptionsFlow(parallelism: Int = DefaultParallelism): Flow[AssociateDhcpOptionsRequest, AssociateDhcpOptionsResponse, NotUsed]
def associateDhcpOptionsSource(associateDhcpOptionsRequest: AssociateDhcpOptionsRequest, parallelism: Int = DefaultParallelism): Source[AssociateDhcpOptionsResponse, NotUsed]
def associateIamInstanceProfileFlow(parallelism: Int = DefaultParallelism): Flow[AssociateIamInstanceProfileRequest, AssociateIamInstanceProfileResponse, NotUsed]
def associateIamInstanceProfileSource(associateIamInstanceProfileRequest: AssociateIamInstanceProfileRequest, parallelism: Int = DefaultParallelism): Source[AssociateIamInstanceProfileResponse, NotUsed]
def associateRouteTableFlow(parallelism: Int = DefaultParallelism): Flow[AssociateRouteTableRequest, AssociateRouteTableResponse, NotUsed]
def associateRouteTableSource(associateRouteTableRequest: AssociateRouteTableRequest, parallelism: Int = DefaultParallelism): Source[AssociateRouteTableResponse, NotUsed]
def associateSubnetCidrBlockFlow(parallelism: Int = DefaultParallelism): Flow[AssociateSubnetCidrBlockRequest, AssociateSubnetCidrBlockResponse, NotUsed]
def associateSubnetCidrBlockSource(associateSubnetCidrBlockRequest: AssociateSubnetCidrBlockRequest, parallelism: Int = DefaultParallelism): Source[AssociateSubnetCidrBlockResponse, NotUsed]
def associateTransitGatewayMulticastDomainFlow(parallelism: Int = DefaultParallelism): Flow[AssociateTransitGatewayMulticastDomainRequest, AssociateTransitGatewayMulticastDomainResponse, NotUsed]
def associateTransitGatewayMulticastDomainSource(associateTransitGatewayMulticastDomainRequest: AssociateTransitGatewayMulticastDomainRequest, parallelism: Int = DefaultParallelism): Source[AssociateTransitGatewayMulticastDomainResponse, NotUsed]
def associateTransitGatewayRouteTableFlow(parallelism: Int = DefaultParallelism): Flow[AssociateTransitGatewayRouteTableRequest, AssociateTransitGatewayRouteTableResponse, NotUsed]
def associateTransitGatewayRouteTableSource(associateTransitGatewayRouteTableRequest: AssociateTransitGatewayRouteTableRequest, parallelism: Int = DefaultParallelism): Source[AssociateTransitGatewayRouteTableResponse, NotUsed]
def associateVpcCidrBlockFlow(parallelism: Int = DefaultParallelism): Flow[AssociateVpcCidrBlockRequest, AssociateVpcCidrBlockResponse, NotUsed]
def associateVpcCidrBlockSource(associateVpcCidrBlockRequest: AssociateVpcCidrBlockRequest, parallelism: Int = DefaultParallelism): Source[AssociateVpcCidrBlockResponse, NotUsed]
def attachClassicLinkVpcFlow(parallelism: Int = DefaultParallelism): Flow[AttachClassicLinkVpcRequest, AttachClassicLinkVpcResponse, NotUsed]
def attachClassicLinkVpcSource(attachClassicLinkVpcRequest: AttachClassicLinkVpcRequest, parallelism: Int = DefaultParallelism): Source[AttachClassicLinkVpcResponse, NotUsed]
def attachInternetGatewayFlow(parallelism: Int = DefaultParallelism): Flow[AttachInternetGatewayRequest, AttachInternetGatewayResponse, NotUsed]
def attachInternetGatewaySource(attachInternetGatewayRequest: AttachInternetGatewayRequest, parallelism: Int = DefaultParallelism): Source[AttachInternetGatewayResponse, NotUsed]
def attachNetworkInterfaceFlow(parallelism: Int = DefaultParallelism): Flow[AttachNetworkInterfaceRequest, AttachNetworkInterfaceResponse, NotUsed]
def attachNetworkInterfaceSource(attachNetworkInterfaceRequest: AttachNetworkInterfaceRequest, parallelism: Int = DefaultParallelism): Source[AttachNetworkInterfaceResponse, NotUsed]
def attachVolumeFlow(parallelism: Int = DefaultParallelism): Flow[AttachVolumeRequest, AttachVolumeResponse, NotUsed]
def attachVolumeSource(attachVolumeRequest: AttachVolumeRequest, parallelism: Int = DefaultParallelism): Source[AttachVolumeResponse, NotUsed]
def attachVpnGatewayFlow(parallelism: Int = DefaultParallelism): Flow[AttachVpnGatewayRequest, AttachVpnGatewayResponse, NotUsed]
def attachVpnGatewaySource(attachVpnGatewayRequest: AttachVpnGatewayRequest, parallelism: Int = DefaultParallelism): Source[AttachVpnGatewayResponse, NotUsed]
def authorizeClientVpnIngressFlow(parallelism: Int = DefaultParallelism): Flow[AuthorizeClientVpnIngressRequest, AuthorizeClientVpnIngressResponse, NotUsed]
def authorizeClientVpnIngressSource(authorizeClientVpnIngressRequest: AuthorizeClientVpnIngressRequest, parallelism: Int = DefaultParallelism): Source[AuthorizeClientVpnIngressResponse, NotUsed]
def authorizeSecurityGroupEgressFlow(parallelism: Int = DefaultParallelism): Flow[AuthorizeSecurityGroupEgressRequest, AuthorizeSecurityGroupEgressResponse, NotUsed]
def authorizeSecurityGroupEgressSource(authorizeSecurityGroupEgressRequest: AuthorizeSecurityGroupEgressRequest, parallelism: Int = DefaultParallelism): Source[AuthorizeSecurityGroupEgressResponse, NotUsed]
def authorizeSecurityGroupIngressFlow(parallelism: Int = DefaultParallelism): Flow[AuthorizeSecurityGroupIngressRequest, AuthorizeSecurityGroupIngressResponse, NotUsed]
def authorizeSecurityGroupIngressSource(authorizeSecurityGroupIngressRequest: AuthorizeSecurityGroupIngressRequest, parallelism: Int = DefaultParallelism): Source[AuthorizeSecurityGroupIngressResponse, NotUsed]
def bundleInstanceFlow(parallelism: Int = DefaultParallelism): Flow[BundleInstanceRequest, BundleInstanceResponse, NotUsed]
def bundleInstanceSource(bundleInstanceRequest: BundleInstanceRequest, parallelism: Int = DefaultParallelism): Source[BundleInstanceResponse, NotUsed]
def cancelBundleTaskFlow(parallelism: Int = DefaultParallelism): Flow[CancelBundleTaskRequest, CancelBundleTaskResponse, NotUsed]
def cancelBundleTaskSource(cancelBundleTaskRequest: CancelBundleTaskRequest, parallelism: Int = DefaultParallelism): Source[CancelBundleTaskResponse, NotUsed]
def cancelCapacityReservationFlow(parallelism: Int = DefaultParallelism): Flow[CancelCapacityReservationRequest, CancelCapacityReservationResponse, NotUsed]
def cancelCapacityReservationSource(cancelCapacityReservationRequest: CancelCapacityReservationRequest, parallelism: Int = DefaultParallelism): Source[CancelCapacityReservationResponse, NotUsed]
def cancelConversionTaskFlow(parallelism: Int = DefaultParallelism): Flow[CancelConversionTaskRequest, CancelConversionTaskResponse, NotUsed]
def cancelConversionTaskSource(cancelConversionTaskRequest: CancelConversionTaskRequest, parallelism: Int = DefaultParallelism): Source[CancelConversionTaskResponse, NotUsed]
def cancelExportTaskFlow(parallelism: Int = DefaultParallelism): Flow[CancelExportTaskRequest, CancelExportTaskResponse, NotUsed]
def cancelExportTaskSource(cancelExportTaskRequest: CancelExportTaskRequest, parallelism: Int = DefaultParallelism): Source[CancelExportTaskResponse, NotUsed]
def cancelImportTaskFlow(parallelism: Int = DefaultParallelism): Flow[CancelImportTaskRequest, CancelImportTaskResponse, NotUsed]
def cancelImportTaskSource(cancelImportTaskRequest: CancelImportTaskRequest, parallelism: Int = DefaultParallelism): Source[CancelImportTaskResponse, NotUsed]
def cancelReservedInstancesListingFlow(parallelism: Int = DefaultParallelism): Flow[CancelReservedInstancesListingRequest, CancelReservedInstancesListingResponse, NotUsed]
def cancelReservedInstancesListingSource(cancelReservedInstancesListingRequest: CancelReservedInstancesListingRequest, parallelism: Int = DefaultParallelism): Source[CancelReservedInstancesListingResponse, NotUsed]
def cancelSpotFleetRequestsFlow(parallelism: Int = DefaultParallelism): Flow[CancelSpotFleetRequestsRequest, CancelSpotFleetRequestsResponse, NotUsed]
def cancelSpotFleetRequestsSource(cancelSpotFleetRequestsRequest: CancelSpotFleetRequestsRequest, parallelism: Int = DefaultParallelism): Source[CancelSpotFleetRequestsResponse, NotUsed]
def cancelSpotInstanceRequestsFlow(parallelism: Int = DefaultParallelism): Flow[CancelSpotInstanceRequestsRequest, CancelSpotInstanceRequestsResponse, NotUsed]
def cancelSpotInstanceRequestsSource(cancelSpotInstanceRequestsRequest: CancelSpotInstanceRequestsRequest, parallelism: Int = DefaultParallelism): Source[CancelSpotInstanceRequestsResponse, NotUsed]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @throws( ... )
def confirmProductInstanceFlow(parallelism: Int = DefaultParallelism): Flow[ConfirmProductInstanceRequest, ConfirmProductInstanceResponse, NotUsed]
def confirmProductInstanceSource(confirmProductInstanceRequest: ConfirmProductInstanceRequest, parallelism: Int = DefaultParallelism): Source[ConfirmProductInstanceResponse, NotUsed]
def copyFpgaImageFlow(parallelism: Int = DefaultParallelism): Flow[CopyFpgaImageRequest, CopyFpgaImageResponse, NotUsed]
def copyFpgaImageSource(copyFpgaImageRequest: CopyFpgaImageRequest, parallelism: Int = DefaultParallelism): Source[CopyFpgaImageResponse, NotUsed]
def copyImageFlow(parallelism: Int = DefaultParallelism): Flow[CopyImageRequest, CopyImageResponse, NotUsed]
def copyImageSource(copyImageRequest: CopyImageRequest, parallelism: Int = DefaultParallelism): Source[CopyImageResponse, NotUsed]
def copySnapshotFlow(parallelism: Int = DefaultParallelism): Flow[CopySnapshotRequest, CopySnapshotResponse, NotUsed]
def copySnapshotSource(copySnapshotRequest: CopySnapshotRequest, parallelism: Int = DefaultParallelism): Source[CopySnapshotResponse, NotUsed]
def createCapacityReservationFlow(parallelism: Int = DefaultParallelism): Flow[CreateCapacityReservationRequest, CreateCapacityReservationResponse, NotUsed]
def createCapacityReservationSource(createCapacityReservationRequest: CreateCapacityReservationRequest, parallelism: Int = DefaultParallelism): Source[CreateCapacityReservationResponse, NotUsed]
def createClientVpnEndpointFlow(parallelism: Int = DefaultParallelism): Flow[CreateClientVpnEndpointRequest, CreateClientVpnEndpointResponse, NotUsed]
def createClientVpnEndpointSource(createClientVpnEndpointRequest: CreateClientVpnEndpointRequest, parallelism: Int = DefaultParallelism): Source[CreateClientVpnEndpointResponse, NotUsed]
def createClientVpnRouteFlow(parallelism: Int = DefaultParallelism): Flow[CreateClientVpnRouteRequest, CreateClientVpnRouteResponse, NotUsed]
def createClientVpnRouteSource(createClientVpnRouteRequest: CreateClientVpnRouteRequest, parallelism: Int = DefaultParallelism): Source[CreateClientVpnRouteResponse, NotUsed]
def createCustomerGatewayFlow(parallelism: Int = DefaultParallelism): Flow[CreateCustomerGatewayRequest, CreateCustomerGatewayResponse, NotUsed]
def createCustomerGatewaySource(createCustomerGatewayRequest: CreateCustomerGatewayRequest, parallelism: Int = DefaultParallelism): Source[CreateCustomerGatewayResponse, NotUsed]
def createDefaultSubnetFlow(parallelism: Int = DefaultParallelism): Flow[CreateDefaultSubnetRequest, CreateDefaultSubnetResponse, NotUsed]
def createDefaultSubnetSource(createDefaultSubnetRequest: CreateDefaultSubnetRequest, parallelism: Int = DefaultParallelism): Source[CreateDefaultSubnetResponse, NotUsed]
def createDefaultVpcFlow(parallelism: Int = DefaultParallelism): Flow[CreateDefaultVpcRequest, CreateDefaultVpcResponse, NotUsed]
def createDefaultVpcSource(): Source[CreateDefaultVpcResponse, NotUsed]
def createDefaultVpcSource(createDefaultVpcRequest: CreateDefaultVpcRequest, parallelism: Int = DefaultParallelism): Source[CreateDefaultVpcResponse, NotUsed]
def createDhcpOptionsFlow(parallelism: Int = DefaultParallelism): Flow[CreateDhcpOptionsRequest, CreateDhcpOptionsResponse, NotUsed]
def createDhcpOptionsSource(createDhcpOptionsRequest: CreateDhcpOptionsRequest, parallelism: Int = DefaultParallelism): Source[CreateDhcpOptionsResponse, NotUsed]
def createEgressOnlyInternetGatewayFlow(parallelism: Int = DefaultParallelism): Flow[CreateEgressOnlyInternetGatewayRequest, CreateEgressOnlyInternetGatewayResponse, NotUsed]
def createEgressOnlyInternetGatewaySource(createEgressOnlyInternetGatewayRequest: CreateEgressOnlyInternetGatewayRequest, parallelism: Int = DefaultParallelism): Source[CreateEgressOnlyInternetGatewayResponse, NotUsed]
def createFleetFlow(parallelism: Int = DefaultParallelism): Flow[CreateFleetRequest, CreateFleetResponse, NotUsed]
def createFleetSource(createFleetRequest: CreateFleetRequest, parallelism: Int = DefaultParallelism): Source[CreateFleetResponse, NotUsed]
def createFlowLogsFlow(parallelism: Int = DefaultParallelism): Flow[CreateFlowLogsRequest, CreateFlowLogsResponse, NotUsed]
def createFlowLogsSource(createFlowLogsRequest: CreateFlowLogsRequest, parallelism: Int = DefaultParallelism): Source[CreateFlowLogsResponse, NotUsed]
def createFpgaImageFlow(parallelism: Int = DefaultParallelism): Flow[CreateFpgaImageRequest, CreateFpgaImageResponse, NotUsed]
def createFpgaImageSource(createFpgaImageRequest: CreateFpgaImageRequest, parallelism: Int = DefaultParallelism): Source[CreateFpgaImageResponse, NotUsed]
def createImageFlow(parallelism: Int = DefaultParallelism): Flow[CreateImageRequest, CreateImageResponse, NotUsed]
def createImageSource(createImageRequest: CreateImageRequest, parallelism: Int = DefaultParallelism): Source[CreateImageResponse, NotUsed]
def createInstanceExportTaskFlow(parallelism: Int = DefaultParallelism): Flow[CreateInstanceExportTaskRequest, CreateInstanceExportTaskResponse, NotUsed]
def createInstanceExportTaskSource(createInstanceExportTaskRequest: CreateInstanceExportTaskRequest, parallelism: Int = DefaultParallelism): Source[CreateInstanceExportTaskResponse, NotUsed]
def createInternetGatewayFlow(parallelism: Int = DefaultParallelism): Flow[CreateInternetGatewayRequest, CreateInternetGatewayResponse, NotUsed]
def createInternetGatewaySource(): Source[CreateInternetGatewayResponse, NotUsed]
def createInternetGatewaySource(createInternetGatewayRequest: CreateInternetGatewayRequest, parallelism: Int = DefaultParallelism): Source[CreateInternetGatewayResponse, NotUsed]
def createKeyPairFlow(parallelism: Int = DefaultParallelism): Flow[CreateKeyPairRequest, CreateKeyPairResponse, NotUsed]
def createKeyPairSource(createKeyPairRequest: CreateKeyPairRequest, parallelism: Int = DefaultParallelism): Source[CreateKeyPairResponse, NotUsed]
def createLaunchTemplateFlow(parallelism: Int = DefaultParallelism): Flow[CreateLaunchTemplateRequest, CreateLaunchTemplateResponse, NotUsed]
def createLaunchTemplateSource(createLaunchTemplateRequest: CreateLaunchTemplateRequest, parallelism: Int = DefaultParallelism): Source[CreateLaunchTemplateResponse, NotUsed]
def createLaunchTemplateVersionFlow(parallelism: Int = DefaultParallelism): Flow[CreateLaunchTemplateVersionRequest, CreateLaunchTemplateVersionResponse, NotUsed]
def createLaunchTemplateVersionSource(createLaunchTemplateVersionRequest: CreateLaunchTemplateVersionRequest, parallelism: Int = DefaultParallelism): Source[CreateLaunchTemplateVersionResponse, NotUsed]
def createLocalGatewayRouteFlow(parallelism: Int = DefaultParallelism): Flow[CreateLocalGatewayRouteRequest, CreateLocalGatewayRouteResponse, NotUsed]
def createLocalGatewayRouteSource(createLocalGatewayRouteRequest: CreateLocalGatewayRouteRequest, parallelism: Int = DefaultParallelism): Source[CreateLocalGatewayRouteResponse, NotUsed]
def createLocalGatewayRouteTableVpcAssociationFlow(parallelism: Int = DefaultParallelism): Flow[CreateLocalGatewayRouteTableVpcAssociationRequest, CreateLocalGatewayRouteTableVpcAssociationResponse, NotUsed]
def createLocalGatewayRouteTableVpcAssociationSource(createLocalGatewayRouteTableVpcAssociationRequest: CreateLocalGatewayRouteTableVpcAssociationRequest, parallelism: Int = DefaultParallelism): Source[CreateLocalGatewayRouteTableVpcAssociationResponse, NotUsed]
def createNatGatewayFlow(parallelism: Int = DefaultParallelism): Flow[CreateNatGatewayRequest, CreateNatGatewayResponse, NotUsed]
def createNatGatewaySource(createNatGatewayRequest: CreateNatGatewayRequest, parallelism: Int = DefaultParallelism): Source[CreateNatGatewayResponse, NotUsed]
def createNetworkAclEntryFlow(parallelism: Int = DefaultParallelism): Flow[CreateNetworkAclEntryRequest, CreateNetworkAclEntryResponse, NotUsed]
def createNetworkAclEntrySource(createNetworkAclEntryRequest: CreateNetworkAclEntryRequest, parallelism: Int = DefaultParallelism): Source[CreateNetworkAclEntryResponse, NotUsed]
def createNetworkAclFlow(parallelism: Int = DefaultParallelism): Flow[CreateNetworkAclRequest, CreateNetworkAclResponse, NotUsed]
def createNetworkAclSource(createNetworkAclRequest: CreateNetworkAclRequest, parallelism: Int = DefaultParallelism): Source[CreateNetworkAclResponse, NotUsed]
def createNetworkInterfaceFlow(parallelism: Int = DefaultParallelism): Flow[CreateNetworkInterfaceRequest, CreateNetworkInterfaceResponse, NotUsed]
def createNetworkInterfacePermissionFlow(parallelism: Int = DefaultParallelism): Flow[CreateNetworkInterfacePermissionRequest, CreateNetworkInterfacePermissionResponse, NotUsed]
def createNetworkInterfacePermissionSource(createNetworkInterfacePermissionRequest: CreateNetworkInterfacePermissionRequest, parallelism: Int = DefaultParallelism): Source[CreateNetworkInterfacePermissionResponse, NotUsed]
def createNetworkInterfaceSource(createNetworkInterfaceRequest: CreateNetworkInterfaceRequest, parallelism: Int = DefaultParallelism): Source[CreateNetworkInterfaceResponse, NotUsed]
def createPlacementGroupFlow(parallelism: Int = DefaultParallelism): Flow[CreatePlacementGroupRequest, CreatePlacementGroupResponse, NotUsed]
def createPlacementGroupSource(createPlacementGroupRequest: CreatePlacementGroupRequest, parallelism: Int = DefaultParallelism): Source[CreatePlacementGroupResponse, NotUsed]
def createReservedInstancesListingFlow(parallelism: Int = DefaultParallelism): Flow[CreateReservedInstancesListingRequest, CreateReservedInstancesListingResponse, NotUsed]
def createReservedInstancesListingSource(createReservedInstancesListingRequest: CreateReservedInstancesListingRequest, parallelism: Int = DefaultParallelism): Source[CreateReservedInstancesListingResponse, NotUsed]
def createRouteFlow(parallelism: Int = DefaultParallelism): Flow[CreateRouteRequest, CreateRouteResponse, NotUsed]
def createRouteSource(createRouteRequest: CreateRouteRequest, parallelism: Int = DefaultParallelism): Source[CreateRouteResponse, NotUsed]
def createRouteTableFlow(parallelism: Int = DefaultParallelism): Flow[CreateRouteTableRequest, CreateRouteTableResponse, NotUsed]
def createRouteTableSource(createRouteTableRequest: CreateRouteTableRequest, parallelism: Int = DefaultParallelism): Source[CreateRouteTableResponse, NotUsed]
def createSecurityGroupFlow(parallelism: Int = DefaultParallelism): Flow[CreateSecurityGroupRequest, CreateSecurityGroupResponse, NotUsed]
def createSecurityGroupSource(createSecurityGroupRequest: CreateSecurityGroupRequest, parallelism: Int = DefaultParallelism): Source[CreateSecurityGroupResponse, NotUsed]
def createSnapshotFlow(parallelism: Int = DefaultParallelism): Flow[CreateSnapshotRequest, CreateSnapshotResponse, NotUsed]
def createSnapshotSource(createSnapshotRequest: CreateSnapshotRequest, parallelism: Int = DefaultParallelism): Source[CreateSnapshotResponse, NotUsed]
def createSnapshotsFlow(parallelism: Int = DefaultParallelism): Flow[CreateSnapshotsRequest, CreateSnapshotsResponse, NotUsed]
def createSnapshotsSource(createSnapshotsRequest: CreateSnapshotsRequest, parallelism: Int = DefaultParallelism): Source[CreateSnapshotsResponse, NotUsed]
def createSpotDatafeedSubscriptionFlow(parallelism: Int = DefaultParallelism): Flow[CreateSpotDatafeedSubscriptionRequest, CreateSpotDatafeedSubscriptionResponse, NotUsed]
def createSpotDatafeedSubscriptionSource(createSpotDatafeedSubscriptionRequest: CreateSpotDatafeedSubscriptionRequest, parallelism: Int = DefaultParallelism): Source[CreateSpotDatafeedSubscriptionResponse, NotUsed]
def createSubnetFlow(parallelism: Int = DefaultParallelism): Flow[CreateSubnetRequest, CreateSubnetResponse, NotUsed]
def createSubnetSource(createSubnetRequest: CreateSubnetRequest, parallelism: Int = DefaultParallelism): Source[CreateSubnetResponse, NotUsed]
def createTagsFlow(parallelism: Int = DefaultParallelism): Flow[CreateTagsRequest, CreateTagsResponse, NotUsed]
def createTagsSource(createTagsRequest: CreateTagsRequest, parallelism: Int = DefaultParallelism): Source[CreateTagsResponse, NotUsed]
def createTrafficMirrorFilterFlow(parallelism: Int = DefaultParallelism): Flow[CreateTrafficMirrorFilterRequest, CreateTrafficMirrorFilterResponse, NotUsed]
def createTrafficMirrorFilterRuleFlow(parallelism: Int = DefaultParallelism): Flow[CreateTrafficMirrorFilterRuleRequest, CreateTrafficMirrorFilterRuleResponse, NotUsed]
def createTrafficMirrorFilterRuleSource(createTrafficMirrorFilterRuleRequest: CreateTrafficMirrorFilterRuleRequest, parallelism: Int = DefaultParallelism): Source[CreateTrafficMirrorFilterRuleResponse, NotUsed]
def createTrafficMirrorFilterSource(createTrafficMirrorFilterRequest: CreateTrafficMirrorFilterRequest, parallelism: Int = DefaultParallelism): Source[CreateTrafficMirrorFilterResponse, NotUsed]
def createTrafficMirrorSessionFlow(parallelism: Int = DefaultParallelism): Flow[CreateTrafficMirrorSessionRequest, CreateTrafficMirrorSessionResponse, NotUsed]
def createTrafficMirrorSessionSource(createTrafficMirrorSessionRequest: CreateTrafficMirrorSessionRequest, parallelism: Int = DefaultParallelism): Source[CreateTrafficMirrorSessionResponse, NotUsed]
def createTrafficMirrorTargetFlow(parallelism: Int = DefaultParallelism): Flow[CreateTrafficMirrorTargetRequest, CreateTrafficMirrorTargetResponse, NotUsed]
def createTrafficMirrorTargetSource(createTrafficMirrorTargetRequest: CreateTrafficMirrorTargetRequest, parallelism: Int = DefaultParallelism): Source[CreateTrafficMirrorTargetResponse, NotUsed]
def createTransitGatewayFlow(parallelism: Int = DefaultParallelism): Flow[CreateTransitGatewayRequest, CreateTransitGatewayResponse, NotUsed]
def createTransitGatewayMulticastDomainFlow(parallelism: Int = DefaultParallelism): Flow[CreateTransitGatewayMulticastDomainRequest, CreateTransitGatewayMulticastDomainResponse, NotUsed]
def createTransitGatewayMulticastDomainSource(createTransitGatewayMulticastDomainRequest: CreateTransitGatewayMulticastDomainRequest, parallelism: Int = DefaultParallelism): Source[CreateTransitGatewayMulticastDomainResponse, NotUsed]
def createTransitGatewayPeeringAttachmentFlow(parallelism: Int = DefaultParallelism): Flow[CreateTransitGatewayPeeringAttachmentRequest, CreateTransitGatewayPeeringAttachmentResponse, NotUsed]
def createTransitGatewayPeeringAttachmentSource(createTransitGatewayPeeringAttachmentRequest: CreateTransitGatewayPeeringAttachmentRequest, parallelism: Int = DefaultParallelism): Source[CreateTransitGatewayPeeringAttachmentResponse, NotUsed]
def createTransitGatewayRouteFlow(parallelism: Int = DefaultParallelism): Flow[CreateTransitGatewayRouteRequest, CreateTransitGatewayRouteResponse, NotUsed]
def createTransitGatewayRouteSource(createTransitGatewayRouteRequest: CreateTransitGatewayRouteRequest, parallelism: Int = DefaultParallelism): Source[CreateTransitGatewayRouteResponse, NotUsed]
def createTransitGatewayRouteTableFlow(parallelism: Int = DefaultParallelism): Flow[CreateTransitGatewayRouteTableRequest, CreateTransitGatewayRouteTableResponse, NotUsed]
def createTransitGatewayRouteTableSource(createTransitGatewayRouteTableRequest: CreateTransitGatewayRouteTableRequest, parallelism: Int = DefaultParallelism): Source[CreateTransitGatewayRouteTableResponse, NotUsed]
def createTransitGatewaySource(): Source[CreateTransitGatewayResponse, NotUsed]
def createTransitGatewaySource(createTransitGatewayRequest: CreateTransitGatewayRequest, parallelism: Int = DefaultParallelism): Source[CreateTransitGatewayResponse, NotUsed]
def createTransitGatewayVpcAttachmentFlow(parallelism: Int = DefaultParallelism): Flow[CreateTransitGatewayVpcAttachmentRequest, CreateTransitGatewayVpcAttachmentResponse, NotUsed]
def createTransitGatewayVpcAttachmentSource(createTransitGatewayVpcAttachmentRequest: CreateTransitGatewayVpcAttachmentRequest, parallelism: Int = DefaultParallelism): Source[CreateTransitGatewayVpcAttachmentResponse, NotUsed]
def createVolumeFlow(parallelism: Int = DefaultParallelism): Flow[CreateVolumeRequest, CreateVolumeResponse, NotUsed]
def createVolumeSource(createVolumeRequest: CreateVolumeRequest, parallelism: Int = DefaultParallelism): Source[CreateVolumeResponse, NotUsed]
def createVpcEndpointConnectionNotificationFlow(parallelism: Int = DefaultParallelism): Flow[CreateVpcEndpointConnectionNotificationRequest, CreateVpcEndpointConnectionNotificationResponse, NotUsed]
def createVpcEndpointConnectionNotificationSource(createVpcEndpointConnectionNotificationRequest: CreateVpcEndpointConnectionNotificationRequest, parallelism: Int = DefaultParallelism): Source[CreateVpcEndpointConnectionNotificationResponse, NotUsed]
def createVpcEndpointFlow(parallelism: Int = DefaultParallelism): Flow[CreateVpcEndpointRequest, CreateVpcEndpointResponse, NotUsed]
def createVpcEndpointServiceConfigurationFlow(parallelism: Int = DefaultParallelism): Flow[CreateVpcEndpointServiceConfigurationRequest, CreateVpcEndpointServiceConfigurationResponse, NotUsed]
def createVpcEndpointServiceConfigurationSource(createVpcEndpointServiceConfigurationRequest: CreateVpcEndpointServiceConfigurationRequest, parallelism: Int = DefaultParallelism): Source[CreateVpcEndpointServiceConfigurationResponse, NotUsed]
def createVpcEndpointSource(createVpcEndpointRequest: CreateVpcEndpointRequest, parallelism: Int = DefaultParallelism): Source[CreateVpcEndpointResponse, NotUsed]
def createVpcFlow(parallelism: Int = DefaultParallelism): Flow[CreateVpcRequest, CreateVpcResponse, NotUsed]
def createVpcPeeringConnectionFlow(parallelism: Int = DefaultParallelism): Flow[CreateVpcPeeringConnectionRequest, CreateVpcPeeringConnectionResponse, NotUsed]
def createVpcPeeringConnectionSource(createVpcPeeringConnectionRequest: CreateVpcPeeringConnectionRequest, parallelism: Int = DefaultParallelism): Source[CreateVpcPeeringConnectionResponse, NotUsed]
def createVpcSource(createVpcRequest: CreateVpcRequest, parallelism: Int = DefaultParallelism): Source[CreateVpcResponse, NotUsed]
def createVpnConnectionFlow(parallelism: Int = DefaultParallelism): Flow[CreateVpnConnectionRequest, CreateVpnConnectionResponse, NotUsed]
def createVpnConnectionRouteFlow(parallelism: Int = DefaultParallelism): Flow[CreateVpnConnectionRouteRequest, CreateVpnConnectionRouteResponse, NotUsed]
def createVpnConnectionRouteSource(createVpnConnectionRouteRequest: CreateVpnConnectionRouteRequest, parallelism: Int = DefaultParallelism): Source[CreateVpnConnectionRouteResponse, NotUsed]
def createVpnConnectionSource(createVpnConnectionRequest: CreateVpnConnectionRequest, parallelism: Int = DefaultParallelism): Source[CreateVpnConnectionResponse, NotUsed]
def createVpnGatewayFlow(parallelism: Int = DefaultParallelism): Flow[CreateVpnGatewayRequest, CreateVpnGatewayResponse, NotUsed]
def createVpnGatewaySource(createVpnGatewayRequest: CreateVpnGatewayRequest, parallelism: Int = DefaultParallelism): Source[CreateVpnGatewayResponse, NotUsed]
def deleteClientVpnEndpointFlow(parallelism: Int = DefaultParallelism): Flow[DeleteClientVpnEndpointRequest, DeleteClientVpnEndpointResponse, NotUsed]
def deleteClientVpnEndpointSource(deleteClientVpnEndpointRequest: DeleteClientVpnEndpointRequest, parallelism: Int = DefaultParallelism): Source[DeleteClientVpnEndpointResponse, NotUsed]
def deleteClientVpnRouteFlow(parallelism: Int = DefaultParallelism): Flow[DeleteClientVpnRouteRequest, DeleteClientVpnRouteResponse, NotUsed]
def deleteClientVpnRouteSource(deleteClientVpnRouteRequest: DeleteClientVpnRouteRequest, parallelism: Int = DefaultParallelism): Source[DeleteClientVpnRouteResponse, NotUsed]
def deleteCustomerGatewayFlow(parallelism: Int = DefaultParallelism): Flow[DeleteCustomerGatewayRequest, DeleteCustomerGatewayResponse, NotUsed]
def deleteCustomerGatewaySource(deleteCustomerGatewayRequest: DeleteCustomerGatewayRequest, parallelism: Int = DefaultParallelism): Source[DeleteCustomerGatewayResponse, NotUsed]
def deleteDhcpOptionsFlow(parallelism: Int = DefaultParallelism): Flow[DeleteDhcpOptionsRequest, DeleteDhcpOptionsResponse, NotUsed]
def deleteDhcpOptionsSource(deleteDhcpOptionsRequest: DeleteDhcpOptionsRequest, parallelism: Int = DefaultParallelism): Source[DeleteDhcpOptionsResponse, NotUsed]
def deleteEgressOnlyInternetGatewayFlow(parallelism: Int = DefaultParallelism): Flow[DeleteEgressOnlyInternetGatewayRequest, DeleteEgressOnlyInternetGatewayResponse, NotUsed]
def deleteEgressOnlyInternetGatewaySource(deleteEgressOnlyInternetGatewayRequest: DeleteEgressOnlyInternetGatewayRequest, parallelism: Int = DefaultParallelism): Source[DeleteEgressOnlyInternetGatewayResponse, NotUsed]
def deleteFleetsFlow(parallelism: Int = DefaultParallelism): Flow[DeleteFleetsRequest, DeleteFleetsResponse, NotUsed]
def deleteFleetsSource(deleteFleetsRequest: DeleteFleetsRequest, parallelism: Int = DefaultParallelism): Source[DeleteFleetsResponse, NotUsed]
def deleteFlowLogsFlow(parallelism: Int = DefaultParallelism): Flow[DeleteFlowLogsRequest, DeleteFlowLogsResponse, NotUsed]
def deleteFlowLogsSource(deleteFlowLogsRequest: DeleteFlowLogsRequest, parallelism: Int = DefaultParallelism): Source[DeleteFlowLogsResponse, NotUsed]
def deleteFpgaImageFlow(parallelism: Int = DefaultParallelism): Flow[DeleteFpgaImageRequest, DeleteFpgaImageResponse, NotUsed]
def deleteFpgaImageSource(deleteFpgaImageRequest: DeleteFpgaImageRequest, parallelism: Int = DefaultParallelism): Source[DeleteFpgaImageResponse, NotUsed]
def deleteInternetGatewayFlow(parallelism: Int = DefaultParallelism): Flow[DeleteInternetGatewayRequest, DeleteInternetGatewayResponse, NotUsed]
def deleteInternetGatewaySource(deleteInternetGatewayRequest: DeleteInternetGatewayRequest, parallelism: Int = DefaultParallelism): Source[DeleteInternetGatewayResponse, NotUsed]
def deleteKeyPairFlow(parallelism: Int = DefaultParallelism): Flow[DeleteKeyPairRequest, DeleteKeyPairResponse, NotUsed]
def deleteKeyPairSource(deleteKeyPairRequest: DeleteKeyPairRequest, parallelism: Int = DefaultParallelism): Source[DeleteKeyPairResponse, NotUsed]
def deleteLaunchTemplateFlow(parallelism: Int = DefaultParallelism): Flow[DeleteLaunchTemplateRequest, DeleteLaunchTemplateResponse, NotUsed]
def deleteLaunchTemplateSource(deleteLaunchTemplateRequest: DeleteLaunchTemplateRequest, parallelism: Int = DefaultParallelism): Source[DeleteLaunchTemplateResponse, NotUsed]
def deleteLaunchTemplateVersionsFlow(parallelism: Int = DefaultParallelism): Flow[DeleteLaunchTemplateVersionsRequest, DeleteLaunchTemplateVersionsResponse, NotUsed]
def deleteLaunchTemplateVersionsSource(deleteLaunchTemplateVersionsRequest: DeleteLaunchTemplateVersionsRequest, parallelism: Int = DefaultParallelism): Source[DeleteLaunchTemplateVersionsResponse, NotUsed]
def deleteLocalGatewayRouteFlow(parallelism: Int = DefaultParallelism): Flow[DeleteLocalGatewayRouteRequest, DeleteLocalGatewayRouteResponse, NotUsed]
def deleteLocalGatewayRouteSource(deleteLocalGatewayRouteRequest: DeleteLocalGatewayRouteRequest, parallelism: Int = DefaultParallelism): Source[DeleteLocalGatewayRouteResponse, NotUsed]
def deleteLocalGatewayRouteTableVpcAssociationFlow(parallelism: Int = DefaultParallelism): Flow[DeleteLocalGatewayRouteTableVpcAssociationRequest, DeleteLocalGatewayRouteTableVpcAssociationResponse, NotUsed]
def deleteLocalGatewayRouteTableVpcAssociationSource(deleteLocalGatewayRouteTableVpcAssociationRequest: DeleteLocalGatewayRouteTableVpcAssociationRequest, parallelism: Int = DefaultParallelism): Source[DeleteLocalGatewayRouteTableVpcAssociationResponse, NotUsed]
def deleteNatGatewayFlow(parallelism: Int = DefaultParallelism): Flow[DeleteNatGatewayRequest, DeleteNatGatewayResponse, NotUsed]
def deleteNatGatewaySource(deleteNatGatewayRequest: DeleteNatGatewayRequest, parallelism: Int = DefaultParallelism): Source[DeleteNatGatewayResponse, NotUsed]
def deleteNetworkAclEntryFlow(parallelism: Int = DefaultParallelism): Flow[DeleteNetworkAclEntryRequest, DeleteNetworkAclEntryResponse, NotUsed]
def deleteNetworkAclEntrySource(deleteNetworkAclEntryRequest: DeleteNetworkAclEntryRequest, parallelism: Int = DefaultParallelism): Source[DeleteNetworkAclEntryResponse, NotUsed]
def deleteNetworkAclFlow(parallelism: Int = DefaultParallelism): Flow[DeleteNetworkAclRequest, DeleteNetworkAclResponse, NotUsed]
def deleteNetworkAclSource(deleteNetworkAclRequest: DeleteNetworkAclRequest, parallelism: Int = DefaultParallelism): Source[DeleteNetworkAclResponse, NotUsed]
def deleteNetworkInterfaceFlow(parallelism: Int = DefaultParallelism): Flow[DeleteNetworkInterfaceRequest, DeleteNetworkInterfaceResponse, NotUsed]
def deleteNetworkInterfacePermissionFlow(parallelism: Int = DefaultParallelism): Flow[DeleteNetworkInterfacePermissionRequest, DeleteNetworkInterfacePermissionResponse, NotUsed]
def deleteNetworkInterfacePermissionSource(deleteNetworkInterfacePermissionRequest: DeleteNetworkInterfacePermissionRequest, parallelism: Int = DefaultParallelism): Source[DeleteNetworkInterfacePermissionResponse, NotUsed]
def deleteNetworkInterfaceSource(deleteNetworkInterfaceRequest: DeleteNetworkInterfaceRequest, parallelism: Int = DefaultParallelism): Source[DeleteNetworkInterfaceResponse, NotUsed]
def deletePlacementGroupFlow(parallelism: Int = DefaultParallelism): Flow[DeletePlacementGroupRequest, DeletePlacementGroupResponse, NotUsed]
def deletePlacementGroupSource(deletePlacementGroupRequest: DeletePlacementGroupRequest, parallelism: Int = DefaultParallelism): Source[DeletePlacementGroupResponse, NotUsed]
def deleteQueuedReservedInstancesFlow(parallelism: Int = DefaultParallelism): Flow[DeleteQueuedReservedInstancesRequest, DeleteQueuedReservedInstancesResponse, NotUsed]
def deleteQueuedReservedInstancesSource(deleteQueuedReservedInstancesRequest: DeleteQueuedReservedInstancesRequest, parallelism: Int = DefaultParallelism): Source[DeleteQueuedReservedInstancesResponse, NotUsed]
def deleteRouteFlow(parallelism: Int = DefaultParallelism): Flow[DeleteRouteRequest, DeleteRouteResponse, NotUsed]
def deleteRouteSource(deleteRouteRequest: DeleteRouteRequest, parallelism: Int = DefaultParallelism): Source[DeleteRouteResponse, NotUsed]
def deleteRouteTableFlow(parallelism: Int = DefaultParallelism): Flow[DeleteRouteTableRequest, DeleteRouteTableResponse, NotUsed]
def deleteRouteTableSource(deleteRouteTableRequest: DeleteRouteTableRequest, parallelism: Int = DefaultParallelism): Source[DeleteRouteTableResponse, NotUsed]
def deleteSecurityGroupFlow(parallelism: Int = DefaultParallelism): Flow[DeleteSecurityGroupRequest, DeleteSecurityGroupResponse, NotUsed]
def deleteSecurityGroupSource(deleteSecurityGroupRequest: DeleteSecurityGroupRequest, parallelism: Int = DefaultParallelism): Source[DeleteSecurityGroupResponse, NotUsed]
def deleteSnapshotFlow(parallelism: Int = DefaultParallelism): Flow[DeleteSnapshotRequest, DeleteSnapshotResponse, NotUsed]
def deleteSnapshotSource(deleteSnapshotRequest: DeleteSnapshotRequest, parallelism: Int = DefaultParallelism): Source[DeleteSnapshotResponse, NotUsed]
def deleteSpotDatafeedSubscriptionFlow(parallelism: Int = DefaultParallelism): Flow[DeleteSpotDatafeedSubscriptionRequest, DeleteSpotDatafeedSubscriptionResponse, NotUsed]
def deleteSpotDatafeedSubscriptionSource(): Source[DeleteSpotDatafeedSubscriptionResponse, NotUsed]
def deleteSpotDatafeedSubscriptionSource(deleteSpotDatafeedSubscriptionRequest: DeleteSpotDatafeedSubscriptionRequest, parallelism: Int = DefaultParallelism): Source[DeleteSpotDatafeedSubscriptionResponse, NotUsed]
def deleteSubnetFlow(parallelism: Int = DefaultParallelism): Flow[DeleteSubnetRequest, DeleteSubnetResponse, NotUsed]
def deleteSubnetSource(deleteSubnetRequest: DeleteSubnetRequest, parallelism: Int = DefaultParallelism): Source[DeleteSubnetResponse, NotUsed]
def deleteTagsFlow(parallelism: Int = DefaultParallelism): Flow[DeleteTagsRequest, DeleteTagsResponse, NotUsed]
def deleteTagsSource(deleteTagsRequest: DeleteTagsRequest, parallelism: Int = DefaultParallelism): Source[DeleteTagsResponse, NotUsed]
def deleteTrafficMirrorFilterFlow(parallelism: Int = DefaultParallelism): Flow[DeleteTrafficMirrorFilterRequest, DeleteTrafficMirrorFilterResponse, NotUsed]
def deleteTrafficMirrorFilterRuleFlow(parallelism: Int = DefaultParallelism): Flow[DeleteTrafficMirrorFilterRuleRequest, DeleteTrafficMirrorFilterRuleResponse, NotUsed]
def deleteTrafficMirrorFilterRuleSource(deleteTrafficMirrorFilterRuleRequest: DeleteTrafficMirrorFilterRuleRequest, parallelism: Int = DefaultParallelism): Source[DeleteTrafficMirrorFilterRuleResponse, NotUsed]
def deleteTrafficMirrorFilterSource(deleteTrafficMirrorFilterRequest: DeleteTrafficMirrorFilterRequest, parallelism: Int = DefaultParallelism): Source[DeleteTrafficMirrorFilterResponse, NotUsed]
def deleteTrafficMirrorSessionFlow(parallelism: Int = DefaultParallelism): Flow[DeleteTrafficMirrorSessionRequest, DeleteTrafficMirrorSessionResponse, NotUsed]
def deleteTrafficMirrorSessionSource(deleteTrafficMirrorSessionRequest: DeleteTrafficMirrorSessionRequest, parallelism: Int = DefaultParallelism): Source[DeleteTrafficMirrorSessionResponse, NotUsed]
def deleteTrafficMirrorTargetFlow(parallelism: Int = DefaultParallelism): Flow[DeleteTrafficMirrorTargetRequest, DeleteTrafficMirrorTargetResponse, NotUsed]
def deleteTrafficMirrorTargetSource(deleteTrafficMirrorTargetRequest: DeleteTrafficMirrorTargetRequest, parallelism: Int = DefaultParallelism): Source[DeleteTrafficMirrorTargetResponse, NotUsed]
def deleteTransitGatewayFlow(parallelism: Int = DefaultParallelism): Flow[DeleteTransitGatewayRequest, DeleteTransitGatewayResponse, NotUsed]
def deleteTransitGatewayMulticastDomainFlow(parallelism: Int = DefaultParallelism): Flow[DeleteTransitGatewayMulticastDomainRequest, DeleteTransitGatewayMulticastDomainResponse, NotUsed]
def deleteTransitGatewayMulticastDomainSource(deleteTransitGatewayMulticastDomainRequest: DeleteTransitGatewayMulticastDomainRequest, parallelism: Int = DefaultParallelism): Source[DeleteTransitGatewayMulticastDomainResponse, NotUsed]
def deleteTransitGatewayPeeringAttachmentFlow(parallelism: Int = DefaultParallelism): Flow[DeleteTransitGatewayPeeringAttachmentRequest, DeleteTransitGatewayPeeringAttachmentResponse, NotUsed]
def deleteTransitGatewayPeeringAttachmentSource(deleteTransitGatewayPeeringAttachmentRequest: DeleteTransitGatewayPeeringAttachmentRequest, parallelism: Int = DefaultParallelism): Source[DeleteTransitGatewayPeeringAttachmentResponse, NotUsed]
def deleteTransitGatewayRouteFlow(parallelism: Int = DefaultParallelism): Flow[DeleteTransitGatewayRouteRequest, DeleteTransitGatewayRouteResponse, NotUsed]
def deleteTransitGatewayRouteSource(deleteTransitGatewayRouteRequest: DeleteTransitGatewayRouteRequest, parallelism: Int = DefaultParallelism): Source[DeleteTransitGatewayRouteResponse, NotUsed]
def deleteTransitGatewayRouteTableFlow(parallelism: Int = DefaultParallelism): Flow[DeleteTransitGatewayRouteTableRequest, DeleteTransitGatewayRouteTableResponse, NotUsed]
def deleteTransitGatewayRouteTableSource(deleteTransitGatewayRouteTableRequest: DeleteTransitGatewayRouteTableRequest, parallelism: Int = DefaultParallelism): Source[DeleteTransitGatewayRouteTableResponse, NotUsed]
def deleteTransitGatewaySource(deleteTransitGatewayRequest: DeleteTransitGatewayRequest, parallelism: Int = DefaultParallelism): Source[DeleteTransitGatewayResponse, NotUsed]
def deleteTransitGatewayVpcAttachmentFlow(parallelism: Int = DefaultParallelism): Flow[DeleteTransitGatewayVpcAttachmentRequest, DeleteTransitGatewayVpcAttachmentResponse, NotUsed]
def deleteTransitGatewayVpcAttachmentSource(deleteTransitGatewayVpcAttachmentRequest: DeleteTransitGatewayVpcAttachmentRequest, parallelism: Int = DefaultParallelism): Source[DeleteTransitGatewayVpcAttachmentResponse, NotUsed]
def deleteVolumeFlow(parallelism: Int = DefaultParallelism): Flow[DeleteVolumeRequest, DeleteVolumeResponse, NotUsed]
def deleteVolumeSource(deleteVolumeRequest: DeleteVolumeRequest, parallelism: Int = DefaultParallelism): Source[DeleteVolumeResponse, NotUsed]
def deleteVpcEndpointConnectionNotificationsFlow(parallelism: Int = DefaultParallelism): Flow[DeleteVpcEndpointConnectionNotificationsRequest, DeleteVpcEndpointConnectionNotificationsResponse, NotUsed]
def deleteVpcEndpointConnectionNotificationsSource(deleteVpcEndpointConnectionNotificationsRequest: DeleteVpcEndpointConnectionNotificationsRequest, parallelism: Int = DefaultParallelism): Source[DeleteVpcEndpointConnectionNotificationsResponse, NotUsed]
def deleteVpcEndpointServiceConfigurationsFlow(parallelism: Int = DefaultParallelism): Flow[DeleteVpcEndpointServiceConfigurationsRequest, DeleteVpcEndpointServiceConfigurationsResponse, NotUsed]
def deleteVpcEndpointServiceConfigurationsSource(deleteVpcEndpointServiceConfigurationsRequest: DeleteVpcEndpointServiceConfigurationsRequest, parallelism: Int = DefaultParallelism): Source[DeleteVpcEndpointServiceConfigurationsResponse, NotUsed]
def deleteVpcEndpointsFlow(parallelism: Int = DefaultParallelism): Flow[DeleteVpcEndpointsRequest, DeleteVpcEndpointsResponse, NotUsed]
def deleteVpcEndpointsSource(deleteVpcEndpointsRequest: DeleteVpcEndpointsRequest, parallelism: Int = DefaultParallelism): Source[DeleteVpcEndpointsResponse, NotUsed]
def deleteVpcFlow(parallelism: Int = DefaultParallelism): Flow[DeleteVpcRequest, DeleteVpcResponse, NotUsed]
def deleteVpcPeeringConnectionFlow(parallelism: Int = DefaultParallelism): Flow[DeleteVpcPeeringConnectionRequest, DeleteVpcPeeringConnectionResponse, NotUsed]
def deleteVpcPeeringConnectionSource(deleteVpcPeeringConnectionRequest: DeleteVpcPeeringConnectionRequest, parallelism: Int = DefaultParallelism): Source[DeleteVpcPeeringConnectionResponse, NotUsed]
def deleteVpcSource(deleteVpcRequest: DeleteVpcRequest, parallelism: Int = DefaultParallelism): Source[DeleteVpcResponse, NotUsed]
def deleteVpnConnectionFlow(parallelism: Int = DefaultParallelism): Flow[DeleteVpnConnectionRequest, DeleteVpnConnectionResponse, NotUsed]
def deleteVpnConnectionRouteFlow(parallelism: Int = DefaultParallelism): Flow[DeleteVpnConnectionRouteRequest, DeleteVpnConnectionRouteResponse, NotUsed]
def deleteVpnConnectionRouteSource(deleteVpnConnectionRouteRequest: DeleteVpnConnectionRouteRequest, parallelism: Int = DefaultParallelism): Source[DeleteVpnConnectionRouteResponse, NotUsed]
def deleteVpnConnectionSource(deleteVpnConnectionRequest: DeleteVpnConnectionRequest, parallelism: Int = DefaultParallelism): Source[DeleteVpnConnectionResponse, NotUsed]
def deleteVpnGatewayFlow(parallelism: Int = DefaultParallelism): Flow[DeleteVpnGatewayRequest, DeleteVpnGatewayResponse, NotUsed]
def deleteVpnGatewaySource(deleteVpnGatewayRequest: DeleteVpnGatewayRequest, parallelism: Int = DefaultParallelism): Source[DeleteVpnGatewayResponse, NotUsed]
def deprovisionByoipCidrFlow(parallelism: Int = DefaultParallelism): Flow[DeprovisionByoipCidrRequest, DeprovisionByoipCidrResponse, NotUsed]
def deprovisionByoipCidrSource(deprovisionByoipCidrRequest: DeprovisionByoipCidrRequest, parallelism: Int = DefaultParallelism): Source[DeprovisionByoipCidrResponse, NotUsed]
def deregisterImageFlow(parallelism: Int = DefaultParallelism): Flow[DeregisterImageRequest, DeregisterImageResponse, NotUsed]
def deregisterImageSource(deregisterImageRequest: DeregisterImageRequest, parallelism: Int = DefaultParallelism): Source[DeregisterImageResponse, NotUsed]
def deregisterTransitGatewayMulticastGroupMembersFlow(parallelism: Int = DefaultParallelism): Flow[DeregisterTransitGatewayMulticastGroupMembersRequest, DeregisterTransitGatewayMulticastGroupMembersResponse, NotUsed]
def deregisterTransitGatewayMulticastGroupMembersSource(deregisterTransitGatewayMulticastGroupMembersRequest: DeregisterTransitGatewayMulticastGroupMembersRequest, parallelism: Int = DefaultParallelism): Source[DeregisterTransitGatewayMulticastGroupMembersResponse, NotUsed]
def deregisterTransitGatewayMulticastGroupSourcesFlow(parallelism: Int = DefaultParallelism): Flow[DeregisterTransitGatewayMulticastGroupSourcesRequest, DeregisterTransitGatewayMulticastGroupSourcesResponse, NotUsed]
def deregisterTransitGatewayMulticastGroupSourcesSource(deregisterTransitGatewayMulticastGroupSourcesRequest: DeregisterTransitGatewayMulticastGroupSourcesRequest, parallelism: Int = DefaultParallelism): Source[DeregisterTransitGatewayMulticastGroupSourcesResponse, NotUsed]
def describeAccountAttributesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeAccountAttributesRequest, DescribeAccountAttributesResponse, NotUsed]
def describeAccountAttributesSource(): Source[DescribeAccountAttributesResponse, NotUsed]
def describeAccountAttributesSource(describeAccountAttributesRequest: DescribeAccountAttributesRequest, parallelism: Int = DefaultParallelism): Source[DescribeAccountAttributesResponse, NotUsed]
def describeAddressesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeAddressesRequest, DescribeAddressesResponse, NotUsed]
def describeAddressesSource(): Source[DescribeAddressesResponse, NotUsed]
def describeAddressesSource(describeAddressesRequest: DescribeAddressesRequest, parallelism: Int = DefaultParallelism): Source[DescribeAddressesResponse, NotUsed]
def describeAggregateIdFormatFlow(parallelism: Int = DefaultParallelism): Flow[DescribeAggregateIdFormatRequest, DescribeAggregateIdFormatResponse, NotUsed]
def describeAggregateIdFormatSource(): Source[DescribeAggregateIdFormatResponse, NotUsed]
def describeAggregateIdFormatSource(describeAggregateIdFormatRequest: DescribeAggregateIdFormatRequest, parallelism: Int = DefaultParallelism): Source[DescribeAggregateIdFormatResponse, NotUsed]
def describeAvailabilityZonesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeAvailabilityZonesRequest, DescribeAvailabilityZonesResponse, NotUsed]
def describeAvailabilityZonesSource(): Source[DescribeAvailabilityZonesResponse, NotUsed]
def describeAvailabilityZonesSource(describeAvailabilityZonesRequest: DescribeAvailabilityZonesRequest, parallelism: Int = DefaultParallelism): Source[DescribeAvailabilityZonesResponse, NotUsed]
def describeBundleTasksFlow(parallelism: Int = DefaultParallelism): Flow[DescribeBundleTasksRequest, DescribeBundleTasksResponse, NotUsed]
def describeBundleTasksSource(): Source[DescribeBundleTasksResponse, NotUsed]
def describeBundleTasksSource(describeBundleTasksRequest: DescribeBundleTasksRequest, parallelism: Int = DefaultParallelism): Source[DescribeBundleTasksResponse, NotUsed]
def describeByoipCidrsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeByoipCidrsRequest, DescribeByoipCidrsResponse, NotUsed]
def describeByoipCidrsPaginatorFlow: Flow[DescribeByoipCidrsRequest, DescribeByoipCidrsResponse, NotUsed]
def describeByoipCidrsSource(describeByoipCidrsRequest: DescribeByoipCidrsRequest, parallelism: Int = DefaultParallelism): Source[DescribeByoipCidrsResponse, NotUsed]
def describeCapacityReservationsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeCapacityReservationsRequest, DescribeCapacityReservationsResponse, NotUsed]
def describeCapacityReservationsPaginatorFlow: Flow[DescribeCapacityReservationsRequest, DescribeCapacityReservationsResponse, NotUsed]
def describeCapacityReservationsPaginatorSource: Source[DescribeCapacityReservationsResponse, NotUsed]
def describeCapacityReservationsSource(): Source[DescribeCapacityReservationsResponse, NotUsed]
def describeCapacityReservationsSource(describeCapacityReservationsRequest: DescribeCapacityReservationsRequest, parallelism: Int = DefaultParallelism): Source[DescribeCapacityReservationsResponse, NotUsed]
def describeClassicLinkInstancesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeClassicLinkInstancesRequest, DescribeClassicLinkInstancesResponse, NotUsed]
def describeClassicLinkInstancesPaginatorFlow: Flow[DescribeClassicLinkInstancesRequest, DescribeClassicLinkInstancesResponse, NotUsed]
def describeClassicLinkInstancesPaginatorSource: Source[DescribeClassicLinkInstancesResponse, NotUsed]
def describeClassicLinkInstancesSource(): Source[DescribeClassicLinkInstancesResponse, NotUsed]
def describeClassicLinkInstancesSource(describeClassicLinkInstancesRequest: DescribeClassicLinkInstancesRequest, parallelism: Int = DefaultParallelism): Source[DescribeClassicLinkInstancesResponse, NotUsed]
def describeClientVpnAuthorizationRulesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeClientVpnAuthorizationRulesRequest, DescribeClientVpnAuthorizationRulesResponse, NotUsed]
def describeClientVpnAuthorizationRulesPaginatorFlow: Flow[DescribeClientVpnAuthorizationRulesRequest, DescribeClientVpnAuthorizationRulesResponse, NotUsed]
def describeClientVpnAuthorizationRulesSource(describeClientVpnAuthorizationRulesRequest: DescribeClientVpnAuthorizationRulesRequest, parallelism: Int = DefaultParallelism): Source[DescribeClientVpnAuthorizationRulesResponse, NotUsed]
def describeClientVpnConnectionsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeClientVpnConnectionsRequest, DescribeClientVpnConnectionsResponse, NotUsed]
def describeClientVpnConnectionsPaginatorFlow: Flow[DescribeClientVpnConnectionsRequest, DescribeClientVpnConnectionsResponse, NotUsed]
def describeClientVpnConnectionsSource(describeClientVpnConnectionsRequest: DescribeClientVpnConnectionsRequest, parallelism: Int = DefaultParallelism): Source[DescribeClientVpnConnectionsResponse, NotUsed]
def describeClientVpnEndpointsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeClientVpnEndpointsRequest, DescribeClientVpnEndpointsResponse, NotUsed]
def describeClientVpnEndpointsPaginatorFlow: Flow[DescribeClientVpnEndpointsRequest, DescribeClientVpnEndpointsResponse, NotUsed]
def describeClientVpnEndpointsPaginatorSource: Source[DescribeClientVpnEndpointsResponse, NotUsed]
def describeClientVpnEndpointsSource(): Source[DescribeClientVpnEndpointsResponse, NotUsed]
def describeClientVpnEndpointsSource(describeClientVpnEndpointsRequest: DescribeClientVpnEndpointsRequest, parallelism: Int = DefaultParallelism): Source[DescribeClientVpnEndpointsResponse, NotUsed]
def describeClientVpnRoutesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeClientVpnRoutesRequest, DescribeClientVpnRoutesResponse, NotUsed]
def describeClientVpnRoutesPaginatorFlow: Flow[DescribeClientVpnRoutesRequest, DescribeClientVpnRoutesResponse, NotUsed]
def describeClientVpnRoutesSource(describeClientVpnRoutesRequest: DescribeClientVpnRoutesRequest, parallelism: Int = DefaultParallelism): Source[DescribeClientVpnRoutesResponse, NotUsed]
def describeClientVpnTargetNetworksFlow(parallelism: Int = DefaultParallelism): Flow[DescribeClientVpnTargetNetworksRequest, DescribeClientVpnTargetNetworksResponse, NotUsed]
def describeClientVpnTargetNetworksPaginatorFlow: Flow[DescribeClientVpnTargetNetworksRequest, DescribeClientVpnTargetNetworksResponse, NotUsed]
def describeClientVpnTargetNetworksSource(describeClientVpnTargetNetworksRequest: DescribeClientVpnTargetNetworksRequest, parallelism: Int = DefaultParallelism): Source[DescribeClientVpnTargetNetworksResponse, NotUsed]
def describeCoipPoolsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeCoipPoolsRequest, DescribeCoipPoolsResponse, NotUsed]
def describeCoipPoolsSource(describeCoipPoolsRequest: DescribeCoipPoolsRequest, parallelism: Int = DefaultParallelism): Source[DescribeCoipPoolsResponse, NotUsed]
def describeConversionTasksFlow(parallelism: Int = DefaultParallelism): Flow[DescribeConversionTasksRequest, DescribeConversionTasksResponse, NotUsed]
def describeConversionTasksSource(): Source[DescribeConversionTasksResponse, NotUsed]
def describeConversionTasksSource(describeConversionTasksRequest: DescribeConversionTasksRequest, parallelism: Int = DefaultParallelism): Source[DescribeConversionTasksResponse, NotUsed]
def describeCustomerGatewaysFlow(parallelism: Int = DefaultParallelism): Flow[DescribeCustomerGatewaysRequest, DescribeCustomerGatewaysResponse, NotUsed]
def describeCustomerGatewaysSource(): Source[DescribeCustomerGatewaysResponse, NotUsed]
def describeCustomerGatewaysSource(describeCustomerGatewaysRequest: DescribeCustomerGatewaysRequest, parallelism: Int = DefaultParallelism): Source[DescribeCustomerGatewaysResponse, NotUsed]
def describeDhcpOptionsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeDhcpOptionsRequest, DescribeDhcpOptionsResponse, NotUsed]
def describeDhcpOptionsPaginatorFlow: Flow[DescribeDhcpOptionsRequest, DescribeDhcpOptionsResponse, NotUsed]
def describeDhcpOptionsPaginatorSource: Source[DescribeDhcpOptionsResponse, NotUsed]
def describeDhcpOptionsSource(): Source[DescribeDhcpOptionsResponse, NotUsed]
def describeDhcpOptionsSource(describeDhcpOptionsRequest: DescribeDhcpOptionsRequest, parallelism: Int = DefaultParallelism): Source[DescribeDhcpOptionsResponse, NotUsed]
def describeEgressOnlyInternetGatewaysFlow(parallelism: Int = DefaultParallelism): Flow[DescribeEgressOnlyInternetGatewaysRequest, DescribeEgressOnlyInternetGatewaysResponse, NotUsed]
def describeEgressOnlyInternetGatewaysPaginatorFlow: Flow[DescribeEgressOnlyInternetGatewaysRequest, DescribeEgressOnlyInternetGatewaysResponse, NotUsed]
def describeEgressOnlyInternetGatewaysPaginatorSource: Source[DescribeEgressOnlyInternetGatewaysResponse, NotUsed]
def describeEgressOnlyInternetGatewaysSource(): Source[DescribeEgressOnlyInternetGatewaysResponse, NotUsed]
def describeEgressOnlyInternetGatewaysSource(describeEgressOnlyInternetGatewaysRequest: DescribeEgressOnlyInternetGatewaysRequest, parallelism: Int = DefaultParallelism): Source[DescribeEgressOnlyInternetGatewaysResponse, NotUsed]
def describeElasticGpusFlow(parallelism: Int = DefaultParallelism): Flow[DescribeElasticGpusRequest, DescribeElasticGpusResponse, NotUsed]
def describeElasticGpusSource(): Source[DescribeElasticGpusResponse, NotUsed]
def describeElasticGpusSource(describeElasticGpusRequest: DescribeElasticGpusRequest, parallelism: Int = DefaultParallelism): Source[DescribeElasticGpusResponse, NotUsed]
def describeExportImageTasksFlow(parallelism: Int = DefaultParallelism): Flow[DescribeExportImageTasksRequest, DescribeExportImageTasksResponse, NotUsed]
def describeExportImageTasksPaginatorFlow: Flow[DescribeExportImageTasksRequest, DescribeExportImageTasksResponse, NotUsed]
def describeExportImageTasksSource(describeExportImageTasksRequest: DescribeExportImageTasksRequest, parallelism: Int = DefaultParallelism): Source[DescribeExportImageTasksResponse, NotUsed]
def describeExportTasksFlow(parallelism: Int = DefaultParallelism): Flow[DescribeExportTasksRequest, DescribeExportTasksResponse, NotUsed]
def describeExportTasksSource(): Source[DescribeExportTasksResponse, NotUsed]
def describeExportTasksSource(describeExportTasksRequest: DescribeExportTasksRequest, parallelism: Int = DefaultParallelism): Source[DescribeExportTasksResponse, NotUsed]
def describeFastSnapshotRestoresFlow(parallelism: Int = DefaultParallelism): Flow[DescribeFastSnapshotRestoresRequest, DescribeFastSnapshotRestoresResponse, NotUsed]
def describeFastSnapshotRestoresPaginatorFlow: Flow[DescribeFastSnapshotRestoresRequest, DescribeFastSnapshotRestoresResponse, NotUsed]
def describeFastSnapshotRestoresSource(describeFastSnapshotRestoresRequest: DescribeFastSnapshotRestoresRequest, parallelism: Int = DefaultParallelism): Source[DescribeFastSnapshotRestoresResponse, NotUsed]
def describeFleetHistoryFlow(parallelism: Int = DefaultParallelism): Flow[DescribeFleetHistoryRequest, DescribeFleetHistoryResponse, NotUsed]
def describeFleetHistorySource(describeFleetHistoryRequest: DescribeFleetHistoryRequest, parallelism: Int = DefaultParallelism): Source[DescribeFleetHistoryResponse, NotUsed]
def describeFleetInstancesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeFleetInstancesRequest, DescribeFleetInstancesResponse, NotUsed]
def describeFleetInstancesSource(describeFleetInstancesRequest: DescribeFleetInstancesRequest, parallelism: Int = DefaultParallelism): Source[DescribeFleetInstancesResponse, NotUsed]
def describeFleetsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeFleetsRequest, DescribeFleetsResponse, NotUsed]
def describeFleetsPaginatorFlow: Flow[DescribeFleetsRequest, DescribeFleetsResponse, NotUsed]
def describeFleetsPaginatorSource: Source[DescribeFleetsResponse, NotUsed]
def describeFleetsSource(): Source[DescribeFleetsResponse, NotUsed]
def describeFleetsSource(describeFleetsRequest: DescribeFleetsRequest, parallelism: Int = DefaultParallelism): Source[DescribeFleetsResponse, NotUsed]
def describeFlowLogsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeFlowLogsRequest, DescribeFlowLogsResponse, NotUsed]
def describeFlowLogsPaginatorFlow: Flow[DescribeFlowLogsRequest, DescribeFlowLogsResponse, NotUsed]
def describeFlowLogsPaginatorSource: Source[DescribeFlowLogsResponse, NotUsed]
def describeFlowLogsSource(): Source[DescribeFlowLogsResponse, NotUsed]
def describeFlowLogsSource(describeFlowLogsRequest: DescribeFlowLogsRequest, parallelism: Int = DefaultParallelism): Source[DescribeFlowLogsResponse, NotUsed]
def describeFpgaImageAttributeFlow(parallelism: Int = DefaultParallelism): Flow[DescribeFpgaImageAttributeRequest, DescribeFpgaImageAttributeResponse, NotUsed]
def describeFpgaImageAttributeSource(describeFpgaImageAttributeRequest: DescribeFpgaImageAttributeRequest, parallelism: Int = DefaultParallelism): Source[DescribeFpgaImageAttributeResponse, NotUsed]
def describeFpgaImagesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeFpgaImagesRequest, DescribeFpgaImagesResponse, NotUsed]
def describeFpgaImagesPaginatorFlow: Flow[DescribeFpgaImagesRequest, DescribeFpgaImagesResponse, NotUsed]
def describeFpgaImagesPaginatorSource: Source[DescribeFpgaImagesResponse, NotUsed]
def describeFpgaImagesSource(): Source[DescribeFpgaImagesResponse, NotUsed]
def describeFpgaImagesSource(describeFpgaImagesRequest: DescribeFpgaImagesRequest, parallelism: Int = DefaultParallelism): Source[DescribeFpgaImagesResponse, NotUsed]
def describeHostReservationOfferingsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeHostReservationOfferingsRequest, DescribeHostReservationOfferingsResponse, NotUsed]
def describeHostReservationOfferingsPaginatorFlow: Flow[DescribeHostReservationOfferingsRequest, DescribeHostReservationOfferingsResponse, NotUsed]
def describeHostReservationOfferingsPaginatorSource: Source[DescribeHostReservationOfferingsResponse, NotUsed]
def describeHostReservationOfferingsSource(): Source[DescribeHostReservationOfferingsResponse, NotUsed]
def describeHostReservationOfferingsSource(describeHostReservationOfferingsRequest: DescribeHostReservationOfferingsRequest, parallelism: Int = DefaultParallelism): Source[DescribeHostReservationOfferingsResponse, NotUsed]
def describeHostReservationsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeHostReservationsRequest, DescribeHostReservationsResponse, NotUsed]
def describeHostReservationsPaginatorFlow: Flow[DescribeHostReservationsRequest, DescribeHostReservationsResponse, NotUsed]
def describeHostReservationsPaginatorSource: Source[DescribeHostReservationsResponse, NotUsed]
def describeHostReservationsSource(): Source[DescribeHostReservationsResponse, NotUsed]
def describeHostReservationsSource(describeHostReservationsRequest: DescribeHostReservationsRequest, parallelism: Int = DefaultParallelism): Source[DescribeHostReservationsResponse, NotUsed]
def describeHostsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeHostsRequest, DescribeHostsResponse, NotUsed]
def describeHostsPaginatorFlow: Flow[DescribeHostsRequest, DescribeHostsResponse, NotUsed]
def describeHostsPaginatorSource: Source[DescribeHostsResponse, NotUsed]
def describeHostsSource(): Source[DescribeHostsResponse, NotUsed]
def describeHostsSource(describeHostsRequest: DescribeHostsRequest, parallelism: Int = DefaultParallelism): Source[DescribeHostsResponse, NotUsed]
def describeIamInstanceProfileAssociationsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeIamInstanceProfileAssociationsRequest, DescribeIamInstanceProfileAssociationsResponse, NotUsed]
def describeIamInstanceProfileAssociationsPaginatorFlow: Flow[DescribeIamInstanceProfileAssociationsRequest, DescribeIamInstanceProfileAssociationsResponse, NotUsed]
def describeIamInstanceProfileAssociationsPaginatorSource: Source[DescribeIamInstanceProfileAssociationsResponse, NotUsed]
def describeIamInstanceProfileAssociationsSource(): Source[DescribeIamInstanceProfileAssociationsResponse, NotUsed]
def describeIamInstanceProfileAssociationsSource(describeIamInstanceProfileAssociationsRequest: DescribeIamInstanceProfileAssociationsRequest, parallelism: Int = DefaultParallelism): Source[DescribeIamInstanceProfileAssociationsResponse, NotUsed]
def describeIdFormatFlow(parallelism: Int = DefaultParallelism): Flow[DescribeIdFormatRequest, DescribeIdFormatResponse, NotUsed]
def describeIdFormatSource(): Source[DescribeIdFormatResponse, NotUsed]
def describeIdFormatSource(describeIdFormatRequest: DescribeIdFormatRequest, parallelism: Int = DefaultParallelism): Source[DescribeIdFormatResponse, NotUsed]
def describeIdentityIdFormatFlow(parallelism: Int = DefaultParallelism): Flow[DescribeIdentityIdFormatRequest, DescribeIdentityIdFormatResponse, NotUsed]
def describeIdentityIdFormatSource(describeIdentityIdFormatRequest: DescribeIdentityIdFormatRequest, parallelism: Int = DefaultParallelism): Source[DescribeIdentityIdFormatResponse, NotUsed]
def describeImageAttributeFlow(parallelism: Int = DefaultParallelism): Flow[DescribeImageAttributeRequest, DescribeImageAttributeResponse, NotUsed]
def describeImageAttributeSource(describeImageAttributeRequest: DescribeImageAttributeRequest, parallelism: Int = DefaultParallelism): Source[DescribeImageAttributeResponse, NotUsed]
def describeImagesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeImagesRequest, DescribeImagesResponse, NotUsed]
def describeImagesSource(): Source[DescribeImagesResponse, NotUsed]
def describeImagesSource(describeImagesRequest: DescribeImagesRequest, parallelism: Int = DefaultParallelism): Source[DescribeImagesResponse, NotUsed]
def describeImportImageTasksFlow(parallelism: Int = DefaultParallelism): Flow[DescribeImportImageTasksRequest, DescribeImportImageTasksResponse, NotUsed]
def describeImportImageTasksPaginatorFlow: Flow[DescribeImportImageTasksRequest, DescribeImportImageTasksResponse, NotUsed]
def describeImportImageTasksPaginatorSource: Source[DescribeImportImageTasksResponse, NotUsed]
def describeImportImageTasksSource(): Source[DescribeImportImageTasksResponse, NotUsed]
def describeImportImageTasksSource(describeImportImageTasksRequest: DescribeImportImageTasksRequest, parallelism: Int = DefaultParallelism): Source[DescribeImportImageTasksResponse, NotUsed]
def describeImportSnapshotTasksFlow(parallelism: Int = DefaultParallelism): Flow[DescribeImportSnapshotTasksRequest, DescribeImportSnapshotTasksResponse, NotUsed]
def describeImportSnapshotTasksPaginatorFlow: Flow[DescribeImportSnapshotTasksRequest, DescribeImportSnapshotTasksResponse, NotUsed]
def describeImportSnapshotTasksPaginatorSource: Source[DescribeImportSnapshotTasksResponse, NotUsed]
def describeImportSnapshotTasksSource(): Source[DescribeImportSnapshotTasksResponse, NotUsed]
def describeImportSnapshotTasksSource(describeImportSnapshotTasksRequest: DescribeImportSnapshotTasksRequest, parallelism: Int = DefaultParallelism): Source[DescribeImportSnapshotTasksResponse, NotUsed]
def describeInstanceAttributeFlow(parallelism: Int = DefaultParallelism): Flow[DescribeInstanceAttributeRequest, DescribeInstanceAttributeResponse, NotUsed]
def describeInstanceAttributeSource(describeInstanceAttributeRequest: DescribeInstanceAttributeRequest, parallelism: Int = DefaultParallelism): Source[DescribeInstanceAttributeResponse, NotUsed]
def describeInstanceCreditSpecificationsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeInstanceCreditSpecificationsRequest, DescribeInstanceCreditSpecificationsResponse, NotUsed]
def describeInstanceCreditSpecificationsPaginatorFlow: Flow[DescribeInstanceCreditSpecificationsRequest, DescribeInstanceCreditSpecificationsResponse, NotUsed]
def describeInstanceCreditSpecificationsPaginatorSource: Source[DescribeInstanceCreditSpecificationsResponse, NotUsed]
def describeInstanceCreditSpecificationsSource(): Source[DescribeInstanceCreditSpecificationsResponse, NotUsed]
def describeInstanceCreditSpecificationsSource(describeInstanceCreditSpecificationsRequest: DescribeInstanceCreditSpecificationsRequest, parallelism: Int = DefaultParallelism): Source[DescribeInstanceCreditSpecificationsResponse, NotUsed]
def describeInstanceStatusFlow(parallelism: Int = DefaultParallelism): Flow[DescribeInstanceStatusRequest, DescribeInstanceStatusResponse, NotUsed]
def describeInstanceStatusPaginatorFlow: Flow[DescribeInstanceStatusRequest, DescribeInstanceStatusResponse, NotUsed]
def describeInstanceStatusPaginatorSource: Source[DescribeInstanceStatusResponse, NotUsed]
def describeInstanceStatusSource(): Source[DescribeInstanceStatusResponse, NotUsed]
def describeInstanceStatusSource(describeInstanceStatusRequest: DescribeInstanceStatusRequest, parallelism: Int = DefaultParallelism): Source[DescribeInstanceStatusResponse, NotUsed]
def describeInstanceTypeOfferingsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeInstanceTypeOfferingsRequest, DescribeInstanceTypeOfferingsResponse, NotUsed]
def describeInstanceTypeOfferingsSource(describeInstanceTypeOfferingsRequest: DescribeInstanceTypeOfferingsRequest, parallelism: Int = DefaultParallelism): Source[DescribeInstanceTypeOfferingsResponse, NotUsed]
def describeInstanceTypesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeInstanceTypesRequest, DescribeInstanceTypesResponse, NotUsed]
def describeInstanceTypesSource(describeInstanceTypesRequest: DescribeInstanceTypesRequest, parallelism: Int = DefaultParallelism): Source[DescribeInstanceTypesResponse, NotUsed]
def describeInstancesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeInstancesRequest, DescribeInstancesResponse, NotUsed]
def describeInstancesPaginatorFlow: Flow[DescribeInstancesRequest, DescribeInstancesResponse, NotUsed]
def describeInstancesPaginatorSource: Source[DescribeInstancesResponse, NotUsed]
def describeInstancesSource(): Source[DescribeInstancesResponse, NotUsed]
def describeInstancesSource(describeInstancesRequest: DescribeInstancesRequest, parallelism: Int = DefaultParallelism): Source[DescribeInstancesResponse, NotUsed]
def describeInternetGatewaysFlow(parallelism: Int = DefaultParallelism): Flow[DescribeInternetGatewaysRequest, DescribeInternetGatewaysResponse, NotUsed]
def describeInternetGatewaysPaginatorFlow: Flow[DescribeInternetGatewaysRequest, DescribeInternetGatewaysResponse, NotUsed]
def describeInternetGatewaysPaginatorSource: Source[DescribeInternetGatewaysResponse, NotUsed]
def describeInternetGatewaysSource(): Source[DescribeInternetGatewaysResponse, NotUsed]
def describeInternetGatewaysSource(describeInternetGatewaysRequest: DescribeInternetGatewaysRequest, parallelism: Int = DefaultParallelism): Source[DescribeInternetGatewaysResponse, NotUsed]
def describeIpv6PoolsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeIpv6PoolsRequest, DescribeIpv6PoolsResponse, NotUsed]
def describeIpv6PoolsPaginatorFlow: Flow[DescribeIpv6PoolsRequest, DescribeIpv6PoolsResponse, NotUsed]
def describeIpv6PoolsSource(describeIpv6PoolsRequest: DescribeIpv6PoolsRequest, parallelism: Int = DefaultParallelism): Source[DescribeIpv6PoolsResponse, NotUsed]
def describeKeyPairsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeKeyPairsRequest, DescribeKeyPairsResponse, NotUsed]
def describeKeyPairsSource(): Source[DescribeKeyPairsResponse, NotUsed]
def describeKeyPairsSource(describeKeyPairsRequest: DescribeKeyPairsRequest, parallelism: Int = DefaultParallelism): Source[DescribeKeyPairsResponse, NotUsed]
def describeLaunchTemplateVersionsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeLaunchTemplateVersionsRequest, DescribeLaunchTemplateVersionsResponse, NotUsed]
def describeLaunchTemplateVersionsPaginatorFlow: Flow[DescribeLaunchTemplateVersionsRequest, DescribeLaunchTemplateVersionsResponse, NotUsed]
def describeLaunchTemplateVersionsSource(describeLaunchTemplateVersionsRequest: DescribeLaunchTemplateVersionsRequest, parallelism: Int = DefaultParallelism): Source[DescribeLaunchTemplateVersionsResponse, NotUsed]
def describeLaunchTemplatesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeLaunchTemplatesRequest, DescribeLaunchTemplatesResponse, NotUsed]
def describeLaunchTemplatesPaginatorFlow: Flow[DescribeLaunchTemplatesRequest, DescribeLaunchTemplatesResponse, NotUsed]
def describeLaunchTemplatesPaginatorSource: Source[DescribeLaunchTemplatesResponse, NotUsed]
def describeLaunchTemplatesSource(): Source[DescribeLaunchTemplatesResponse, NotUsed]
def describeLaunchTemplatesSource(describeLaunchTemplatesRequest: DescribeLaunchTemplatesRequest, parallelism: Int = DefaultParallelism): Source[DescribeLaunchTemplatesResponse, NotUsed]
def describeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest, DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResponse, NotUsed]
def describeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsSource(describeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest: DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest, parallelism: Int = DefaultParallelism): Source[DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResponse, NotUsed]
def describeLocalGatewayRouteTableVpcAssociationsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeLocalGatewayRouteTableVpcAssociationsRequest, DescribeLocalGatewayRouteTableVpcAssociationsResponse, NotUsed]
def describeLocalGatewayRouteTableVpcAssociationsSource(describeLocalGatewayRouteTableVpcAssociationsRequest: DescribeLocalGatewayRouteTableVpcAssociationsRequest, parallelism: Int = DefaultParallelism): Source[DescribeLocalGatewayRouteTableVpcAssociationsResponse, NotUsed]
def describeLocalGatewayRouteTablesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeLocalGatewayRouteTablesRequest, DescribeLocalGatewayRouteTablesResponse, NotUsed]
def describeLocalGatewayRouteTablesSource(describeLocalGatewayRouteTablesRequest: DescribeLocalGatewayRouteTablesRequest, parallelism: Int = DefaultParallelism): Source[DescribeLocalGatewayRouteTablesResponse, NotUsed]
def describeLocalGatewayVirtualInterfaceGroupsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeLocalGatewayVirtualInterfaceGroupsRequest, DescribeLocalGatewayVirtualInterfaceGroupsResponse, NotUsed]
def describeLocalGatewayVirtualInterfaceGroupsSource(describeLocalGatewayVirtualInterfaceGroupsRequest: DescribeLocalGatewayVirtualInterfaceGroupsRequest, parallelism: Int = DefaultParallelism): Source[DescribeLocalGatewayVirtualInterfaceGroupsResponse, NotUsed]
def describeLocalGatewayVirtualInterfacesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeLocalGatewayVirtualInterfacesRequest, DescribeLocalGatewayVirtualInterfacesResponse, NotUsed]
def describeLocalGatewayVirtualInterfacesSource(describeLocalGatewayVirtualInterfacesRequest: DescribeLocalGatewayVirtualInterfacesRequest, parallelism: Int = DefaultParallelism): Source[DescribeLocalGatewayVirtualInterfacesResponse, NotUsed]
def describeLocalGatewaysFlow(parallelism: Int = DefaultParallelism): Flow[DescribeLocalGatewaysRequest, DescribeLocalGatewaysResponse, NotUsed]
def describeLocalGatewaysSource(describeLocalGatewaysRequest: DescribeLocalGatewaysRequest, parallelism: Int = DefaultParallelism): Source[DescribeLocalGatewaysResponse, NotUsed]
def describeMovingAddressesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeMovingAddressesRequest, DescribeMovingAddressesResponse, NotUsed]
def describeMovingAddressesPaginatorFlow: Flow[DescribeMovingAddressesRequest, DescribeMovingAddressesResponse, NotUsed]
def describeMovingAddressesPaginatorSource: Source[DescribeMovingAddressesResponse, NotUsed]
def describeMovingAddressesSource(): Source[DescribeMovingAddressesResponse, NotUsed]
def describeMovingAddressesSource(describeMovingAddressesRequest: DescribeMovingAddressesRequest, parallelism: Int = DefaultParallelism): Source[DescribeMovingAddressesResponse, NotUsed]
def describeNatGatewaysFlow(parallelism: Int = DefaultParallelism): Flow[DescribeNatGatewaysRequest, DescribeNatGatewaysResponse, NotUsed]
def describeNatGatewaysPaginatorFlow: Flow[DescribeNatGatewaysRequest, DescribeNatGatewaysResponse, NotUsed]
def describeNatGatewaysPaginatorSource: Source[DescribeNatGatewaysResponse, NotUsed]
def describeNatGatewaysSource(): Source[DescribeNatGatewaysResponse, NotUsed]
def describeNatGatewaysSource(describeNatGatewaysRequest: DescribeNatGatewaysRequest, parallelism: Int = DefaultParallelism): Source[DescribeNatGatewaysResponse, NotUsed]
def describeNetworkAclsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeNetworkAclsRequest, DescribeNetworkAclsResponse, NotUsed]
def describeNetworkAclsPaginatorFlow: Flow[DescribeNetworkAclsRequest, DescribeNetworkAclsResponse, NotUsed]
def describeNetworkAclsPaginatorSource: Source[DescribeNetworkAclsResponse, NotUsed]
def describeNetworkAclsSource(): Source[DescribeNetworkAclsResponse, NotUsed]
def describeNetworkAclsSource(describeNetworkAclsRequest: DescribeNetworkAclsRequest, parallelism: Int = DefaultParallelism): Source[DescribeNetworkAclsResponse, NotUsed]
def describeNetworkInterfaceAttributeFlow(parallelism: Int = DefaultParallelism): Flow[DescribeNetworkInterfaceAttributeRequest, DescribeNetworkInterfaceAttributeResponse, NotUsed]
def describeNetworkInterfaceAttributeSource(describeNetworkInterfaceAttributeRequest: DescribeNetworkInterfaceAttributeRequest, parallelism: Int = DefaultParallelism): Source[DescribeNetworkInterfaceAttributeResponse, NotUsed]
def describeNetworkInterfacePermissionsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeNetworkInterfacePermissionsRequest, DescribeNetworkInterfacePermissionsResponse, NotUsed]
def describeNetworkInterfacePermissionsPaginatorFlow: Flow[DescribeNetworkInterfacePermissionsRequest, DescribeNetworkInterfacePermissionsResponse, NotUsed]
def describeNetworkInterfacePermissionsPaginatorSource: Source[DescribeNetworkInterfacePermissionsResponse, NotUsed]
def describeNetworkInterfacePermissionsSource(): Source[DescribeNetworkInterfacePermissionsResponse, NotUsed]
def describeNetworkInterfacePermissionsSource(describeNetworkInterfacePermissionsRequest: DescribeNetworkInterfacePermissionsRequest, parallelism: Int = DefaultParallelism): Source[DescribeNetworkInterfacePermissionsResponse, NotUsed]
def describeNetworkInterfacesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeNetworkInterfacesRequest, DescribeNetworkInterfacesResponse, NotUsed]
def describeNetworkInterfacesPaginatorFlow: Flow[DescribeNetworkInterfacesRequest, DescribeNetworkInterfacesResponse, NotUsed]
def describeNetworkInterfacesPaginatorSource: Source[DescribeNetworkInterfacesResponse, NotUsed]
def describeNetworkInterfacesSource(): Source[DescribeNetworkInterfacesResponse, NotUsed]
def describeNetworkInterfacesSource(describeNetworkInterfacesRequest: DescribeNetworkInterfacesRequest, parallelism: Int = DefaultParallelism): Source[DescribeNetworkInterfacesResponse, NotUsed]
def describePlacementGroupsFlow(parallelism: Int = DefaultParallelism): Flow[DescribePlacementGroupsRequest, DescribePlacementGroupsResponse, NotUsed]
def describePlacementGroupsSource(): Source[DescribePlacementGroupsResponse, NotUsed]
def describePlacementGroupsSource(describePlacementGroupsRequest: DescribePlacementGroupsRequest, parallelism: Int = DefaultParallelism): Source[DescribePlacementGroupsResponse, NotUsed]
def describePrefixListsFlow(parallelism: Int = DefaultParallelism): Flow[DescribePrefixListsRequest, DescribePrefixListsResponse, NotUsed]
def describePrefixListsPaginatorFlow: Flow[DescribePrefixListsRequest, DescribePrefixListsResponse, NotUsed]
def describePrefixListsPaginatorSource: Source[DescribePrefixListsResponse, NotUsed]
def describePrefixListsSource(): Source[DescribePrefixListsResponse, NotUsed]
def describePrefixListsSource(describePrefixListsRequest: DescribePrefixListsRequest, parallelism: Int = DefaultParallelism): Source[DescribePrefixListsResponse, NotUsed]
def describePrincipalIdFormatFlow(parallelism: Int = DefaultParallelism): Flow[DescribePrincipalIdFormatRequest, DescribePrincipalIdFormatResponse, NotUsed]
def describePrincipalIdFormatPaginatorFlow: Flow[DescribePrincipalIdFormatRequest, DescribePrincipalIdFormatResponse, NotUsed]
def describePrincipalIdFormatPaginatorSource: Source[DescribePrincipalIdFormatResponse, NotUsed]
def describePrincipalIdFormatSource(): Source[DescribePrincipalIdFormatResponse, NotUsed]
def describePrincipalIdFormatSource(describePrincipalIdFormatRequest: DescribePrincipalIdFormatRequest, parallelism: Int = DefaultParallelism): Source[DescribePrincipalIdFormatResponse, NotUsed]
def describePublicIpv4PoolsFlow(parallelism: Int = DefaultParallelism): Flow[DescribePublicIpv4PoolsRequest, DescribePublicIpv4PoolsResponse, NotUsed]
def describePublicIpv4PoolsPaginatorFlow: Flow[DescribePublicIpv4PoolsRequest, DescribePublicIpv4PoolsResponse, NotUsed]
def describePublicIpv4PoolsPaginatorSource: Source[DescribePublicIpv4PoolsResponse, NotUsed]
def describePublicIpv4PoolsSource(): Source[DescribePublicIpv4PoolsResponse, NotUsed]
def describePublicIpv4PoolsSource(describePublicIpv4PoolsRequest: DescribePublicIpv4PoolsRequest, parallelism: Int = DefaultParallelism): Source[DescribePublicIpv4PoolsResponse, NotUsed]
def describeRegionsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeRegionsRequest, DescribeRegionsResponse, NotUsed]
def describeRegionsSource(): Source[DescribeRegionsResponse, NotUsed]
def describeRegionsSource(describeRegionsRequest: DescribeRegionsRequest, parallelism: Int = DefaultParallelism): Source[DescribeRegionsResponse, NotUsed]
def describeReservedInstancesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeReservedInstancesRequest, DescribeReservedInstancesResponse, NotUsed]
def describeReservedInstancesListingsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeReservedInstancesListingsRequest, DescribeReservedInstancesListingsResponse, NotUsed]
def describeReservedInstancesListingsSource(): Source[DescribeReservedInstancesListingsResponse, NotUsed]
def describeReservedInstancesListingsSource(describeReservedInstancesListingsRequest: DescribeReservedInstancesListingsRequest, parallelism: Int = DefaultParallelism): Source[DescribeReservedInstancesListingsResponse, NotUsed]
def describeReservedInstancesModificationsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeReservedInstancesModificationsRequest, DescribeReservedInstancesModificationsResponse, NotUsed]
def describeReservedInstancesModificationsPaginatorFlow: Flow[DescribeReservedInstancesModificationsRequest, DescribeReservedInstancesModificationsResponse, NotUsed]
def describeReservedInstancesModificationsPaginatorSource: Source[DescribeReservedInstancesModificationsResponse, NotUsed]
def describeReservedInstancesModificationsSource(): Source[DescribeReservedInstancesModificationsResponse, NotUsed]
def describeReservedInstancesModificationsSource(describeReservedInstancesModificationsRequest: DescribeReservedInstancesModificationsRequest, parallelism: Int = DefaultParallelism): Source[DescribeReservedInstancesModificationsResponse, NotUsed]
def describeReservedInstancesOfferingsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeReservedInstancesOfferingsRequest, DescribeReservedInstancesOfferingsResponse, NotUsed]
def describeReservedInstancesOfferingsPaginatorFlow: Flow[DescribeReservedInstancesOfferingsRequest, DescribeReservedInstancesOfferingsResponse, NotUsed]
def describeReservedInstancesOfferingsPaginatorSource: Source[DescribeReservedInstancesOfferingsResponse, NotUsed]
def describeReservedInstancesOfferingsSource(): Source[DescribeReservedInstancesOfferingsResponse, NotUsed]
def describeReservedInstancesOfferingsSource(describeReservedInstancesOfferingsRequest: DescribeReservedInstancesOfferingsRequest, parallelism: Int = DefaultParallelism): Source[DescribeReservedInstancesOfferingsResponse, NotUsed]
def describeReservedInstancesSource(): Source[DescribeReservedInstancesResponse, NotUsed]
def describeReservedInstancesSource(describeReservedInstancesRequest: DescribeReservedInstancesRequest, parallelism: Int = DefaultParallelism): Source[DescribeReservedInstancesResponse, NotUsed]
def describeRouteTablesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeRouteTablesRequest, DescribeRouteTablesResponse, NotUsed]
def describeRouteTablesPaginatorFlow: Flow[DescribeRouteTablesRequest, DescribeRouteTablesResponse, NotUsed]
def describeRouteTablesPaginatorSource: Source[DescribeRouteTablesResponse, NotUsed]
def describeRouteTablesSource(): Source[DescribeRouteTablesResponse, NotUsed]
def describeRouteTablesSource(describeRouteTablesRequest: DescribeRouteTablesRequest, parallelism: Int = DefaultParallelism): Source[DescribeRouteTablesResponse, NotUsed]
def describeScheduledInstanceAvailabilityFlow(parallelism: Int = DefaultParallelism): Flow[DescribeScheduledInstanceAvailabilityRequest, DescribeScheduledInstanceAvailabilityResponse, NotUsed]
def describeScheduledInstanceAvailabilityPaginatorFlow: Flow[DescribeScheduledInstanceAvailabilityRequest, DescribeScheduledInstanceAvailabilityResponse, NotUsed]
def describeScheduledInstanceAvailabilitySource(describeScheduledInstanceAvailabilityRequest: DescribeScheduledInstanceAvailabilityRequest, parallelism: Int = DefaultParallelism): Source[DescribeScheduledInstanceAvailabilityResponse, NotUsed]
def describeScheduledInstancesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeScheduledInstancesRequest, DescribeScheduledInstancesResponse, NotUsed]
def describeScheduledInstancesPaginatorFlow: Flow[DescribeScheduledInstancesRequest, DescribeScheduledInstancesResponse, NotUsed]
def describeScheduledInstancesPaginatorSource: Source[DescribeScheduledInstancesResponse, NotUsed]
def describeScheduledInstancesSource(): Source[DescribeScheduledInstancesResponse, NotUsed]
def describeScheduledInstancesSource(describeScheduledInstancesRequest: DescribeScheduledInstancesRequest, parallelism: Int = DefaultParallelism): Source[DescribeScheduledInstancesResponse, NotUsed]
def describeSecurityGroupReferencesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeSecurityGroupReferencesRequest, DescribeSecurityGroupReferencesResponse, NotUsed]
def describeSecurityGroupReferencesSource(describeSecurityGroupReferencesRequest: DescribeSecurityGroupReferencesRequest, parallelism: Int = DefaultParallelism): Source[DescribeSecurityGroupReferencesResponse, NotUsed]
def describeSecurityGroupsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeSecurityGroupsRequest, DescribeSecurityGroupsResponse, NotUsed]
def describeSecurityGroupsPaginatorFlow: Flow[DescribeSecurityGroupsRequest, DescribeSecurityGroupsResponse, NotUsed]
def describeSecurityGroupsPaginatorSource: Source[DescribeSecurityGroupsResponse, NotUsed]
def describeSecurityGroupsSource(): Source[DescribeSecurityGroupsResponse, NotUsed]
def describeSecurityGroupsSource(describeSecurityGroupsRequest: DescribeSecurityGroupsRequest, parallelism: Int = DefaultParallelism): Source[DescribeSecurityGroupsResponse, NotUsed]
def describeSnapshotAttributeFlow(parallelism: Int = DefaultParallelism): Flow[DescribeSnapshotAttributeRequest, DescribeSnapshotAttributeResponse, NotUsed]
def describeSnapshotAttributeSource(describeSnapshotAttributeRequest: DescribeSnapshotAttributeRequest, parallelism: Int = DefaultParallelism): Source[DescribeSnapshotAttributeResponse, NotUsed]
def describeSnapshotsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeSnapshotsRequest, DescribeSnapshotsResponse, NotUsed]
def describeSnapshotsPaginatorFlow: Flow[DescribeSnapshotsRequest, DescribeSnapshotsResponse, NotUsed]
def describeSnapshotsPaginatorSource: Source[DescribeSnapshotsResponse, NotUsed]
def describeSnapshotsSource(): Source[DescribeSnapshotsResponse, NotUsed]
def describeSnapshotsSource(describeSnapshotsRequest: DescribeSnapshotsRequest, parallelism: Int = DefaultParallelism): Source[DescribeSnapshotsResponse, NotUsed]
def describeSpotDatafeedSubscriptionFlow(parallelism: Int = DefaultParallelism): Flow[DescribeSpotDatafeedSubscriptionRequest, DescribeSpotDatafeedSubscriptionResponse, NotUsed]
def describeSpotDatafeedSubscriptionSource(): Source[DescribeSpotDatafeedSubscriptionResponse, NotUsed]
def describeSpotDatafeedSubscriptionSource(describeSpotDatafeedSubscriptionRequest: DescribeSpotDatafeedSubscriptionRequest, parallelism: Int = DefaultParallelism): Source[DescribeSpotDatafeedSubscriptionResponse, NotUsed]
def describeSpotFleetInstancesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeSpotFleetInstancesRequest, DescribeSpotFleetInstancesResponse, NotUsed]
def describeSpotFleetInstancesSource(describeSpotFleetInstancesRequest: DescribeSpotFleetInstancesRequest, parallelism: Int = DefaultParallelism): Source[DescribeSpotFleetInstancesResponse, NotUsed]
def describeSpotFleetRequestHistoryFlow(parallelism: Int = DefaultParallelism): Flow[DescribeSpotFleetRequestHistoryRequest, DescribeSpotFleetRequestHistoryResponse, NotUsed]
def describeSpotFleetRequestHistorySource(describeSpotFleetRequestHistoryRequest: DescribeSpotFleetRequestHistoryRequest, parallelism: Int = DefaultParallelism): Source[DescribeSpotFleetRequestHistoryResponse, NotUsed]
def describeSpotFleetRequestsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeSpotFleetRequestsRequest, DescribeSpotFleetRequestsResponse, NotUsed]
def describeSpotFleetRequestsPaginatorFlow: Flow[DescribeSpotFleetRequestsRequest, DescribeSpotFleetRequestsResponse, NotUsed]
def describeSpotFleetRequestsPaginatorSource: Source[DescribeSpotFleetRequestsResponse, NotUsed]
def describeSpotFleetRequestsSource(): Source[DescribeSpotFleetRequestsResponse, NotUsed]
def describeSpotFleetRequestsSource(describeSpotFleetRequestsRequest: DescribeSpotFleetRequestsRequest, parallelism: Int = DefaultParallelism): Source[DescribeSpotFleetRequestsResponse, NotUsed]
def describeSpotInstanceRequestsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeSpotInstanceRequestsRequest, DescribeSpotInstanceRequestsResponse, NotUsed]
def describeSpotInstanceRequestsPaginatorFlow: Flow[DescribeSpotInstanceRequestsRequest, DescribeSpotInstanceRequestsResponse, NotUsed]
def describeSpotInstanceRequestsPaginatorSource: Source[DescribeSpotInstanceRequestsResponse, NotUsed]
def describeSpotInstanceRequestsSource(): Source[DescribeSpotInstanceRequestsResponse, NotUsed]
def describeSpotInstanceRequestsSource(describeSpotInstanceRequestsRequest: DescribeSpotInstanceRequestsRequest, parallelism: Int = DefaultParallelism): Source[DescribeSpotInstanceRequestsResponse, NotUsed]
def describeSpotPriceHistoryFlow(parallelism: Int = DefaultParallelism): Flow[DescribeSpotPriceHistoryRequest, DescribeSpotPriceHistoryResponse, NotUsed]
def describeSpotPriceHistoryPaginatorFlow: Flow[DescribeSpotPriceHistoryRequest, DescribeSpotPriceHistoryResponse, NotUsed]
def describeSpotPriceHistoryPaginatorSource: Source[DescribeSpotPriceHistoryResponse, NotUsed]
def describeSpotPriceHistorySource(): Source[DescribeSpotPriceHistoryResponse, NotUsed]
def describeSpotPriceHistorySource(describeSpotPriceHistoryRequest: DescribeSpotPriceHistoryRequest, parallelism: Int = DefaultParallelism): Source[DescribeSpotPriceHistoryResponse, NotUsed]
def describeStaleSecurityGroupsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeStaleSecurityGroupsRequest, DescribeStaleSecurityGroupsResponse, NotUsed]
def describeStaleSecurityGroupsPaginatorFlow: Flow[DescribeStaleSecurityGroupsRequest, DescribeStaleSecurityGroupsResponse, NotUsed]
def describeStaleSecurityGroupsSource(describeStaleSecurityGroupsRequest: DescribeStaleSecurityGroupsRequest, parallelism: Int = DefaultParallelism): Source[DescribeStaleSecurityGroupsResponse, NotUsed]
def describeSubnetsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeSubnetsRequest, DescribeSubnetsResponse, NotUsed]
def describeSubnetsPaginatorFlow: Flow[DescribeSubnetsRequest, DescribeSubnetsResponse, NotUsed]
def describeSubnetsPaginatorSource: Source[DescribeSubnetsResponse, NotUsed]
def describeSubnetsSource(): Source[DescribeSubnetsResponse, NotUsed]
def describeSubnetsSource(describeSubnetsRequest: DescribeSubnetsRequest, parallelism: Int = DefaultParallelism): Source[DescribeSubnetsResponse, NotUsed]
def describeTagsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeTagsRequest, DescribeTagsResponse, NotUsed]
def describeTagsPaginatorFlow: Flow[DescribeTagsRequest, DescribeTagsResponse, NotUsed]
def describeTagsPaginatorSource: Source[DescribeTagsResponse, NotUsed]
def describeTagsSource(): Source[DescribeTagsResponse, NotUsed]
def describeTagsSource(describeTagsRequest: DescribeTagsRequest, parallelism: Int = DefaultParallelism): Source[DescribeTagsResponse, NotUsed]
def describeTrafficMirrorFiltersFlow(parallelism: Int = DefaultParallelism): Flow[DescribeTrafficMirrorFiltersRequest, DescribeTrafficMirrorFiltersResponse, NotUsed]
def describeTrafficMirrorFiltersPaginatorFlow: Flow[DescribeTrafficMirrorFiltersRequest, DescribeTrafficMirrorFiltersResponse, NotUsed]
def describeTrafficMirrorFiltersSource(describeTrafficMirrorFiltersRequest: DescribeTrafficMirrorFiltersRequest, parallelism: Int = DefaultParallelism): Source[DescribeTrafficMirrorFiltersResponse, NotUsed]
def describeTrafficMirrorSessionsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeTrafficMirrorSessionsRequest, DescribeTrafficMirrorSessionsResponse, NotUsed]
def describeTrafficMirrorSessionsPaginatorFlow: Flow[DescribeTrafficMirrorSessionsRequest, DescribeTrafficMirrorSessionsResponse, NotUsed]
def describeTrafficMirrorSessionsSource(describeTrafficMirrorSessionsRequest: DescribeTrafficMirrorSessionsRequest, parallelism: Int = DefaultParallelism): Source[DescribeTrafficMirrorSessionsResponse, NotUsed]
def describeTrafficMirrorTargetsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeTrafficMirrorTargetsRequest, DescribeTrafficMirrorTargetsResponse, NotUsed]
def describeTrafficMirrorTargetsPaginatorFlow: Flow[DescribeTrafficMirrorTargetsRequest, DescribeTrafficMirrorTargetsResponse, NotUsed]
def describeTrafficMirrorTargetsSource(describeTrafficMirrorTargetsRequest: DescribeTrafficMirrorTargetsRequest, parallelism: Int = DefaultParallelism): Source[DescribeTrafficMirrorTargetsResponse, NotUsed]
def describeTransitGatewayAttachmentsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeTransitGatewayAttachmentsRequest, DescribeTransitGatewayAttachmentsResponse, NotUsed]
def describeTransitGatewayAttachmentsPaginatorFlow: Flow[DescribeTransitGatewayAttachmentsRequest, DescribeTransitGatewayAttachmentsResponse, NotUsed]
def describeTransitGatewayAttachmentsPaginatorSource: Source[DescribeTransitGatewayAttachmentsResponse, NotUsed]
def describeTransitGatewayAttachmentsSource(): Source[DescribeTransitGatewayAttachmentsResponse, NotUsed]
def describeTransitGatewayAttachmentsSource(describeTransitGatewayAttachmentsRequest: DescribeTransitGatewayAttachmentsRequest, parallelism: Int = DefaultParallelism): Source[DescribeTransitGatewayAttachmentsResponse, NotUsed]
def describeTransitGatewayMulticastDomainsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeTransitGatewayMulticastDomainsRequest, DescribeTransitGatewayMulticastDomainsResponse, NotUsed]
def describeTransitGatewayMulticastDomainsSource(describeTransitGatewayMulticastDomainsRequest: DescribeTransitGatewayMulticastDomainsRequest, parallelism: Int = DefaultParallelism): Source[DescribeTransitGatewayMulticastDomainsResponse, NotUsed]
def describeTransitGatewayPeeringAttachmentsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeTransitGatewayPeeringAttachmentsRequest, DescribeTransitGatewayPeeringAttachmentsResponse, NotUsed]
def describeTransitGatewayPeeringAttachmentsSource(describeTransitGatewayPeeringAttachmentsRequest: DescribeTransitGatewayPeeringAttachmentsRequest, parallelism: Int = DefaultParallelism): Source[DescribeTransitGatewayPeeringAttachmentsResponse, NotUsed]
def describeTransitGatewayRouteTablesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeTransitGatewayRouteTablesRequest, DescribeTransitGatewayRouteTablesResponse, NotUsed]
def describeTransitGatewayRouteTablesPaginatorFlow: Flow[DescribeTransitGatewayRouteTablesRequest, DescribeTransitGatewayRouteTablesResponse, NotUsed]
def describeTransitGatewayRouteTablesPaginatorSource: Source[DescribeTransitGatewayRouteTablesResponse, NotUsed]
def describeTransitGatewayRouteTablesSource(): Source[DescribeTransitGatewayRouteTablesResponse, NotUsed]
def describeTransitGatewayRouteTablesSource(describeTransitGatewayRouteTablesRequest: DescribeTransitGatewayRouteTablesRequest, parallelism: Int = DefaultParallelism): Source[DescribeTransitGatewayRouteTablesResponse, NotUsed]
def describeTransitGatewayVpcAttachmentsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeTransitGatewayVpcAttachmentsRequest, DescribeTransitGatewayVpcAttachmentsResponse, NotUsed]
def describeTransitGatewayVpcAttachmentsPaginatorFlow: Flow[DescribeTransitGatewayVpcAttachmentsRequest, DescribeTransitGatewayVpcAttachmentsResponse, NotUsed]
def describeTransitGatewayVpcAttachmentsPaginatorSource: Source[DescribeTransitGatewayVpcAttachmentsResponse, NotUsed]
def describeTransitGatewayVpcAttachmentsSource(): Source[DescribeTransitGatewayVpcAttachmentsResponse, NotUsed]
def describeTransitGatewayVpcAttachmentsSource(describeTransitGatewayVpcAttachmentsRequest: DescribeTransitGatewayVpcAttachmentsRequest, parallelism: Int = DefaultParallelism): Source[DescribeTransitGatewayVpcAttachmentsResponse, NotUsed]
def describeTransitGatewaysFlow(parallelism: Int = DefaultParallelism): Flow[DescribeTransitGatewaysRequest, DescribeTransitGatewaysResponse, NotUsed]
def describeTransitGatewaysPaginatorFlow: Flow[DescribeTransitGatewaysRequest, DescribeTransitGatewaysResponse, NotUsed]
def describeTransitGatewaysPaginatorSource: Source[DescribeTransitGatewaysResponse, NotUsed]
def describeTransitGatewaysSource(): Source[DescribeTransitGatewaysResponse, NotUsed]
def describeTransitGatewaysSource(describeTransitGatewaysRequest: DescribeTransitGatewaysRequest, parallelism: Int = DefaultParallelism): Source[DescribeTransitGatewaysResponse, NotUsed]
def describeVolumeAttributeFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVolumeAttributeRequest, DescribeVolumeAttributeResponse, NotUsed]
def describeVolumeAttributeSource(describeVolumeAttributeRequest: DescribeVolumeAttributeRequest, parallelism: Int = DefaultParallelism): Source[DescribeVolumeAttributeResponse, NotUsed]
def describeVolumeStatusFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVolumeStatusRequest, DescribeVolumeStatusResponse, NotUsed]
def describeVolumeStatusPaginatorFlow: Flow[DescribeVolumeStatusRequest, DescribeVolumeStatusResponse, NotUsed]
def describeVolumeStatusPaginatorSource: Source[DescribeVolumeStatusResponse, NotUsed]
def describeVolumeStatusSource(): Source[DescribeVolumeStatusResponse, NotUsed]
def describeVolumeStatusSource(describeVolumeStatusRequest: DescribeVolumeStatusRequest, parallelism: Int = DefaultParallelism): Source[DescribeVolumeStatusResponse, NotUsed]
def describeVolumesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVolumesRequest, DescribeVolumesResponse, NotUsed]
def describeVolumesModificationsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVolumesModificationsRequest, DescribeVolumesModificationsResponse, NotUsed]
def describeVolumesModificationsPaginatorFlow: Flow[DescribeVolumesModificationsRequest, DescribeVolumesModificationsResponse, NotUsed]
def describeVolumesModificationsPaginatorSource: Source[DescribeVolumesModificationsResponse, NotUsed]
def describeVolumesModificationsSource(): Source[DescribeVolumesModificationsResponse, NotUsed]
def describeVolumesModificationsSource(describeVolumesModificationsRequest: DescribeVolumesModificationsRequest, parallelism: Int = DefaultParallelism): Source[DescribeVolumesModificationsResponse, NotUsed]
def describeVolumesPaginatorFlow: Flow[DescribeVolumesRequest, DescribeVolumesResponse, NotUsed]
def describeVolumesPaginatorSource: Source[DescribeVolumesResponse, NotUsed]
def describeVolumesSource(): Source[DescribeVolumesResponse, NotUsed]
def describeVolumesSource(describeVolumesRequest: DescribeVolumesRequest, parallelism: Int = DefaultParallelism): Source[DescribeVolumesResponse, NotUsed]
def describeVpcAttributeFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVpcAttributeRequest, DescribeVpcAttributeResponse, NotUsed]
def describeVpcAttributeSource(describeVpcAttributeRequest: DescribeVpcAttributeRequest, parallelism: Int = DefaultParallelism): Source[DescribeVpcAttributeResponse, NotUsed]
def describeVpcClassicLinkDnsSupportFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVpcClassicLinkDnsSupportRequest, DescribeVpcClassicLinkDnsSupportResponse, NotUsed]
def describeVpcClassicLinkDnsSupportPaginatorFlow: Flow[DescribeVpcClassicLinkDnsSupportRequest, DescribeVpcClassicLinkDnsSupportResponse, NotUsed]
def describeVpcClassicLinkDnsSupportPaginatorSource: Source[DescribeVpcClassicLinkDnsSupportResponse, NotUsed]
def describeVpcClassicLinkDnsSupportSource(): Source[DescribeVpcClassicLinkDnsSupportResponse, NotUsed]
def describeVpcClassicLinkDnsSupportSource(describeVpcClassicLinkDnsSupportRequest: DescribeVpcClassicLinkDnsSupportRequest, parallelism: Int = DefaultParallelism): Source[DescribeVpcClassicLinkDnsSupportResponse, NotUsed]
def describeVpcClassicLinkFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVpcClassicLinkRequest, DescribeVpcClassicLinkResponse, NotUsed]
def describeVpcClassicLinkSource(): Source[DescribeVpcClassicLinkResponse, NotUsed]
def describeVpcClassicLinkSource(describeVpcClassicLinkRequest: DescribeVpcClassicLinkRequest, parallelism: Int = DefaultParallelism): Source[DescribeVpcClassicLinkResponse, NotUsed]
def describeVpcEndpointConnectionNotificationsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVpcEndpointConnectionNotificationsRequest, DescribeVpcEndpointConnectionNotificationsResponse, NotUsed]
def describeVpcEndpointConnectionNotificationsPaginatorFlow: Flow[DescribeVpcEndpointConnectionNotificationsRequest, DescribeVpcEndpointConnectionNotificationsResponse, NotUsed]
def describeVpcEndpointConnectionNotificationsPaginatorSource: Source[DescribeVpcEndpointConnectionNotificationsResponse, NotUsed]
def describeVpcEndpointConnectionNotificationsSource(): Source[DescribeVpcEndpointConnectionNotificationsResponse, NotUsed]
def describeVpcEndpointConnectionNotificationsSource(describeVpcEndpointConnectionNotificationsRequest: DescribeVpcEndpointConnectionNotificationsRequest, parallelism: Int = DefaultParallelism): Source[DescribeVpcEndpointConnectionNotificationsResponse, NotUsed]
def describeVpcEndpointConnectionsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVpcEndpointConnectionsRequest, DescribeVpcEndpointConnectionsResponse, NotUsed]
def describeVpcEndpointConnectionsPaginatorFlow: Flow[DescribeVpcEndpointConnectionsRequest, DescribeVpcEndpointConnectionsResponse, NotUsed]
def describeVpcEndpointConnectionsPaginatorSource: Source[DescribeVpcEndpointConnectionsResponse, NotUsed]
def describeVpcEndpointConnectionsSource(): Source[DescribeVpcEndpointConnectionsResponse, NotUsed]
def describeVpcEndpointConnectionsSource(describeVpcEndpointConnectionsRequest: DescribeVpcEndpointConnectionsRequest, parallelism: Int = DefaultParallelism): Source[DescribeVpcEndpointConnectionsResponse, NotUsed]
def describeVpcEndpointServiceConfigurationsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVpcEndpointServiceConfigurationsRequest, DescribeVpcEndpointServiceConfigurationsResponse, NotUsed]
def describeVpcEndpointServiceConfigurationsPaginatorFlow: Flow[DescribeVpcEndpointServiceConfigurationsRequest, DescribeVpcEndpointServiceConfigurationsResponse, NotUsed]
def describeVpcEndpointServiceConfigurationsPaginatorSource: Source[DescribeVpcEndpointServiceConfigurationsResponse, NotUsed]
def describeVpcEndpointServiceConfigurationsSource(): Source[DescribeVpcEndpointServiceConfigurationsResponse, NotUsed]
def describeVpcEndpointServiceConfigurationsSource(describeVpcEndpointServiceConfigurationsRequest: DescribeVpcEndpointServiceConfigurationsRequest, parallelism: Int = DefaultParallelism): Source[DescribeVpcEndpointServiceConfigurationsResponse, NotUsed]
def describeVpcEndpointServicePermissionsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVpcEndpointServicePermissionsRequest, DescribeVpcEndpointServicePermissionsResponse, NotUsed]
def describeVpcEndpointServicePermissionsPaginatorFlow: Flow[DescribeVpcEndpointServicePermissionsRequest, DescribeVpcEndpointServicePermissionsResponse, NotUsed]
def describeVpcEndpointServicePermissionsSource(describeVpcEndpointServicePermissionsRequest: DescribeVpcEndpointServicePermissionsRequest, parallelism: Int = DefaultParallelism): Source[DescribeVpcEndpointServicePermissionsResponse, NotUsed]
def describeVpcEndpointServicesFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVpcEndpointServicesRequest, DescribeVpcEndpointServicesResponse, NotUsed]
def describeVpcEndpointServicesSource(): Source[DescribeVpcEndpointServicesResponse, NotUsed]
def describeVpcEndpointServicesSource(describeVpcEndpointServicesRequest: DescribeVpcEndpointServicesRequest, parallelism: Int = DefaultParallelism): Source[DescribeVpcEndpointServicesResponse, NotUsed]
def describeVpcEndpointsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVpcEndpointsRequest, DescribeVpcEndpointsResponse, NotUsed]
def describeVpcEndpointsPaginatorFlow: Flow[DescribeVpcEndpointsRequest, DescribeVpcEndpointsResponse, NotUsed]
def describeVpcEndpointsPaginatorSource: Source[DescribeVpcEndpointsResponse, NotUsed]
def describeVpcEndpointsSource(): Source[DescribeVpcEndpointsResponse, NotUsed]
def describeVpcEndpointsSource(describeVpcEndpointsRequest: DescribeVpcEndpointsRequest, parallelism: Int = DefaultParallelism): Source[DescribeVpcEndpointsResponse, NotUsed]
def describeVpcPeeringConnectionsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVpcPeeringConnectionsRequest, DescribeVpcPeeringConnectionsResponse, NotUsed]
def describeVpcPeeringConnectionsPaginatorFlow: Flow[DescribeVpcPeeringConnectionsRequest, DescribeVpcPeeringConnectionsResponse, NotUsed]
def describeVpcPeeringConnectionsPaginatorSource: Source[DescribeVpcPeeringConnectionsResponse, NotUsed]
def describeVpcPeeringConnectionsSource(): Source[DescribeVpcPeeringConnectionsResponse, NotUsed]
def describeVpcPeeringConnectionsSource(describeVpcPeeringConnectionsRequest: DescribeVpcPeeringConnectionsRequest, parallelism: Int = DefaultParallelism): Source[DescribeVpcPeeringConnectionsResponse, NotUsed]
def describeVpcsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVpcsRequest, DescribeVpcsResponse, NotUsed]
def describeVpcsPaginatorFlow: Flow[DescribeVpcsRequest, DescribeVpcsResponse, NotUsed]
def describeVpcsPaginatorSource: Source[DescribeVpcsResponse, NotUsed]
def describeVpcsSource(): Source[DescribeVpcsResponse, NotUsed]
def describeVpcsSource(describeVpcsRequest: DescribeVpcsRequest, parallelism: Int = DefaultParallelism): Source[DescribeVpcsResponse, NotUsed]
def describeVpnConnectionsFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVpnConnectionsRequest, DescribeVpnConnectionsResponse, NotUsed]
def describeVpnConnectionsSource(): Source[DescribeVpnConnectionsResponse, NotUsed]
def describeVpnConnectionsSource(describeVpnConnectionsRequest: DescribeVpnConnectionsRequest, parallelism: Int = DefaultParallelism): Source[DescribeVpnConnectionsResponse, NotUsed]
def describeVpnGatewaysFlow(parallelism: Int = DefaultParallelism): Flow[DescribeVpnGatewaysRequest, DescribeVpnGatewaysResponse, NotUsed]
def describeVpnGatewaysSource(): Source[DescribeVpnGatewaysResponse, NotUsed]
def describeVpnGatewaysSource(describeVpnGatewaysRequest: DescribeVpnGatewaysRequest, parallelism: Int = DefaultParallelism): Source[DescribeVpnGatewaysResponse, NotUsed]
def detachClassicLinkVpcFlow(parallelism: Int = DefaultParallelism): Flow[DetachClassicLinkVpcRequest, DetachClassicLinkVpcResponse, NotUsed]
def detachClassicLinkVpcSource(detachClassicLinkVpcRequest: DetachClassicLinkVpcRequest, parallelism: Int = DefaultParallelism): Source[DetachClassicLinkVpcResponse, NotUsed]
def detachInternetGatewayFlow(parallelism: Int = DefaultParallelism): Flow[DetachInternetGatewayRequest, DetachInternetGatewayResponse, NotUsed]
def detachInternetGatewaySource(detachInternetGatewayRequest: DetachInternetGatewayRequest, parallelism: Int = DefaultParallelism): Source[DetachInternetGatewayResponse, NotUsed]
def detachNetworkInterfaceFlow(parallelism: Int = DefaultParallelism): Flow[DetachNetworkInterfaceRequest, DetachNetworkInterfaceResponse, NotUsed]
def detachNetworkInterfaceSource(detachNetworkInterfaceRequest: DetachNetworkInterfaceRequest, parallelism: Int = DefaultParallelism): Source[DetachNetworkInterfaceResponse, NotUsed]
def detachVolumeFlow(parallelism: Int = DefaultParallelism): Flow[DetachVolumeRequest, DetachVolumeResponse, NotUsed]
def detachVolumeSource(detachVolumeRequest: DetachVolumeRequest, parallelism: Int = DefaultParallelism): Source[DetachVolumeResponse, NotUsed]
def detachVpnGatewayFlow(parallelism: Int = DefaultParallelism): Flow[DetachVpnGatewayRequest, DetachVpnGatewayResponse, NotUsed]
def detachVpnGatewaySource(detachVpnGatewayRequest: DetachVpnGatewayRequest, parallelism: Int = DefaultParallelism): Source[DetachVpnGatewayResponse, NotUsed]
def disableEbsEncryptionByDefaultFlow(parallelism: Int = DefaultParallelism): Flow[DisableEbsEncryptionByDefaultRequest, DisableEbsEncryptionByDefaultResponse, NotUsed]
def disableEbsEncryptionByDefaultSource(disableEbsEncryptionByDefaultRequest: DisableEbsEncryptionByDefaultRequest, parallelism: Int = DefaultParallelism): Source[DisableEbsEncryptionByDefaultResponse, NotUsed]
def disableFastSnapshotRestoresFlow(parallelism: Int = DefaultParallelism): Flow[DisableFastSnapshotRestoresRequest, DisableFastSnapshotRestoresResponse, NotUsed]
def disableFastSnapshotRestoresSource(disableFastSnapshotRestoresRequest: DisableFastSnapshotRestoresRequest, parallelism: Int = DefaultParallelism): Source[DisableFastSnapshotRestoresResponse, NotUsed]
def disableTransitGatewayRouteTablePropagationFlow(parallelism: Int = DefaultParallelism): Flow[DisableTransitGatewayRouteTablePropagationRequest, DisableTransitGatewayRouteTablePropagationResponse, NotUsed]
def disableTransitGatewayRouteTablePropagationSource(disableTransitGatewayRouteTablePropagationRequest: DisableTransitGatewayRouteTablePropagationRequest, parallelism: Int = DefaultParallelism): Source[DisableTransitGatewayRouteTablePropagationResponse, NotUsed]
def disableVgwRoutePropagationFlow(parallelism: Int = DefaultParallelism): Flow[DisableVgwRoutePropagationRequest, DisableVgwRoutePropagationResponse, NotUsed]
def disableVgwRoutePropagationSource(disableVgwRoutePropagationRequest: DisableVgwRoutePropagationRequest, parallelism: Int = DefaultParallelism): Source[DisableVgwRoutePropagationResponse, NotUsed]
def disableVpcClassicLinkDnsSupportFlow(parallelism: Int = DefaultParallelism): Flow[DisableVpcClassicLinkDnsSupportRequest, DisableVpcClassicLinkDnsSupportResponse, NotUsed]
def disableVpcClassicLinkDnsSupportSource(disableVpcClassicLinkDnsSupportRequest: DisableVpcClassicLinkDnsSupportRequest, parallelism: Int = DefaultParallelism): Source[DisableVpcClassicLinkDnsSupportResponse, NotUsed]
def disableVpcClassicLinkFlow(parallelism: Int = DefaultParallelism): Flow[DisableVpcClassicLinkRequest, DisableVpcClassicLinkResponse, NotUsed]
def disableVpcClassicLinkSource(disableVpcClassicLinkRequest: DisableVpcClassicLinkRequest, parallelism: Int = DefaultParallelism): Source[DisableVpcClassicLinkResponse, NotUsed]
def disassociateAddressFlow(parallelism: Int = DefaultParallelism): Flow[DisassociateAddressRequest, DisassociateAddressResponse, NotUsed]
def disassociateAddressSource(disassociateAddressRequest: DisassociateAddressRequest, parallelism: Int = DefaultParallelism): Source[DisassociateAddressResponse, NotUsed]
def disassociateClientVpnTargetNetworkFlow(parallelism: Int = DefaultParallelism): Flow[DisassociateClientVpnTargetNetworkRequest, DisassociateClientVpnTargetNetworkResponse, NotUsed]
def disassociateClientVpnTargetNetworkSource(disassociateClientVpnTargetNetworkRequest: DisassociateClientVpnTargetNetworkRequest, parallelism: Int = DefaultParallelism): Source[DisassociateClientVpnTargetNetworkResponse, NotUsed]
def disassociateIamInstanceProfileFlow(parallelism: Int = DefaultParallelism): Flow[DisassociateIamInstanceProfileRequest, DisassociateIamInstanceProfileResponse, NotUsed]
def disassociateIamInstanceProfileSource(disassociateIamInstanceProfileRequest: DisassociateIamInstanceProfileRequest, parallelism: Int = DefaultParallelism): Source[DisassociateIamInstanceProfileResponse, NotUsed]
def disassociateRouteTableFlow(parallelism: Int = DefaultParallelism): Flow[DisassociateRouteTableRequest, DisassociateRouteTableResponse, NotUsed]
def disassociateRouteTableSource(disassociateRouteTableRequest: DisassociateRouteTableRequest, parallelism: Int = DefaultParallelism): Source[DisassociateRouteTableResponse, NotUsed]
def disassociateSubnetCidrBlockFlow(parallelism: Int = DefaultParallelism): Flow[DisassociateSubnetCidrBlockRequest, DisassociateSubnetCidrBlockResponse, NotUsed]
def disassociateSubnetCidrBlockSource(disassociateSubnetCidrBlockRequest: DisassociateSubnetCidrBlockRequest, parallelism: Int = DefaultParallelism): Source[DisassociateSubnetCidrBlockResponse, NotUsed]
def disassociateTransitGatewayMulticastDomainFlow(parallelism: Int = DefaultParallelism): Flow[DisassociateTransitGatewayMulticastDomainRequest, DisassociateTransitGatewayMulticastDomainResponse, NotUsed]
def disassociateTransitGatewayMulticastDomainSource(disassociateTransitGatewayMulticastDomainRequest: DisassociateTransitGatewayMulticastDomainRequest, parallelism: Int = DefaultParallelism): Source[DisassociateTransitGatewayMulticastDomainResponse, NotUsed]
def disassociateTransitGatewayRouteTableFlow(parallelism: Int = DefaultParallelism): Flow[DisassociateTransitGatewayRouteTableRequest, DisassociateTransitGatewayRouteTableResponse, NotUsed]
def disassociateTransitGatewayRouteTableSource(disassociateTransitGatewayRouteTableRequest: DisassociateTransitGatewayRouteTableRequest, parallelism: Int = DefaultParallelism): Source[DisassociateTransitGatewayRouteTableResponse, NotUsed]
def disassociateVpcCidrBlockFlow(parallelism: Int = DefaultParallelism): Flow[DisassociateVpcCidrBlockRequest, DisassociateVpcCidrBlockResponse, NotUsed]
def disassociateVpcCidrBlockSource(disassociateVpcCidrBlockRequest: DisassociateVpcCidrBlockRequest, parallelism: Int = DefaultParallelism): Source[DisassociateVpcCidrBlockResponse, NotUsed]
def enableEbsEncryptionByDefaultFlow(parallelism: Int = DefaultParallelism): Flow[EnableEbsEncryptionByDefaultRequest, EnableEbsEncryptionByDefaultResponse, NotUsed]
def enableEbsEncryptionByDefaultSource(enableEbsEncryptionByDefaultRequest: EnableEbsEncryptionByDefaultRequest, parallelism: Int = DefaultParallelism): Source[EnableEbsEncryptionByDefaultResponse, NotUsed]
def enableFastSnapshotRestoresFlow(parallelism: Int = DefaultParallelism): Flow[EnableFastSnapshotRestoresRequest, EnableFastSnapshotRestoresResponse, NotUsed]
def enableFastSnapshotRestoresSource(enableFastSnapshotRestoresRequest: EnableFastSnapshotRestoresRequest, parallelism: Int = DefaultParallelism): Source[EnableFastSnapshotRestoresResponse, NotUsed]
def enableTransitGatewayRouteTablePropagationFlow(parallelism: Int = DefaultParallelism): Flow[EnableTransitGatewayRouteTablePropagationRequest, EnableTransitGatewayRouteTablePropagationResponse, NotUsed]
def enableTransitGatewayRouteTablePropagationSource(enableTransitGatewayRouteTablePropagationRequest: EnableTransitGatewayRouteTablePropagationRequest, parallelism: Int = DefaultParallelism): Source[EnableTransitGatewayRouteTablePropagationResponse, NotUsed]
def enableVgwRoutePropagationFlow(parallelism: Int = DefaultParallelism): Flow[EnableVgwRoutePropagationRequest, EnableVgwRoutePropagationResponse, NotUsed]
def enableVgwRoutePropagationSource(enableVgwRoutePropagationRequest: EnableVgwRoutePropagationRequest, parallelism: Int = DefaultParallelism): Source[EnableVgwRoutePropagationResponse, NotUsed]
def enableVolumeIOFlow(parallelism: Int = DefaultParallelism): Flow[EnableVolumeIoRequest, EnableVolumeIOResponse, NotUsed]
def enableVolumeIOSource(enableVolumeIoRequest: EnableVolumeIoRequest, parallelism: Int = DefaultParallelism): Source[EnableVolumeIOResponse, NotUsed]
def enableVpcClassicLinkDnsSupportFlow(parallelism: Int = DefaultParallelism): Flow[EnableVpcClassicLinkDnsSupportRequest, EnableVpcClassicLinkDnsSupportResponse, NotUsed]
def enableVpcClassicLinkDnsSupportSource(enableVpcClassicLinkDnsSupportRequest: EnableVpcClassicLinkDnsSupportRequest, parallelism: Int = DefaultParallelism): Source[EnableVpcClassicLinkDnsSupportResponse, NotUsed]
def enableVpcClassicLinkFlow(parallelism: Int = DefaultParallelism): Flow[EnableVpcClassicLinkRequest, EnableVpcClassicLinkResponse, NotUsed]
def enableVpcClassicLinkSource(enableVpcClassicLinkRequest: EnableVpcClassicLinkRequest, parallelism: Int = DefaultParallelism): Source[EnableVpcClassicLinkResponse, NotUsed]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exportClientVpnClientCertificateRevocationListFlow(parallelism: Int = DefaultParallelism): Flow[ExportClientVpnClientCertificateRevocationListRequest, ExportClientVpnClientCertificateRevocationListResponse, NotUsed]
def exportClientVpnClientCertificateRevocationListSource(exportClientVpnClientCertificateRevocationListRequest: ExportClientVpnClientCertificateRevocationListRequest, parallelism: Int = DefaultParallelism): Source[ExportClientVpnClientCertificateRevocationListResponse, NotUsed]
def exportClientVpnClientConfigurationFlow(parallelism: Int = DefaultParallelism): Flow[ExportClientVpnClientConfigurationRequest, ExportClientVpnClientConfigurationResponse, NotUsed]
def exportClientVpnClientConfigurationSource(exportClientVpnClientConfigurationRequest: ExportClientVpnClientConfigurationRequest, parallelism: Int = DefaultParallelism): Source[ExportClientVpnClientConfigurationResponse, NotUsed]
def exportImageFlow(parallelism: Int = DefaultParallelism): Flow[ExportImageRequest, ExportImageResponse, NotUsed]
def exportImageSource(exportImageRequest: ExportImageRequest, parallelism: Int = DefaultParallelism): Source[ExportImageResponse, NotUsed]
def exportTransitGatewayRoutesFlow(parallelism: Int = DefaultParallelism): Flow[ExportTransitGatewayRoutesRequest, ExportTransitGatewayRoutesResponse, NotUsed]
def exportTransitGatewayRoutesSource(exportTransitGatewayRoutesRequest: ExportTransitGatewayRoutesRequest, parallelism: Int = DefaultParallelism): Source[ExportTransitGatewayRoutesResponse, NotUsed]
def getAssociatedIpv6PoolCidrsFlow(parallelism: Int = DefaultParallelism): Flow[GetAssociatedIpv6PoolCidrsRequest, GetAssociatedIpv6PoolCidrsResponse, NotUsed]
def getAssociatedIpv6PoolCidrsPaginatorFlow: Flow[GetAssociatedIpv6PoolCidrsRequest, GetAssociatedIpv6PoolCidrsResponse, NotUsed]
def getAssociatedIpv6PoolCidrsSource(getAssociatedIpv6PoolCidrsRequest: GetAssociatedIpv6PoolCidrsRequest, parallelism: Int = DefaultParallelism): Source[GetAssociatedIpv6PoolCidrsResponse, NotUsed]
def getCapacityReservationUsageFlow(parallelism: Int = DefaultParallelism): Flow[GetCapacityReservationUsageRequest, GetCapacityReservationUsageResponse, NotUsed]
def getCapacityReservationUsageSource(getCapacityReservationUsageRequest: GetCapacityReservationUsageRequest, parallelism: Int = DefaultParallelism): Source[GetCapacityReservationUsageResponse, NotUsed]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def getCoipPoolUsageFlow(parallelism: Int = DefaultParallelism): Flow[GetCoipPoolUsageRequest, GetCoipPoolUsageResponse, NotUsed]
def getCoipPoolUsageSource(getCoipPoolUsageRequest: GetCoipPoolUsageRequest, parallelism: Int = DefaultParallelism): Source[GetCoipPoolUsageResponse, NotUsed]
def getConsoleOutputFlow(parallelism: Int = DefaultParallelism): Flow[GetConsoleOutputRequest, GetConsoleOutputResponse, NotUsed]
def getConsoleOutputSource(getConsoleOutputRequest: GetConsoleOutputRequest, parallelism: Int = DefaultParallelism): Source[GetConsoleOutputResponse, NotUsed]
def getConsoleScreenshotFlow(parallelism: Int = DefaultParallelism): Flow[GetConsoleScreenshotRequest, GetConsoleScreenshotResponse, NotUsed]
def getConsoleScreenshotSource(getConsoleScreenshotRequest: GetConsoleScreenshotRequest, parallelism: Int = DefaultParallelism): Source[GetConsoleScreenshotResponse, NotUsed]
def getDefaultCreditSpecificationFlow(parallelism: Int = DefaultParallelism): Flow[GetDefaultCreditSpecificationRequest, GetDefaultCreditSpecificationResponse, NotUsed]
def getDefaultCreditSpecificationSource(getDefaultCreditSpecificationRequest: GetDefaultCreditSpecificationRequest, parallelism: Int = DefaultParallelism): Source[GetDefaultCreditSpecificationResponse, NotUsed]
def getEbsDefaultKmsKeyIdFlow(parallelism: Int = DefaultParallelism): Flow[GetEbsDefaultKmsKeyIdRequest, GetEbsDefaultKmsKeyIdResponse, NotUsed]
def getEbsDefaultKmsKeyIdSource(getEbsDefaultKmsKeyIdRequest: GetEbsDefaultKmsKeyIdRequest, parallelism: Int = DefaultParallelism): Source[GetEbsDefaultKmsKeyIdResponse, NotUsed]
def getEbsEncryptionByDefaultFlow(parallelism: Int = DefaultParallelism): Flow[GetEbsEncryptionByDefaultRequest, GetEbsEncryptionByDefaultResponse, NotUsed]
def getEbsEncryptionByDefaultSource(getEbsEncryptionByDefaultRequest: GetEbsEncryptionByDefaultRequest, parallelism: Int = DefaultParallelism): Source[GetEbsEncryptionByDefaultResponse, NotUsed]
def getHostReservationPurchasePreviewFlow(parallelism: Int = DefaultParallelism): Flow[GetHostReservationPurchasePreviewRequest, GetHostReservationPurchasePreviewResponse, NotUsed]
def getHostReservationPurchasePreviewSource(getHostReservationPurchasePreviewRequest: GetHostReservationPurchasePreviewRequest, parallelism: Int = DefaultParallelism): Source[GetHostReservationPurchasePreviewResponse, NotUsed]
def getLaunchTemplateDataFlow(parallelism: Int = DefaultParallelism): Flow[GetLaunchTemplateDataRequest, GetLaunchTemplateDataResponse, NotUsed]
def getLaunchTemplateDataSource(getLaunchTemplateDataRequest: GetLaunchTemplateDataRequest, parallelism: Int = DefaultParallelism): Source[GetLaunchTemplateDataResponse, NotUsed]
def getPasswordDataFlow(parallelism: Int = DefaultParallelism): Flow[GetPasswordDataRequest, GetPasswordDataResponse, NotUsed]
def getPasswordDataSource(getPasswordDataRequest: GetPasswordDataRequest, parallelism: Int = DefaultParallelism): Source[GetPasswordDataResponse, NotUsed]
def getReservedInstancesExchangeQuoteFlow(parallelism: Int = DefaultParallelism): Flow[GetReservedInstancesExchangeQuoteRequest, GetReservedInstancesExchangeQuoteResponse, NotUsed]
def getReservedInstancesExchangeQuoteSource(getReservedInstancesExchangeQuoteRequest: GetReservedInstancesExchangeQuoteRequest, parallelism: Int = DefaultParallelism): Source[GetReservedInstancesExchangeQuoteResponse, NotUsed]
def getTransitGatewayAttachmentPropagationsFlow(parallelism: Int = DefaultParallelism): Flow[GetTransitGatewayAttachmentPropagationsRequest, GetTransitGatewayAttachmentPropagationsResponse, NotUsed]
def getTransitGatewayAttachmentPropagationsPaginatorFlow: Flow[GetTransitGatewayAttachmentPropagationsRequest, GetTransitGatewayAttachmentPropagationsResponse, NotUsed]
def getTransitGatewayAttachmentPropagationsSource(getTransitGatewayAttachmentPropagationsRequest: GetTransitGatewayAttachmentPropagationsRequest, parallelism: Int = DefaultParallelism): Source[GetTransitGatewayAttachmentPropagationsResponse, NotUsed]
def getTransitGatewayMulticastDomainAssociationsFlow(parallelism: Int = DefaultParallelism): Flow[GetTransitGatewayMulticastDomainAssociationsRequest, GetTransitGatewayMulticastDomainAssociationsResponse, NotUsed]
def getTransitGatewayMulticastDomainAssociationsSource(getTransitGatewayMulticastDomainAssociationsRequest: GetTransitGatewayMulticastDomainAssociationsRequest, parallelism: Int = DefaultParallelism): Source[GetTransitGatewayMulticastDomainAssociationsResponse, NotUsed]
def getTransitGatewayRouteTableAssociationsFlow(parallelism: Int = DefaultParallelism): Flow[GetTransitGatewayRouteTableAssociationsRequest, GetTransitGatewayRouteTableAssociationsResponse, NotUsed]
def getTransitGatewayRouteTableAssociationsPaginatorFlow: Flow[GetTransitGatewayRouteTableAssociationsRequest, GetTransitGatewayRouteTableAssociationsResponse, NotUsed]
def getTransitGatewayRouteTableAssociationsSource(getTransitGatewayRouteTableAssociationsRequest: GetTransitGatewayRouteTableAssociationsRequest, parallelism: Int = DefaultParallelism): Source[GetTransitGatewayRouteTableAssociationsResponse, NotUsed]
def getTransitGatewayRouteTablePropagationsFlow(parallelism: Int = DefaultParallelism): Flow[GetTransitGatewayRouteTablePropagationsRequest, GetTransitGatewayRouteTablePropagationsResponse, NotUsed]
def getTransitGatewayRouteTablePropagationsPaginatorFlow: Flow[GetTransitGatewayRouteTablePropagationsRequest, GetTransitGatewayRouteTablePropagationsResponse, NotUsed]
def getTransitGatewayRouteTablePropagationsSource(getTransitGatewayRouteTablePropagationsRequest: GetTransitGatewayRouteTablePropagationsRequest, parallelism: Int = DefaultParallelism): Source[GetTransitGatewayRouteTablePropagationsResponse, NotUsed]
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def importClientVpnClientCertificateRevocationListFlow(parallelism: Int = DefaultParallelism): Flow[ImportClientVpnClientCertificateRevocationListRequest, ImportClientVpnClientCertificateRevocationListResponse, NotUsed]
def importClientVpnClientCertificateRevocationListSource(importClientVpnClientCertificateRevocationListRequest: ImportClientVpnClientCertificateRevocationListRequest, parallelism: Int = DefaultParallelism): Source[ImportClientVpnClientCertificateRevocationListResponse, NotUsed]
def importImageFlow(parallelism: Int = DefaultParallelism): Flow[ImportImageRequest, ImportImageResponse, NotUsed]
def importImageSource(importImageRequest: ImportImageRequest, parallelism: Int = DefaultParallelism): Source[ImportImageResponse, NotUsed]
def importInstanceFlow(parallelism: Int = DefaultParallelism): Flow[ImportInstanceRequest, ImportInstanceResponse, NotUsed]
def importInstanceSource(importInstanceRequest: ImportInstanceRequest, parallelism: Int = DefaultParallelism): Source[ImportInstanceResponse, NotUsed]
def importKeyPairFlow(parallelism: Int = DefaultParallelism): Flow[ImportKeyPairRequest, ImportKeyPairResponse, NotUsed]
def importKeyPairSource(importKeyPairRequest: ImportKeyPairRequest, parallelism: Int = DefaultParallelism): Source[ImportKeyPairResponse, NotUsed]
def importSnapshotFlow(parallelism: Int = DefaultParallelism): Flow[ImportSnapshotRequest, ImportSnapshotResponse, NotUsed]
def importSnapshotSource(importSnapshotRequest: ImportSnapshotRequest, parallelism: Int = DefaultParallelism): Source[ImportSnapshotResponse, NotUsed]
def importVolumeFlow(parallelism: Int = DefaultParallelism): Flow[ImportVolumeRequest, ImportVolumeResponse, NotUsed]
def importVolumeSource(importVolumeRequest: ImportVolumeRequest, parallelism: Int = DefaultParallelism): Source[ImportVolumeResponse, NotUsed]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def modifyCapacityReservationFlow(parallelism: Int = DefaultParallelism): Flow[ModifyCapacityReservationRequest, ModifyCapacityReservationResponse, NotUsed]
def modifyCapacityReservationSource(modifyCapacityReservationRequest: ModifyCapacityReservationRequest, parallelism: Int = DefaultParallelism): Source[ModifyCapacityReservationResponse, NotUsed]
def modifyClientVpnEndpointFlow(parallelism: Int = DefaultParallelism): Flow[ModifyClientVpnEndpointRequest, ModifyClientVpnEndpointResponse, NotUsed]
def modifyClientVpnEndpointSource(modifyClientVpnEndpointRequest: ModifyClientVpnEndpointRequest, parallelism: Int = DefaultParallelism): Source[ModifyClientVpnEndpointResponse, NotUsed]
def modifyDefaultCreditSpecificationFlow(parallelism: Int = DefaultParallelism): Flow[ModifyDefaultCreditSpecificationRequest, ModifyDefaultCreditSpecificationResponse, NotUsed]
def modifyDefaultCreditSpecificationSource(modifyDefaultCreditSpecificationRequest: ModifyDefaultCreditSpecificationRequest, parallelism: Int = DefaultParallelism): Source[ModifyDefaultCreditSpecificationResponse, NotUsed]
def modifyEbsDefaultKmsKeyIdFlow(parallelism: Int = DefaultParallelism): Flow[ModifyEbsDefaultKmsKeyIdRequest, ModifyEbsDefaultKmsKeyIdResponse, NotUsed]
def modifyEbsDefaultKmsKeyIdSource(modifyEbsDefaultKmsKeyIdRequest: ModifyEbsDefaultKmsKeyIdRequest, parallelism: Int = DefaultParallelism): Source[ModifyEbsDefaultKmsKeyIdResponse, NotUsed]
def modifyFleetFlow(parallelism: Int = DefaultParallelism): Flow[ModifyFleetRequest, ModifyFleetResponse, NotUsed]
def modifyFleetSource(modifyFleetRequest: ModifyFleetRequest, parallelism: Int = DefaultParallelism): Source[ModifyFleetResponse, NotUsed]
def modifyFpgaImageAttributeFlow(parallelism: Int = DefaultParallelism): Flow[ModifyFpgaImageAttributeRequest, ModifyFpgaImageAttributeResponse, NotUsed]
def modifyFpgaImageAttributeSource(modifyFpgaImageAttributeRequest: ModifyFpgaImageAttributeRequest, parallelism: Int = DefaultParallelism): Source[ModifyFpgaImageAttributeResponse, NotUsed]
def modifyHostsFlow(parallelism: Int = DefaultParallelism): Flow[ModifyHostsRequest, ModifyHostsResponse, NotUsed]
def modifyHostsSource(modifyHostsRequest: ModifyHostsRequest, parallelism: Int = DefaultParallelism): Source[ModifyHostsResponse, NotUsed]
def modifyIdFormatFlow(parallelism: Int = DefaultParallelism): Flow[ModifyIdFormatRequest, ModifyIdFormatResponse, NotUsed]
def modifyIdFormatSource(modifyIdFormatRequest: ModifyIdFormatRequest, parallelism: Int = DefaultParallelism): Source[ModifyIdFormatResponse, NotUsed]
def modifyIdentityIdFormatFlow(parallelism: Int = DefaultParallelism): Flow[ModifyIdentityIdFormatRequest, ModifyIdentityIdFormatResponse, NotUsed]
def modifyIdentityIdFormatSource(modifyIdentityIdFormatRequest: ModifyIdentityIdFormatRequest, parallelism: Int = DefaultParallelism): Source[ModifyIdentityIdFormatResponse, NotUsed]
def modifyImageAttributeFlow(parallelism: Int = DefaultParallelism): Flow[ModifyImageAttributeRequest, ModifyImageAttributeResponse, NotUsed]
def modifyImageAttributeSource(modifyImageAttributeRequest: ModifyImageAttributeRequest, parallelism: Int = DefaultParallelism): Source[ModifyImageAttributeResponse, NotUsed]
def modifyInstanceAttributeFlow(parallelism: Int = DefaultParallelism): Flow[ModifyInstanceAttributeRequest, ModifyInstanceAttributeResponse, NotUsed]
def modifyInstanceAttributeSource(modifyInstanceAttributeRequest: ModifyInstanceAttributeRequest, parallelism: Int = DefaultParallelism): Source[ModifyInstanceAttributeResponse, NotUsed]
def modifyInstanceCapacityReservationAttributesFlow(parallelism: Int = DefaultParallelism): Flow[ModifyInstanceCapacityReservationAttributesRequest, ModifyInstanceCapacityReservationAttributesResponse, NotUsed]
def modifyInstanceCapacityReservationAttributesSource(modifyInstanceCapacityReservationAttributesRequest: ModifyInstanceCapacityReservationAttributesRequest, parallelism: Int = DefaultParallelism): Source[ModifyInstanceCapacityReservationAttributesResponse, NotUsed]
def modifyInstanceCreditSpecificationFlow(parallelism: Int = DefaultParallelism): Flow[ModifyInstanceCreditSpecificationRequest, ModifyInstanceCreditSpecificationResponse, NotUsed]
def modifyInstanceCreditSpecificationSource(modifyInstanceCreditSpecificationRequest: ModifyInstanceCreditSpecificationRequest, parallelism: Int = DefaultParallelism): Source[ModifyInstanceCreditSpecificationResponse, NotUsed]
def modifyInstanceEventStartTimeFlow(parallelism: Int = DefaultParallelism): Flow[ModifyInstanceEventStartTimeRequest, ModifyInstanceEventStartTimeResponse, NotUsed]
def modifyInstanceEventStartTimeSource(modifyInstanceEventStartTimeRequest: ModifyInstanceEventStartTimeRequest, parallelism: Int = DefaultParallelism): Source[ModifyInstanceEventStartTimeResponse, NotUsed]
def modifyInstanceMetadataOptionsFlow(parallelism: Int = DefaultParallelism): Flow[ModifyInstanceMetadataOptionsRequest, ModifyInstanceMetadataOptionsResponse, NotUsed]
def modifyInstanceMetadataOptionsSource(modifyInstanceMetadataOptionsRequest: ModifyInstanceMetadataOptionsRequest, parallelism: Int = DefaultParallelism): Source[ModifyInstanceMetadataOptionsResponse, NotUsed]
def modifyInstancePlacementFlow(parallelism: Int = DefaultParallelism): Flow[ModifyInstancePlacementRequest, ModifyInstancePlacementResponse, NotUsed]
def modifyInstancePlacementSource(modifyInstancePlacementRequest: ModifyInstancePlacementRequest, parallelism: Int = DefaultParallelism): Source[ModifyInstancePlacementResponse, NotUsed]
def modifyLaunchTemplateFlow(parallelism: Int = DefaultParallelism): Flow[ModifyLaunchTemplateRequest, ModifyLaunchTemplateResponse, NotUsed]
def modifyLaunchTemplateSource(modifyLaunchTemplateRequest: ModifyLaunchTemplateRequest, parallelism: Int = DefaultParallelism): Source[ModifyLaunchTemplateResponse, NotUsed]
def modifyNetworkInterfaceAttributeFlow(parallelism: Int = DefaultParallelism): Flow[ModifyNetworkInterfaceAttributeRequest, ModifyNetworkInterfaceAttributeResponse, NotUsed]
def modifyNetworkInterfaceAttributeSource(modifyNetworkInterfaceAttributeRequest: ModifyNetworkInterfaceAttributeRequest, parallelism: Int = DefaultParallelism): Source[ModifyNetworkInterfaceAttributeResponse, NotUsed]
def modifyReservedInstancesFlow(parallelism: Int = DefaultParallelism): Flow[ModifyReservedInstancesRequest, ModifyReservedInstancesResponse, NotUsed]
def modifyReservedInstancesSource(modifyReservedInstancesRequest: ModifyReservedInstancesRequest, parallelism: Int = DefaultParallelism): Source[ModifyReservedInstancesResponse, NotUsed]
def modifySnapshotAttributeFlow(parallelism: Int = DefaultParallelism): Flow[ModifySnapshotAttributeRequest, ModifySnapshotAttributeResponse, NotUsed]
def modifySnapshotAttributeSource(modifySnapshotAttributeRequest: ModifySnapshotAttributeRequest, parallelism: Int = DefaultParallelism): Source[ModifySnapshotAttributeResponse, NotUsed]
def modifySpotFleetRequestFlow(parallelism: Int = DefaultParallelism): Flow[ModifySpotFleetRequestRequest, ModifySpotFleetRequestResponse, NotUsed]
def modifySpotFleetRequestSource(modifySpotFleetRequestRequest: ModifySpotFleetRequestRequest, parallelism: Int = DefaultParallelism): Source[ModifySpotFleetRequestResponse, NotUsed]
def modifySubnetAttributeFlow(parallelism: Int = DefaultParallelism): Flow[ModifySubnetAttributeRequest, ModifySubnetAttributeResponse, NotUsed]
def modifySubnetAttributeSource(modifySubnetAttributeRequest: ModifySubnetAttributeRequest, parallelism: Int = DefaultParallelism): Source[ModifySubnetAttributeResponse, NotUsed]
def modifyTrafficMirrorFilterNetworkServicesFlow(parallelism: Int = DefaultParallelism): Flow[ModifyTrafficMirrorFilterNetworkServicesRequest, ModifyTrafficMirrorFilterNetworkServicesResponse, NotUsed]
def modifyTrafficMirrorFilterNetworkServicesSource(modifyTrafficMirrorFilterNetworkServicesRequest: ModifyTrafficMirrorFilterNetworkServicesRequest, parallelism: Int = DefaultParallelism): Source[ModifyTrafficMirrorFilterNetworkServicesResponse, NotUsed]
def modifyTrafficMirrorFilterRuleFlow(parallelism: Int = DefaultParallelism): Flow[ModifyTrafficMirrorFilterRuleRequest, ModifyTrafficMirrorFilterRuleResponse, NotUsed]
def modifyTrafficMirrorFilterRuleSource(modifyTrafficMirrorFilterRuleRequest: ModifyTrafficMirrorFilterRuleRequest, parallelism: Int = DefaultParallelism): Source[ModifyTrafficMirrorFilterRuleResponse, NotUsed]
def modifyTrafficMirrorSessionFlow(parallelism: Int = DefaultParallelism): Flow[ModifyTrafficMirrorSessionRequest, ModifyTrafficMirrorSessionResponse, NotUsed]
def modifyTrafficMirrorSessionSource(modifyTrafficMirrorSessionRequest: ModifyTrafficMirrorSessionRequest, parallelism: Int = DefaultParallelism): Source[ModifyTrafficMirrorSessionResponse, NotUsed]
def modifyTransitGatewayVpcAttachmentFlow(parallelism: Int = DefaultParallelism): Flow[ModifyTransitGatewayVpcAttachmentRequest, ModifyTransitGatewayVpcAttachmentResponse, NotUsed]
def modifyTransitGatewayVpcAttachmentSource(modifyTransitGatewayVpcAttachmentRequest: ModifyTransitGatewayVpcAttachmentRequest, parallelism: Int = DefaultParallelism): Source[ModifyTransitGatewayVpcAttachmentResponse, NotUsed]
def modifyVolumeAttributeFlow(parallelism: Int = DefaultParallelism): Flow[ModifyVolumeAttributeRequest, ModifyVolumeAttributeResponse, NotUsed]
def modifyVolumeAttributeSource(modifyVolumeAttributeRequest: ModifyVolumeAttributeRequest, parallelism: Int = DefaultParallelism): Source[ModifyVolumeAttributeResponse, NotUsed]
def modifyVolumeFlow(parallelism: Int = DefaultParallelism): Flow[ModifyVolumeRequest, ModifyVolumeResponse, NotUsed]
def modifyVolumeSource(modifyVolumeRequest: ModifyVolumeRequest, parallelism: Int = DefaultParallelism): Source[ModifyVolumeResponse, NotUsed]
def modifyVpcAttributeFlow(parallelism: Int = DefaultParallelism): Flow[ModifyVpcAttributeRequest, ModifyVpcAttributeResponse, NotUsed]
def modifyVpcAttributeSource(modifyVpcAttributeRequest: ModifyVpcAttributeRequest, parallelism: Int = DefaultParallelism): Source[ModifyVpcAttributeResponse, NotUsed]
def modifyVpcEndpointConnectionNotificationFlow(parallelism: Int = DefaultParallelism): Flow[ModifyVpcEndpointConnectionNotificationRequest, ModifyVpcEndpointConnectionNotificationResponse, NotUsed]
def modifyVpcEndpointConnectionNotificationSource(modifyVpcEndpointConnectionNotificationRequest: ModifyVpcEndpointConnectionNotificationRequest, parallelism: Int = DefaultParallelism): Source[ModifyVpcEndpointConnectionNotificationResponse, NotUsed]
def modifyVpcEndpointFlow(parallelism: Int = DefaultParallelism): Flow[ModifyVpcEndpointRequest, ModifyVpcEndpointResponse, NotUsed]
def modifyVpcEndpointServiceConfigurationFlow(parallelism: Int = DefaultParallelism): Flow[ModifyVpcEndpointServiceConfigurationRequest, ModifyVpcEndpointServiceConfigurationResponse, NotUsed]
def modifyVpcEndpointServiceConfigurationSource(modifyVpcEndpointServiceConfigurationRequest: ModifyVpcEndpointServiceConfigurationRequest, parallelism: Int = DefaultParallelism): Source[ModifyVpcEndpointServiceConfigurationResponse, NotUsed]
def modifyVpcEndpointServicePermissionsFlow(parallelism: Int = DefaultParallelism): Flow[ModifyVpcEndpointServicePermissionsRequest, ModifyVpcEndpointServicePermissionsResponse, NotUsed]
def modifyVpcEndpointServicePermissionsSource(modifyVpcEndpointServicePermissionsRequest: ModifyVpcEndpointServicePermissionsRequest, parallelism: Int = DefaultParallelism): Source[ModifyVpcEndpointServicePermissionsResponse, NotUsed]
def modifyVpcEndpointSource(modifyVpcEndpointRequest: ModifyVpcEndpointRequest, parallelism: Int = DefaultParallelism): Source[ModifyVpcEndpointResponse, NotUsed]
def modifyVpcPeeringConnectionOptionsFlow(parallelism: Int = DefaultParallelism): Flow[ModifyVpcPeeringConnectionOptionsRequest, ModifyVpcPeeringConnectionOptionsResponse, NotUsed]
def modifyVpcPeeringConnectionOptionsSource(modifyVpcPeeringConnectionOptionsRequest: ModifyVpcPeeringConnectionOptionsRequest, parallelism: Int = DefaultParallelism): Source[ModifyVpcPeeringConnectionOptionsResponse, NotUsed]
def modifyVpcTenancyFlow(parallelism: Int = DefaultParallelism): Flow[ModifyVpcTenancyRequest, ModifyVpcTenancyResponse, NotUsed]
def modifyVpcTenancySource(modifyVpcTenancyRequest: ModifyVpcTenancyRequest, parallelism: Int = DefaultParallelism): Source[ModifyVpcTenancyResponse, NotUsed]
def modifyVpnConnectionFlow(parallelism: Int = DefaultParallelism): Flow[ModifyVpnConnectionRequest, ModifyVpnConnectionResponse, NotUsed]
def modifyVpnConnectionSource(modifyVpnConnectionRequest: ModifyVpnConnectionRequest, parallelism: Int = DefaultParallelism): Source[ModifyVpnConnectionResponse, NotUsed]
def modifyVpnTunnelCertificateFlow(parallelism: Int = DefaultParallelism): Flow[ModifyVpnTunnelCertificateRequest, ModifyVpnTunnelCertificateResponse, NotUsed]
def modifyVpnTunnelCertificateSource(modifyVpnTunnelCertificateRequest: ModifyVpnTunnelCertificateRequest, parallelism: Int = DefaultParallelism): Source[ModifyVpnTunnelCertificateResponse, NotUsed]
def modifyVpnTunnelOptionsFlow(parallelism: Int = DefaultParallelism): Flow[ModifyVpnTunnelOptionsRequest, ModifyVpnTunnelOptionsResponse, NotUsed]
def modifyVpnTunnelOptionsSource(modifyVpnTunnelOptionsRequest: ModifyVpnTunnelOptionsRequest, parallelism: Int = DefaultParallelism): Source[ModifyVpnTunnelOptionsResponse, NotUsed]
def monitorInstancesFlow(parallelism: Int = DefaultParallelism): Flow[MonitorInstancesRequest, MonitorInstancesResponse, NotUsed]
def monitorInstancesSource(monitorInstancesRequest: MonitorInstancesRequest, parallelism: Int = DefaultParallelism): Source[MonitorInstancesResponse, NotUsed]
def moveAddressToVpcFlow(parallelism: Int = DefaultParallelism): Flow[MoveAddressToVpcRequest, MoveAddressToVpcResponse, NotUsed]
def moveAddressToVpcSource(moveAddressToVpcRequest: MoveAddressToVpcRequest, parallelism: Int = DefaultParallelism): Source[MoveAddressToVpcResponse, NotUsed]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
def provisionByoipCidrFlow(parallelism: Int = DefaultParallelism): Flow[ProvisionByoipCidrRequest, ProvisionByoipCidrResponse, NotUsed]
def provisionByoipCidrSource(provisionByoipCidrRequest: ProvisionByoipCidrRequest, parallelism: Int = DefaultParallelism): Source[ProvisionByoipCidrResponse, NotUsed]
def purchaseHostReservationFlow(parallelism: Int = DefaultParallelism): Flow[PurchaseHostReservationRequest, PurchaseHostReservationResponse, NotUsed]
def purchaseHostReservationSource(purchaseHostReservationRequest: PurchaseHostReservationRequest, parallelism: Int = DefaultParallelism): Source[PurchaseHostReservationResponse, NotUsed]
def purchaseReservedInstancesOfferingFlow(parallelism: Int = DefaultParallelism): Flow[PurchaseReservedInstancesOfferingRequest, PurchaseReservedInstancesOfferingResponse, NotUsed]
def purchaseReservedInstancesOfferingSource(purchaseReservedInstancesOfferingRequest: PurchaseReservedInstancesOfferingRequest, parallelism: Int = DefaultParallelism): Source[PurchaseReservedInstancesOfferingResponse, NotUsed]
def purchaseScheduledInstancesFlow(parallelism: Int = DefaultParallelism): Flow[PurchaseScheduledInstancesRequest, PurchaseScheduledInstancesResponse, NotUsed]
def purchaseScheduledInstancesSource(purchaseScheduledInstancesRequest: PurchaseScheduledInstancesRequest, parallelism: Int = DefaultParallelism): Source[PurchaseScheduledInstancesResponse, NotUsed]
def rebootInstancesFlow(parallelism: Int = DefaultParallelism): Flow[RebootInstancesRequest, RebootInstancesResponse, NotUsed]
def rebootInstancesSource(rebootInstancesRequest: RebootInstancesRequest, parallelism: Int = DefaultParallelism): Source[RebootInstancesResponse, NotUsed]
def registerImageFlow(parallelism: Int = DefaultParallelism): Flow[RegisterImageRequest, RegisterImageResponse, NotUsed]
def registerImageSource(registerImageRequest: RegisterImageRequest, parallelism: Int = DefaultParallelism): Source[RegisterImageResponse, NotUsed]
def registerTransitGatewayMulticastGroupMembersFlow(parallelism: Int = DefaultParallelism): Flow[RegisterTransitGatewayMulticastGroupMembersRequest, RegisterTransitGatewayMulticastGroupMembersResponse, NotUsed]
def registerTransitGatewayMulticastGroupMembersSource(registerTransitGatewayMulticastGroupMembersRequest: RegisterTransitGatewayMulticastGroupMembersRequest, parallelism: Int = DefaultParallelism): Source[RegisterTransitGatewayMulticastGroupMembersResponse, NotUsed]
def registerTransitGatewayMulticastGroupSourcesFlow(parallelism: Int = DefaultParallelism): Flow[RegisterTransitGatewayMulticastGroupSourcesRequest, RegisterTransitGatewayMulticastGroupSourcesResponse, NotUsed]
def registerTransitGatewayMulticastGroupSourcesSource(registerTransitGatewayMulticastGroupSourcesRequest: RegisterTransitGatewayMulticastGroupSourcesRequest, parallelism: Int = DefaultParallelism): Source[RegisterTransitGatewayMulticastGroupSourcesResponse, NotUsed]
def rejectTransitGatewayPeeringAttachmentFlow(parallelism: Int = DefaultParallelism): Flow[RejectTransitGatewayPeeringAttachmentRequest, RejectTransitGatewayPeeringAttachmentResponse, NotUsed]
def rejectTransitGatewayPeeringAttachmentSource(rejectTransitGatewayPeeringAttachmentRequest: RejectTransitGatewayPeeringAttachmentRequest, parallelism: Int = DefaultParallelism): Source[RejectTransitGatewayPeeringAttachmentResponse, NotUsed]
def rejectTransitGatewayVpcAttachmentFlow(parallelism: Int = DefaultParallelism): Flow[RejectTransitGatewayVpcAttachmentRequest, RejectTransitGatewayVpcAttachmentResponse, NotUsed]
def rejectTransitGatewayVpcAttachmentSource(rejectTransitGatewayVpcAttachmentRequest: RejectTransitGatewayVpcAttachmentRequest, parallelism: Int = DefaultParallelism): Source[RejectTransitGatewayVpcAttachmentResponse, NotUsed]
def rejectVpcEndpointConnectionsFlow(parallelism: Int = DefaultParallelism): Flow[RejectVpcEndpointConnectionsRequest, RejectVpcEndpointConnectionsResponse, NotUsed]
def rejectVpcEndpointConnectionsSource(rejectVpcEndpointConnectionsRequest: RejectVpcEndpointConnectionsRequest, parallelism: Int = DefaultParallelism): Source[RejectVpcEndpointConnectionsResponse, NotUsed]
def rejectVpcPeeringConnectionFlow(parallelism: Int = DefaultParallelism): Flow[RejectVpcPeeringConnectionRequest, RejectVpcPeeringConnectionResponse, NotUsed]
def rejectVpcPeeringConnectionSource(rejectVpcPeeringConnectionRequest: RejectVpcPeeringConnectionRequest, parallelism: Int = DefaultParallelism): Source[RejectVpcPeeringConnectionResponse, NotUsed]
def releaseAddressFlow(parallelism: Int = DefaultParallelism): Flow[ReleaseAddressRequest, ReleaseAddressResponse, NotUsed]
def releaseAddressSource(releaseAddressRequest: ReleaseAddressRequest, parallelism: Int = DefaultParallelism): Source[ReleaseAddressResponse, NotUsed]
def releaseHostsFlow(parallelism: Int = DefaultParallelism): Flow[ReleaseHostsRequest, ReleaseHostsResponse, NotUsed]
def releaseHostsSource(releaseHostsRequest: ReleaseHostsRequest, parallelism: Int = DefaultParallelism): Source[ReleaseHostsResponse, NotUsed]
def replaceIamInstanceProfileAssociationFlow(parallelism: Int = DefaultParallelism): Flow[ReplaceIamInstanceProfileAssociationRequest, ReplaceIamInstanceProfileAssociationResponse, NotUsed]
def replaceIamInstanceProfileAssociationSource(replaceIamInstanceProfileAssociationRequest: ReplaceIamInstanceProfileAssociationRequest, parallelism: Int = DefaultParallelism): Source[ReplaceIamInstanceProfileAssociationResponse, NotUsed]
def replaceNetworkAclAssociationFlow(parallelism: Int = DefaultParallelism): Flow[ReplaceNetworkAclAssociationRequest, ReplaceNetworkAclAssociationResponse, NotUsed]
def replaceNetworkAclAssociationSource(replaceNetworkAclAssociationRequest: ReplaceNetworkAclAssociationRequest, parallelism: Int = DefaultParallelism): Source[ReplaceNetworkAclAssociationResponse, NotUsed]
def replaceNetworkAclEntryFlow(parallelism: Int = DefaultParallelism): Flow[ReplaceNetworkAclEntryRequest, ReplaceNetworkAclEntryResponse, NotUsed]
def replaceNetworkAclEntrySource(replaceNetworkAclEntryRequest: ReplaceNetworkAclEntryRequest, parallelism: Int = DefaultParallelism): Source[ReplaceNetworkAclEntryResponse, NotUsed]
def replaceRouteFlow(parallelism: Int = DefaultParallelism): Flow[ReplaceRouteRequest, ReplaceRouteResponse, NotUsed]
def replaceRouteSource(replaceRouteRequest: ReplaceRouteRequest, parallelism: Int = DefaultParallelism): Source[ReplaceRouteResponse, NotUsed]
def replaceRouteTableAssociationFlow(parallelism: Int = DefaultParallelism): Flow[ReplaceRouteTableAssociationRequest, ReplaceRouteTableAssociationResponse, NotUsed]
def replaceRouteTableAssociationSource(replaceRouteTableAssociationRequest: ReplaceRouteTableAssociationRequest, parallelism: Int = DefaultParallelism): Source[ReplaceRouteTableAssociationResponse, NotUsed]
def replaceTransitGatewayRouteFlow(parallelism: Int = DefaultParallelism): Flow[ReplaceTransitGatewayRouteRequest, ReplaceTransitGatewayRouteResponse, NotUsed]
def replaceTransitGatewayRouteSource(replaceTransitGatewayRouteRequest: ReplaceTransitGatewayRouteRequest, parallelism: Int = DefaultParallelism): Source[ReplaceTransitGatewayRouteResponse, NotUsed]
def reportInstanceStatusFlow(parallelism: Int = DefaultParallelism): Flow[ReportInstanceStatusRequest, ReportInstanceStatusResponse, NotUsed]
def reportInstanceStatusSource(reportInstanceStatusRequest: ReportInstanceStatusRequest, parallelism: Int = DefaultParallelism): Source[ReportInstanceStatusResponse, NotUsed]
def requestSpotFleetFlow(parallelism: Int = DefaultParallelism): Flow[RequestSpotFleetRequest, RequestSpotFleetResponse, NotUsed]
def requestSpotFleetSource(requestSpotFleetRequest: RequestSpotFleetRequest, parallelism: Int = DefaultParallelism): Source[RequestSpotFleetResponse, NotUsed]
def requestSpotInstancesFlow(parallelism: Int = DefaultParallelism): Flow[RequestSpotInstancesRequest, RequestSpotInstancesResponse, NotUsed]
def requestSpotInstancesSource(requestSpotInstancesRequest: RequestSpotInstancesRequest, parallelism: Int = DefaultParallelism): Source[RequestSpotInstancesResponse, NotUsed]
def resetEbsDefaultKmsKeyIdFlow(parallelism: Int = DefaultParallelism): Flow[ResetEbsDefaultKmsKeyIdRequest, ResetEbsDefaultKmsKeyIdResponse, NotUsed]
def resetEbsDefaultKmsKeyIdSource(resetEbsDefaultKmsKeyIdRequest: ResetEbsDefaultKmsKeyIdRequest, parallelism: Int = DefaultParallelism): Source[ResetEbsDefaultKmsKeyIdResponse, NotUsed]
def resetFpgaImageAttributeFlow(parallelism: Int = DefaultParallelism): Flow[ResetFpgaImageAttributeRequest, ResetFpgaImageAttributeResponse, NotUsed]
def resetFpgaImageAttributeSource(resetFpgaImageAttributeRequest: ResetFpgaImageAttributeRequest, parallelism: Int = DefaultParallelism): Source[ResetFpgaImageAttributeResponse, NotUsed]
def resetImageAttributeFlow(parallelism: Int = DefaultParallelism): Flow[ResetImageAttributeRequest, ResetImageAttributeResponse, NotUsed]
def resetImageAttributeSource(resetImageAttributeRequest: ResetImageAttributeRequest, parallelism: Int = DefaultParallelism): Source[ResetImageAttributeResponse, NotUsed]
def resetInstanceAttributeFlow(parallelism: Int = DefaultParallelism): Flow[ResetInstanceAttributeRequest, ResetInstanceAttributeResponse, NotUsed]
def resetInstanceAttributeSource(resetInstanceAttributeRequest: ResetInstanceAttributeRequest, parallelism: Int = DefaultParallelism): Source[ResetInstanceAttributeResponse, NotUsed]
def resetNetworkInterfaceAttributeFlow(parallelism: Int = DefaultParallelism): Flow[ResetNetworkInterfaceAttributeRequest, ResetNetworkInterfaceAttributeResponse, NotUsed]
def resetNetworkInterfaceAttributeSource(resetNetworkInterfaceAttributeRequest: ResetNetworkInterfaceAttributeRequest, parallelism: Int = DefaultParallelism): Source[ResetNetworkInterfaceAttributeResponse, NotUsed]
def resetSnapshotAttributeFlow(parallelism: Int = DefaultParallelism): Flow[ResetSnapshotAttributeRequest, ResetSnapshotAttributeResponse, NotUsed]
def resetSnapshotAttributeSource(resetSnapshotAttributeRequest: ResetSnapshotAttributeRequest, parallelism: Int = DefaultParallelism): Source[ResetSnapshotAttributeResponse, NotUsed]
def restoreAddressToClassicFlow(parallelism: Int = DefaultParallelism): Flow[RestoreAddressToClassicRequest, RestoreAddressToClassicResponse, NotUsed]
def restoreAddressToClassicSource(restoreAddressToClassicRequest: RestoreAddressToClassicRequest, parallelism: Int = DefaultParallelism): Source[RestoreAddressToClassicResponse, NotUsed]
def revokeClientVpnIngressFlow(parallelism: Int = DefaultParallelism): Flow[RevokeClientVpnIngressRequest, RevokeClientVpnIngressResponse, NotUsed]
def revokeClientVpnIngressSource(revokeClientVpnIngressRequest: RevokeClientVpnIngressRequest, parallelism: Int = DefaultParallelism): Source[RevokeClientVpnIngressResponse, NotUsed]
def revokeSecurityGroupEgressFlow(parallelism: Int = DefaultParallelism): Flow[RevokeSecurityGroupEgressRequest, RevokeSecurityGroupEgressResponse, NotUsed]
def revokeSecurityGroupEgressSource(revokeSecurityGroupEgressRequest: RevokeSecurityGroupEgressRequest, parallelism: Int = DefaultParallelism): Source[RevokeSecurityGroupEgressResponse, NotUsed]
def revokeSecurityGroupIngressFlow(parallelism: Int = DefaultParallelism): Flow[RevokeSecurityGroupIngressRequest, RevokeSecurityGroupIngressResponse, NotUsed]
def revokeSecurityGroupIngressSource(revokeSecurityGroupIngressRequest: RevokeSecurityGroupIngressRequest, parallelism: Int = DefaultParallelism): Source[RevokeSecurityGroupIngressResponse, NotUsed]
def runInstancesFlow(parallelism: Int = DefaultParallelism): Flow[RunInstancesRequest, RunInstancesResponse, NotUsed]
def runInstancesSource(runInstancesRequest: RunInstancesRequest, parallelism: Int = DefaultParallelism): Source[RunInstancesResponse, NotUsed]
def runScheduledInstancesFlow(parallelism: Int = DefaultParallelism): Flow[RunScheduledInstancesRequest, RunScheduledInstancesResponse, NotUsed]
def runScheduledInstancesSource(runScheduledInstancesRequest: RunScheduledInstancesRequest, parallelism: Int = DefaultParallelism): Source[RunScheduledInstancesResponse, NotUsed]
def searchLocalGatewayRoutesFlow(parallelism: Int = DefaultParallelism): Flow[SearchLocalGatewayRoutesRequest, SearchLocalGatewayRoutesResponse, NotUsed]
def searchLocalGatewayRoutesSource(searchLocalGatewayRoutesRequest: SearchLocalGatewayRoutesRequest, parallelism: Int = DefaultParallelism): Source[SearchLocalGatewayRoutesResponse, NotUsed]
def searchTransitGatewayMulticastGroupsFlow(parallelism: Int = DefaultParallelism): Flow[SearchTransitGatewayMulticastGroupsRequest, SearchTransitGatewayMulticastGroupsResponse, NotUsed]
def searchTransitGatewayMulticastGroupsSource(searchTransitGatewayMulticastGroupsRequest: SearchTransitGatewayMulticastGroupsRequest, parallelism: Int = DefaultParallelism): Source[SearchTransitGatewayMulticastGroupsResponse, NotUsed]
def searchTransitGatewayRoutesFlow(parallelism: Int = DefaultParallelism): Flow[SearchTransitGatewayRoutesRequest, SearchTransitGatewayRoutesResponse, NotUsed]
def searchTransitGatewayRoutesSource(searchTransitGatewayRoutesRequest: SearchTransitGatewayRoutesRequest, parallelism: Int = DefaultParallelism): Source[SearchTransitGatewayRoutesResponse, NotUsed]
def sendDiagnosticInterruptFlow(parallelism: Int = DefaultParallelism): Flow[SendDiagnosticInterruptRequest, SendDiagnosticInterruptResponse, NotUsed]
def sendDiagnosticInterruptSource(sendDiagnosticInterruptRequest: SendDiagnosticInterruptRequest, parallelism: Int = DefaultParallelism): Source[SendDiagnosticInterruptResponse, NotUsed]
def startInstancesFlow(parallelism: Int = DefaultParallelism): Flow[StartInstancesRequest, StartInstancesResponse, NotUsed]
def startInstancesSource(startInstancesRequest: StartInstancesRequest, parallelism: Int = DefaultParallelism): Source[StartInstancesResponse, NotUsed]
def startVpcEndpointServicePrivateDnsVerificationFlow(parallelism: Int = DefaultParallelism): Flow[StartVpcEndpointServicePrivateDnsVerificationRequest, StartVpcEndpointServicePrivateDnsVerificationResponse, NotUsed]
def startVpcEndpointServicePrivateDnsVerificationSource(startVpcEndpointServicePrivateDnsVerificationRequest: StartVpcEndpointServicePrivateDnsVerificationRequest, parallelism: Int = DefaultParallelism): Source[StartVpcEndpointServicePrivateDnsVerificationResponse, NotUsed]
def stopInstancesFlow(parallelism: Int = DefaultParallelism): Flow[StopInstancesRequest, StopInstancesResponse, NotUsed]
def stopInstancesSource(stopInstancesRequest: StopInstancesRequest, parallelism: Int = DefaultParallelism): Source[StopInstancesResponse, NotUsed]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def terminateClientVpnConnectionsFlow(parallelism: Int = DefaultParallelism): Flow[TerminateClientVpnConnectionsRequest, TerminateClientVpnConnectionsResponse, NotUsed]
def terminateClientVpnConnectionsSource(terminateClientVpnConnectionsRequest: TerminateClientVpnConnectionsRequest, parallelism: Int = DefaultParallelism): Source[TerminateClientVpnConnectionsResponse, NotUsed]
def terminateInstancesFlow(parallelism: Int = DefaultParallelism): Flow[TerminateInstancesRequest, TerminateInstancesResponse, NotUsed]
def terminateInstancesSource(terminateInstancesRequest: TerminateInstancesRequest, parallelism: Int = DefaultParallelism): Source[TerminateInstancesResponse, NotUsed]
def toString(): String

Definition Classes
AnyRef → Any
def unassignIpv6AddressesFlow(parallelism: Int = DefaultParallelism): Flow[UnassignIpv6AddressesRequest, UnassignIpv6AddressesResponse, NotUsed]
def unassignIpv6AddressesSource(unassignIpv6AddressesRequest: UnassignIpv6AddressesRequest, parallelism: Int = DefaultParallelism): Source[UnassignIpv6AddressesResponse, NotUsed]
def unassignPrivateIpAddressesFlow(parallelism: Int = DefaultParallelism): Flow[UnassignPrivateIpAddressesRequest, UnassignPrivateIpAddressesResponse, NotUsed]
def unassignPrivateIpAddressesSource(unassignPrivateIpAddressesRequest: UnassignPrivateIpAddressesRequest, parallelism: Int = DefaultParallelism): Source[UnassignPrivateIpAddressesResponse, NotUsed]
def unmonitorInstancesFlow(parallelism: Int = DefaultParallelism): Flow[UnmonitorInstancesRequest, UnmonitorInstancesResponse, NotUsed]
def unmonitorInstancesSource(unmonitorInstancesRequest: UnmonitorInstancesRequest, parallelism: Int = DefaultParallelism): Source[UnmonitorInstancesResponse, NotUsed]
def updateSecurityGroupRuleDescriptionsEgressFlow(parallelism: Int = DefaultParallelism): Flow[UpdateSecurityGroupRuleDescriptionsEgressRequest, UpdateSecurityGroupRuleDescriptionsEgressResponse, NotUsed]
def updateSecurityGroupRuleDescriptionsEgressSource(updateSecurityGroupRuleDescriptionsEgressRequest: UpdateSecurityGroupRuleDescriptionsEgressRequest, parallelism: Int = DefaultParallelism): Source[UpdateSecurityGroupRuleDescriptionsEgressResponse, NotUsed]
def updateSecurityGroupRuleDescriptionsIngressFlow(parallelism: Int = DefaultParallelism): Flow[UpdateSecurityGroupRuleDescriptionsIngressRequest, UpdateSecurityGroupRuleDescriptionsIngressResponse, NotUsed]
def updateSecurityGroupRuleDescriptionsIngressSource(updateSecurityGroupRuleDescriptionsIngressRequest: UpdateSecurityGroupRuleDescriptionsIngressRequest, parallelism: Int = DefaultParallelism): Source[UpdateSecurityGroupRuleDescriptionsIngressResponse, NotUsed]
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withdrawByoipCidrFlow(parallelism: Int = DefaultParallelism): Flow[WithdrawByoipCidrRequest, WithdrawByoipCidrResponse, NotUsed]
def withdrawByoipCidrSource(withdrawByoipCidrRequest: WithdrawByoipCidrRequest, parallelism: Int = DefaultParallelism): Source[WithdrawByoipCidrResponse, NotUsed]

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.

Related Docs: object Ec2AkkaClient | package akka

trait Ec2AkkaClient extends AnyRef

Abstract Value Members

abstract val underlying: Ec2AsyncClient

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def acceptReservedInstancesExchangeQuoteFlow(parallelism: Int = DefaultParallelism): Flow[AcceptReservedInstancesExchangeQuoteRequest, AcceptReservedInstancesExchangeQuoteResponse, NotUsed]

def acceptReservedInstancesExchangeQuoteSource(acceptReservedInstancesExchangeQuoteRequest: AcceptReservedInstancesExchangeQuoteRequest, parallelism: Int = DefaultParallelism): Source[AcceptReservedInstancesExchangeQuoteResponse, NotUsed]

def acceptTransitGatewayPeeringAttachmentFlow(parallelism: Int = DefaultParallelism): Flow[AcceptTransitGatewayPeeringAttachmentRequest, AcceptTransitGatewayPeeringAttachmentResponse, NotUsed]

def acceptTransitGatewayPeeringAttachmentSource(acceptTransitGatewayPeeringAttachmentRequest: AcceptTransitGatewayPeeringAttachmentRequest, parallelism: Int = DefaultParallelism): Source[AcceptTransitGatewayPeeringAttachmentResponse, NotUsed]

def acceptTransitGatewayVpcAttachmentFlow(parallelism: Int = DefaultParallelism): Flow[AcceptTransitGatewayVpcAttachmentRequest, AcceptTransitGatewayVpcAttachmentResponse, NotUsed]

def acceptTransitGatewayVpcAttachmentSource(acceptTransitGatewayVpcAttachmentRequest: AcceptTransitGatewayVpcAttachmentRequest, parallelism: Int = DefaultParallelism): Source[AcceptTransitGatewayVpcAttachmentResponse, NotUsed]

def acceptVpcEndpointConnectionsFlow(parallelism: Int = DefaultParallelism): Flow[AcceptVpcEndpointConnectionsRequest, AcceptVpcEndpointConnectionsResponse, NotUsed]

def acceptVpcEndpointConnectionsSource(acceptVpcEndpointConnectionsRequest: AcceptVpcEndpointConnectionsRequest, parallelism: Int = DefaultParallelism): Source[AcceptVpcEndpointConnectionsResponse, NotUsed]

def acceptVpcPeeringConnectionFlow(parallelism: Int = DefaultParallelism): Flow[AcceptVpcPeeringConnectionRequest, AcceptVpcPeeringConnectionResponse, NotUsed]

def acceptVpcPeeringConnectionSource(acceptVpcPeeringConnectionRequest: AcceptVpcPeeringConnectionRequest, parallelism: Int = DefaultParallelism): Source[AcceptVpcPeeringConnectionResponse, NotUsed]

def advertiseByoipCidrFlow(parallelism: Int = DefaultParallelism): Flow[AdvertiseByoipCidrRequest, AdvertiseByoipCidrResponse, NotUsed]

def advertiseByoipCidrSource(advertiseByoipCidrRequest: AdvertiseByoipCidrRequest, parallelism: Int = DefaultParallelism): Source[AdvertiseByoipCidrResponse, NotUsed]

def allocateAddressFlow(parallelism: Int = DefaultParallelism): Flow[AllocateAddressRequest, AllocateAddressResponse, NotUsed]

def allocateAddressSource(): Source[AllocateAddressResponse, NotUsed]

def allocateAddressSource(allocateAddressRequest: AllocateAddressRequest, parallelism: Int = DefaultParallelism): Source[AllocateAddressResponse, NotUsed]

def allocateHostsFlow(parallelism: Int = DefaultParallelism): Flow[AllocateHostsRequest, AllocateHostsResponse, NotUsed]

def allocateHostsSource(allocateHostsRequest: AllocateHostsRequest, parallelism: Int = DefaultParallelism): Source[AllocateHostsResponse, NotUsed]

def applySecurityGroupsToClientVpnTargetNetworkFlow(parallelism: Int = DefaultParallelism): Flow[ApplySecurityGroupsToClientVpnTargetNetworkRequest, ApplySecurityGroupsToClientVpnTargetNetworkResponse, NotUsed]

def applySecurityGroupsToClientVpnTargetNetworkSource(applySecurityGroupsToClientVpnTargetNetworkRequest: ApplySecurityGroupsToClientVpnTargetNetworkRequest, parallelism: Int = DefaultParallelism): Source[ApplySecurityGroupsToClientVpnTargetNetworkResponse, NotUsed]

final def asInstanceOf[T0]: T0

def assignIpv6AddressesFlow(parallelism: Int = DefaultParallelism): Flow[AssignIpv6AddressesRequest, AssignIpv6AddressesResponse, NotUsed]

def assignIpv6AddressesSource(assignIpv6AddressesRequest: AssignIpv6AddressesRequest, parallelism: Int = DefaultParallelism): Source[AssignIpv6AddressesResponse, NotUsed]

def assignPrivateIpAddressesFlow(parallelism: Int = DefaultParallelism): Flow[AssignPrivateIpAddressesRequest, AssignPrivateIpAddressesResponse, NotUsed]

def assignPrivateIpAddressesSource(assignPrivateIpAddressesRequest: AssignPrivateIpAddressesRequest, parallelism: Int = DefaultParallelism): Source[AssignPrivateIpAddressesResponse, NotUsed]

def associateAddressFlow(parallelism: Int = DefaultParallelism): Flow[AssociateAddressRequest, AssociateAddressResponse, NotUsed]

def associateAddressSource(): Source[AssociateAddressResponse, NotUsed]

def associateAddressSource(associateAddressRequest: AssociateAddressRequest, parallelism: Int = DefaultParallelism): Source[AssociateAddressResponse, NotUsed]

def associateClientVpnTargetNetworkFlow(parallelism: Int = DefaultParallelism): Flow[AssociateClientVpnTargetNetworkRequest, AssociateClientVpnTargetNetworkResponse, NotUsed]

def associateClientVpnTargetNetworkSource(associateClientVpnTargetNetworkRequest: AssociateClientVpnTargetNetworkRequest, parallelism: Int = DefaultParallelism): Source[AssociateClientVpnTargetNetworkResponse, NotUsed]

def associateDhcpOptionsFlow(parallelism: Int = DefaultParallelism): Flow[AssociateDhcpOptionsRequest, AssociateDhcpOptionsResponse, NotUsed]

def associateDhcpOptionsSource(associateDhcpOptionsRequest: AssociateDhcpOptionsRequest, parallelism: Int = DefaultParallelism): Source[AssociateDhcpOptionsResponse, NotUsed]

def associateIamInstanceProfileFlow(parallelism: Int = DefaultParallelism): Flow[AssociateIamInstanceProfileRequest, AssociateIamInstanceProfileResponse, NotUsed]

def associateIamInstanceProfileSource(associateIamInstanceProfileRequest: AssociateIamInstanceProfileRequest, parallelism: Int = DefaultParallelism): Source[AssociateIamInstanceProfileResponse, NotUsed]

def associateRouteTableFlow(parallelism: Int = DefaultParallelism): Flow[AssociateRouteTableRequest, AssociateRouteTableResponse, NotUsed]

def associateRouteTableSource(associateRouteTableRequest: AssociateRouteTableRequest, parallelism: Int = DefaultParallelism): Source[AssociateRouteTableResponse, NotUsed]

def associateSubnetCidrBlockFlow(parallelism: Int = DefaultParallelism): Flow[AssociateSubnetCidrBlockRequest, AssociateSubnetCidrBlockResponse, NotUsed]

def associateSubnetCidrBlockSource(associateSubnetCidrBlockRequest: AssociateSubnetCidrBlockRequest, parallelism: Int = DefaultParallelism): Source[AssociateSubnetCidrBlockResponse, NotUsed]

def associateTransitGatewayMulticastDomainFlow(parallelism: Int = DefaultParallelism): Flow[AssociateTransitGatewayMulticastDomainRequest, AssociateTransitGatewayMulticastDomainResponse, NotUsed]

def associateTransitGatewayMulticastDomainSource(associateTransitGatewayMulticastDomainRequest: AssociateTransitGatewayMulticastDomainRequest, parallelism: Int = DefaultParallelism): Source[AssociateTransitGatewayMulticastDomainResponse, NotUsed]

def associateTransitGatewayRouteTableFlow(parallelism: Int = DefaultParallelism): Flow[AssociateTransitGatewayRouteTableRequest, AssociateTransitGatewayRouteTableResponse, NotUsed]

def associateTransitGatewayRouteTableSource(associateTransitGatewayRouteTableRequest: AssociateTransitGatewayRouteTableRequest, parallelism: Int = DefaultParallelism): Source[AssociateTransitGatewayRouteTableResponse, NotUsed]

def associateVpcCidrBlockFlow(parallelism: Int = DefaultParallelism): Flow[AssociateVpcCidrBlockRequest, AssociateVpcCidrBlockResponse, NotUsed]

def associateVpcCidrBlockSource(associateVpcCidrBlockRequest: AssociateVpcCidrBlockRequest, parallelism: Int = DefaultParallelism): Source[AssociateVpcCidrBlockResponse, NotUsed]

def attachClassicLinkVpcFlow(parallelism: Int = DefaultParallelism): Flow[AttachClassicLinkVpcRequest, AttachClassicLinkVpcResponse, NotUsed]

def attachClassicLinkVpcSource(attachClassicLinkVpcRequest: AttachClassicLinkVpcRequest, parallelism: Int = DefaultParallelism): Source[AttachClassicLinkVpcResponse, NotUsed]

def attachInternetGatewayFlow(parallelism: Int = DefaultParallelism): Flow[AttachInternetGatewayRequest, AttachInternetGatewayResponse, NotUsed]

def attachInternetGatewaySource(attachInternetGatewayRequest: AttachInternetGatewayRequest, parallelism: Int = DefaultParallelism): Source[AttachInternetGatewayResponse, NotUsed]

def attachNetworkInterfaceFlow(parallelism: Int = DefaultParallelism): Flow[AttachNetworkInterfaceRequest, AttachNetworkInterfaceResponse, NotUsed]

def attachNetworkInterfaceSource(attachNetworkInterfaceRequest: AttachNetworkInterfaceRequest, parallelism: Int = DefaultParallelism): Source[AttachNetworkInterfaceResponse, NotUsed]

def attachVolumeFlow(parallelism: Int = DefaultParallelism): Flow[AttachVolumeRequest, AttachVolumeResponse, NotUsed]

def attachVolumeSource(attachVolumeRequest: AttachVolumeRequest, parallelism: Int = DefaultParallelism): Source[AttachVolumeResponse, NotUsed]

def attachVpnGatewayFlow(parallelism: Int = DefaultParallelism): Flow[AttachVpnGatewayRequest, AttachVpnGatewayResponse, NotUsed]

def attachVpnGatewaySource(attachVpnGatewayRequest: AttachVpnGatewayRequest, parallelism: Int = DefaultParallelism): Source[AttachVpnGatewayResponse, NotUsed]

def authorizeClientVpnIngressFlow(parallelism: Int = DefaultParallelism): Flow[AuthorizeClientVpnIngressRequest, AuthorizeClientVpnIngressResponse, NotUsed]

def authorizeClientVpnIngressSource(authorizeClientVpnIngressRequest: AuthorizeClientVpnIngressRequest, parallelism: Int = DefaultParallelism): Source[AuthorizeClientVpnIngressResponse, NotUsed]

def authorizeSecurityGroupEgressFlow(parallelism: Int = DefaultParallelism): Flow[AuthorizeSecurityGroupEgressRequest, AuthorizeSecurityGroupEgressResponse, NotUsed]

def authorizeSecurityGroupEgressSource(authorizeSecurityGroupEgressRequest: AuthorizeSecurityGroupEgressRequest, parallelism: Int = DefaultParallelism): Source[AuthorizeSecurityGroupEgressResponse, NotUsed]

def authorizeSecurityGroupIngressFlow(parallelism: Int = DefaultParallelism): Flow[AuthorizeSecurityGroupIngressRequest, AuthorizeSecurityGroupIngressResponse, NotUsed]

def authorizeSecurityGroupIngressSource(authorizeSecurityGroupIngressRequest: AuthorizeSecurityGroupIngressRequest, parallelism: Int = DefaultParallelism): Source[AuthorizeSecurityGroupIngressResponse, NotUsed]

def bundleInstanceFlow(parallelism: Int = DefaultParallelism): Flow[BundleInstanceRequest, BundleInstanceResponse, NotUsed]

def bundleInstanceSource(bundleInstanceRequest: BundleInstanceRequest, parallelism: Int = DefaultParallelism): Source[BundleInstanceResponse, NotUsed]

def cancelBundleTaskFlow(parallelism: Int = DefaultParallelism): Flow[CancelBundleTaskRequest, CancelBundleTaskResponse, NotUsed]

def cancelBundleTaskSource(cancelBundleTaskRequest: CancelBundleTaskRequest, parallelism: Int = DefaultParallelism): Source[CancelBundleTaskResponse, NotUsed]

def cancelCapacityReservationFlow(parallelism: Int = DefaultParallelism): Flow[CancelCapacityReservationRequest, CancelCapacityReservationResponse, NotUsed]

def cancelCapacityReservationSource(cancelCapacityReservationRequest: CancelCapacityReservationRequest, parallelism: Int = DefaultParallelism): Source[CancelCapacityReservationResponse, NotUsed]

def cancelConversionTaskFlow(parallelism: Int = DefaultParallelism): Flow[CancelConversionTaskRequest, CancelConversionTaskResponse, NotUsed]

def cancelConversionTaskSource(cancelConversionTaskRequest: CancelConversionTaskRequest, parallelism: Int = DefaultParallelism): Source[CancelConversionTaskResponse, NotUsed]

def cancelExportTaskFlow(parallelism: Int = DefaultParallelism): Flow[CancelExportTaskRequest, CancelExportTaskResponse, NotUsed]

def cancelExportTaskSource(cancelExportTaskRequest: CancelExportTaskRequest, parallelism: Int = DefaultParallelism): Source[CancelExportTaskResponse, NotUsed]

def cancelImportTaskFlow(parallelism: Int = DefaultParallelism): Flow[CancelImportTaskRequest, CancelImportTaskResponse, NotUsed]

def cancelImportTaskSource(cancelImportTaskRequest: CancelImportTaskRequest, parallelism: Int = DefaultParallelism): Source[CancelImportTaskResponse, NotUsed]