export declare const makeEC2Service: Effect.Effect<any, unknown, unknown>

export declare class EC2Service

export interface EC2Service$ {
  /**
   * @see {@link AcceptAddressTransferCommand}
   */
  acceptAddressTransfer(
    args: AcceptAddressTransferCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AcceptAddressTransferCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AcceptCapacityReservationBillingOwnershipCommand}
   */
  acceptCapacityReservationBillingOwnership(
    args: AcceptCapacityReservationBillingOwnershipCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    AcceptCapacityReservationBillingOwnershipCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link AcceptReservedInstancesExchangeQuoteCommand}
   */
  acceptReservedInstancesExchangeQuote(
    args: AcceptReservedInstancesExchangeQuoteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AcceptReservedInstancesExchangeQuoteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AcceptTransitGatewayClientVpnAttachmentCommand}
   */
  acceptTransitGatewayClientVpnAttachment(
    args: AcceptTransitGatewayClientVpnAttachmentCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    AcceptTransitGatewayClientVpnAttachmentCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link AcceptTransitGatewayMulticastDomainAssociationsCommand}
   */
  acceptTransitGatewayMulticastDomainAssociations(
    args: AcceptTransitGatewayMulticastDomainAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    AcceptTransitGatewayMulticastDomainAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link AcceptTransitGatewayPeeringAttachmentCommand}
   */
  acceptTransitGatewayPeeringAttachment(
    args: AcceptTransitGatewayPeeringAttachmentCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AcceptTransitGatewayPeeringAttachmentCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AcceptTransitGatewayVpcAttachmentCommand}
   */
  acceptTransitGatewayVpcAttachment(
    args: AcceptTransitGatewayVpcAttachmentCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AcceptTransitGatewayVpcAttachmentCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AcceptVpcEndpointConnectionsCommand}
   */
  acceptVpcEndpointConnections(
    args: AcceptVpcEndpointConnectionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AcceptVpcEndpointConnectionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AcceptVpcPeeringConnectionCommand}
   */
  acceptVpcPeeringConnection(
    args: AcceptVpcPeeringConnectionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AcceptVpcPeeringConnectionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AdvertiseByoipCidrCommand}
   */
  advertiseByoipCidr(
    args: AdvertiseByoipCidrCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AdvertiseByoipCidrCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AllocateAddressCommand}
   */
  allocateAddress(
    args: AllocateAddressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AllocateAddressCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AllocateHostsCommand}
   */
  allocateHosts(
    args: AllocateHostsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AllocateHostsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AllocateIpamPoolCidrCommand}
   */
  allocateIpamPoolCidr(
    args: AllocateIpamPoolCidrCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AllocateIpamPoolCidrCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ApplySecurityGroupsToClientVpnTargetNetworkCommand}
   */
  applySecurityGroupsToClientVpnTargetNetwork(
    args: ApplySecurityGroupsToClientVpnTargetNetworkCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link AssignIpv6AddressesCommand}
   */
  assignIpv6Addresses(
    args: AssignIpv6AddressesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssignIpv6AddressesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssignPrivateIpAddressesCommand}
   */
  assignPrivateIpAddresses(
    args: AssignPrivateIpAddressesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssignPrivateIpAddressesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssignPrivateNatGatewayAddressCommand}
   */
  assignPrivateNatGatewayAddress(
    args: AssignPrivateNatGatewayAddressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssignPrivateNatGatewayAddressCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateAddressCommand}
   */
  associateAddress(
    args: AssociateAddressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateAddressCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateApplicationStatusCheckCommand}
   */
  associateApplicationStatusCheck(
    args: AssociateApplicationStatusCheckCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateApplicationStatusCheckCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateCapacityReservationBillingOwnerCommand}
   */
  associateCapacityReservationBillingOwner(
    args: AssociateCapacityReservationBillingOwnerCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    AssociateCapacityReservationBillingOwnerCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link AssociateClientVpnTargetNetworkCommand}
   */
  associateClientVpnTargetNetwork(
    args: AssociateClientVpnTargetNetworkCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateClientVpnTargetNetworkCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateDhcpOptionsCommand}
   */
  associateDhcpOptions(
    args: AssociateDhcpOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateDhcpOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateEnclaveCertificateIamRoleCommand}
   */
  associateEnclaveCertificateIamRole(
    args: AssociateEnclaveCertificateIamRoleCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateEnclaveCertificateIamRoleCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateIamInstanceProfileCommand}
   */
  associateIamInstanceProfile(
    args: AssociateIamInstanceProfileCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateIamInstanceProfileCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateInstanceEventWindowCommand}
   */
  associateInstanceEventWindow(
    args: AssociateInstanceEventWindowCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateInstanceEventWindowCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateIpamByoasnCommand}
   */
  associateIpamByoasn(
    args: AssociateIpamByoasnCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateIpamByoasnCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateIpamResourceDiscoveryCommand}
   */
  associateIpamResourceDiscovery(
    args: AssociateIpamResourceDiscoveryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateIpamResourceDiscoveryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateNatGatewayAddressCommand}
   */
  associateNatGatewayAddress(
    args: AssociateNatGatewayAddressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateNatGatewayAddressCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateRouteServerCommand}
   */
  associateRouteServer(
    args: AssociateRouteServerCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateRouteServerCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateRouteTableCommand}
   */
  associateRouteTable(
    args: AssociateRouteTableCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateRouteTableCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateSecurityGroupVpcCommand}
   */
  associateSecurityGroupVpc(
    args: AssociateSecurityGroupVpcCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateSecurityGroupVpcCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateSubnetCidrBlockCommand}
   */
  associateSubnetCidrBlock(
    args: AssociateSubnetCidrBlockCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateSubnetCidrBlockCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateTransitGatewayMulticastDomainCommand}
   */
  associateTransitGatewayMulticastDomain(
    args: AssociateTransitGatewayMulticastDomainCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateTransitGatewayMulticastDomainCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateTransitGatewayPolicyTableCommand}
   */
  associateTransitGatewayPolicyTable(
    args: AssociateTransitGatewayPolicyTableCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateTransitGatewayPolicyTableCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateTransitGatewayRouteTableCommand}
   */
  associateTransitGatewayRouteTable(
    args: AssociateTransitGatewayRouteTableCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateTransitGatewayRouteTableCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateTrunkInterfaceCommand}
   */
  associateTrunkInterface(
    args: AssociateTrunkInterfaceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateTrunkInterfaceCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AssociateVpcCidrBlockCommand}
   */
  associateVpcCidrBlock(
    args: AssociateVpcCidrBlockCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AssociateVpcCidrBlockCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AttachClassicLinkVpcCommand}
   */
  attachClassicLinkVpc(
    args: AttachClassicLinkVpcCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AttachClassicLinkVpcCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AttachImageWatermarkCommand}
   */
  attachImageWatermark(
    args: AttachImageWatermarkCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AttachImageWatermarkCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AttachInternetGatewayCommand}
   */
  attachInternetGateway(
    args: AttachInternetGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AttachInternetGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AttachNetworkInterfaceCommand}
   */
  attachNetworkInterface(
    args: AttachNetworkInterfaceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AttachNetworkInterfaceCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AttachVerifiedAccessTrustProviderCommand}
   */
  attachVerifiedAccessTrustProvider(
    args: AttachVerifiedAccessTrustProviderCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AttachVerifiedAccessTrustProviderCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AttachVolumeCommand}
   */
  attachVolume(
    args: AttachVolumeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AttachVolumeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AttachVpnGatewayCommand}
   */
  attachVpnGateway(
    args: AttachVpnGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AttachVpnGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AuthorizeClientVpnIngressCommand}
   */
  authorizeClientVpnIngress(
    args: AuthorizeClientVpnIngressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AuthorizeClientVpnIngressCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AuthorizeSecurityGroupEgressCommand}
   */
  authorizeSecurityGroupEgress(
    args: AuthorizeSecurityGroupEgressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AuthorizeSecurityGroupEgressCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link AuthorizeSecurityGroupIngressCommand}
   */
  authorizeSecurityGroupIngress(
    args: AuthorizeSecurityGroupIngressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<AuthorizeSecurityGroupIngressCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link BatchModifyIpamRoutingPolicyRegistrationsCommand}
   */
  batchModifyIpamRoutingPolicyRegistrations(
    args: BatchModifyIpamRoutingPolicyRegistrationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    BatchModifyIpamRoutingPolicyRegistrationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link BundleInstanceCommand}
   */
  bundleInstance(
    args: BundleInstanceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<BundleInstanceCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CancelBundleTaskCommand}
   */
  cancelBundleTask(
    args: CancelBundleTaskCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CancelBundleTaskCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CancelCapacityReservationCommand}
   */
  cancelCapacityReservation(
    args: CancelCapacityReservationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CancelCapacityReservationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CancelCapacityReservationFleetsCommand}
   */
  cancelCapacityReservationFleets(
    args: CancelCapacityReservationFleetsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CancelCapacityReservationFleetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CancelConversionTaskCommand}
   */
  cancelConversionTask(
    args: CancelConversionTaskCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CancelConversionTaskCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CancelDeclarativePoliciesReportCommand}
   */
  cancelDeclarativePoliciesReport(
    args: CancelDeclarativePoliciesReportCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CancelDeclarativePoliciesReportCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CancelExportTaskCommand}
   */
  cancelExportTask(
    args: CancelExportTaskCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CancelExportTaskCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CancelImageLaunchPermissionCommand}
   */
  cancelImageLaunchPermission(
    args: CancelImageLaunchPermissionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CancelImageLaunchPermissionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CancelImportTaskCommand}
   */
  cancelImportTask(
    args: CancelImportTaskCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CancelImportTaskCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CancelReservedInstancesListingCommand}
   */
  cancelReservedInstancesListing(
    args: CancelReservedInstancesListingCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CancelReservedInstancesListingCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CancelSpotFleetRequestsCommand}
   */
  cancelSpotFleetRequests(
    args: CancelSpotFleetRequestsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CancelSpotFleetRequestsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CancelSpotInstanceRequestsCommand}
   */
  cancelSpotInstanceRequests(
    args: CancelSpotInstanceRequestsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CancelSpotInstanceRequestsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ConfirmProductInstanceCommand}
   */
  confirmProductInstance(
    args: ConfirmProductInstanceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ConfirmProductInstanceCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CopyFpgaImageCommand}
   */
  copyFpgaImage(
    args: CopyFpgaImageCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CopyFpgaImageCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CopyImageCommand}
   */
  copyImage(
    args: CopyImageCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CopyImageCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CopySnapshotCommand}
   */
  copySnapshot(
    args: CopySnapshotCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CopySnapshotCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CopyVolumesCommand}
   */
  copyVolumes(
    args: CopyVolumesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CopyVolumesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateApplicationStatusCheckCommand}
   */
  createApplicationStatusCheck(
    args: CreateApplicationStatusCheckCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateApplicationStatusCheckCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateCapacityManagerDataExportCommand}
   */
  createCapacityManagerDataExport(
    args: CreateCapacityManagerDataExportCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateCapacityManagerDataExportCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateCapacityReservationCommand}
   */
  createCapacityReservation(
    args: CreateCapacityReservationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateCapacityReservationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateCapacityReservationBySplittingCommand}
   */
  createCapacityReservationBySplitting(
    args: CreateCapacityReservationBySplittingCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateCapacityReservationBySplittingCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateCapacityReservationCancellationQuoteCommand}
   */
  createCapacityReservationCancellationQuote(
    args: CreateCapacityReservationCancellationQuoteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    CreateCapacityReservationCancellationQuoteCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link CreateCapacityReservationDateChangeQuoteCommand}
   */
  createCapacityReservationDateChangeQuote(
    args: CreateCapacityReservationDateChangeQuoteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    CreateCapacityReservationDateChangeQuoteCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link CreateCapacityReservationFleetCommand}
   */
  createCapacityReservationFleet(
    args: CreateCapacityReservationFleetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateCapacityReservationFleetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateCarrierGatewayCommand}
   */
  createCarrierGateway(
    args: CreateCarrierGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateCarrierGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateClientVpnEndpointCommand}
   */
  createClientVpnEndpoint(
    args: CreateClientVpnEndpointCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateClientVpnEndpointCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateClientVpnRouteCommand}
   */
  createClientVpnRoute(
    args: CreateClientVpnRouteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateClientVpnRouteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateCoipCidrCommand}
   */
  createCoipCidr(
    args: CreateCoipCidrCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateCoipCidrCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateCoipPoolCommand}
   */
  createCoipPool(
    args: CreateCoipPoolCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateCoipPoolCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateCustomerGatewayCommand}
   */
  createCustomerGateway(
    args: CreateCustomerGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateCustomerGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateDefaultSubnetCommand}
   */
  createDefaultSubnet(
    args: CreateDefaultSubnetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateDefaultSubnetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateDefaultVpcCommand}
   */
  createDefaultVpc(
    args: CreateDefaultVpcCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateDefaultVpcCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateDelegateMacVolumeOwnershipTaskCommand}
   */
  createDelegateMacVolumeOwnershipTask(
    args: CreateDelegateMacVolumeOwnershipTaskCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateDelegateMacVolumeOwnershipTaskCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateDhcpOptionsCommand}
   */
  createDhcpOptions(
    args: CreateDhcpOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateDhcpOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateEgressOnlyInternetGatewayCommand}
   */
  createEgressOnlyInternetGateway(
    args: CreateEgressOnlyInternetGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateEgressOnlyInternetGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateFleetCommand}
   */
  createFleet(
    args: CreateFleetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateFleetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateFlowLogsCommand}
   */
  createFlowLogs(
    args: CreateFlowLogsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateFlowLogsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateFpgaImageCommand}
   */
  createFpgaImage(
    args: CreateFpgaImageCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateFpgaImageCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateImageCommand}
   */
  createImage(
    args: CreateImageCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateImageCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateImageUsageReportCommand}
   */
  createImageUsageReport(
    args: CreateImageUsageReportCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateImageUsageReportCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateInstanceConnectEndpointCommand}
   */
  createInstanceConnectEndpoint(
    args: CreateInstanceConnectEndpointCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateInstanceConnectEndpointCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateInstanceEventWindowCommand}
   */
  createInstanceEventWindow(
    args: CreateInstanceEventWindowCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateInstanceEventWindowCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateInstanceExportTaskCommand}
   */
  createInstanceExportTask(
    args: CreateInstanceExportTaskCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateInstanceExportTaskCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateInternetGatewayCommand}
   */
  createInternetGateway(
    args: CreateInternetGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateInternetGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateInterruptibleCapacityReservationAllocationCommand}
   */
  createInterruptibleCapacityReservationAllocation(
    args: CreateInterruptibleCapacityReservationAllocationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    CreateInterruptibleCapacityReservationAllocationCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link CreateIpamCommand}
   */
  createIpam(
    args: CreateIpamCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateIpamCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateIpamExternalResourceVerificationTokenCommand}
   */
  createIpamExternalResourceVerificationToken(
    args: CreateIpamExternalResourceVerificationTokenCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    CreateIpamExternalResourceVerificationTokenCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link CreateIpamInternetRegistryAssociationCommand}
   */
  createIpamInternetRegistryAssociation(
    args: CreateIpamInternetRegistryAssociationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateIpamInternetRegistryAssociationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateIpamPolicyCommand}
   */
  createIpamPolicy(
    args: CreateIpamPolicyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateIpamPolicyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateIpamPoolCommand}
   */
  createIpamPool(
    args: CreateIpamPoolCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateIpamPoolCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateIpamPrefixListResolverCommand}
   */
  createIpamPrefixListResolver(
    args: CreateIpamPrefixListResolverCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateIpamPrefixListResolverCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateIpamPrefixListResolverTargetCommand}
   */
  createIpamPrefixListResolverTarget(
    args: CreateIpamPrefixListResolverTargetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateIpamPrefixListResolverTargetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateIpamResourceDiscoveryCommand}
   */
  createIpamResourceDiscovery(
    args: CreateIpamResourceDiscoveryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateIpamResourceDiscoveryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateIpamRoutingPolicyRegistrationCommand}
   */
  createIpamRoutingPolicyRegistration(
    args: CreateIpamRoutingPolicyRegistrationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateIpamRoutingPolicyRegistrationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateIpamScopeCommand}
   */
  createIpamScope(
    args: CreateIpamScopeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateIpamScopeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateKeyPairCommand}
   */
  createKeyPair(
    args: CreateKeyPairCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateKeyPairCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateLaunchTemplateCommand}
   */
  createLaunchTemplate(
    args: CreateLaunchTemplateCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateLaunchTemplateCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateLaunchTemplateVersionCommand}
   */
  createLaunchTemplateVersion(
    args: CreateLaunchTemplateVersionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateLaunchTemplateVersionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateLocalGatewayRouteCommand}
   */
  createLocalGatewayRoute(
    args: CreateLocalGatewayRouteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateLocalGatewayRouteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateLocalGatewayRouteTableCommand}
   */
  createLocalGatewayRouteTable(
    args: CreateLocalGatewayRouteTableCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateLocalGatewayRouteTableCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationCommand}
   */
  createLocalGatewayRouteTableVirtualInterfaceGroupAssociation(
    args: CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link CreateLocalGatewayRouteTableVpcAssociationCommand}
   */
  createLocalGatewayRouteTableVpcAssociation(
    args: CreateLocalGatewayRouteTableVpcAssociationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    CreateLocalGatewayRouteTableVpcAssociationCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link CreateLocalGatewayVirtualInterfaceCommand}
   */
  createLocalGatewayVirtualInterface(
    args: CreateLocalGatewayVirtualInterfaceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateLocalGatewayVirtualInterfaceCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateLocalGatewayVirtualInterfaceGroupCommand}
   */
  createLocalGatewayVirtualInterfaceGroup(
    args: CreateLocalGatewayVirtualInterfaceGroupCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    CreateLocalGatewayVirtualInterfaceGroupCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link CreateMacSystemIntegrityProtectionModificationTaskCommand}
   */
  createMacSystemIntegrityProtectionModificationTask(
    args: CreateMacSystemIntegrityProtectionModificationTaskCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    CreateMacSystemIntegrityProtectionModificationTaskCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link CreateManagedPrefixListCommand}
   */
  createManagedPrefixList(
    args: CreateManagedPrefixListCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateManagedPrefixListCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateNatGatewayCommand}
   */
  createNatGateway(
    args: CreateNatGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateNatGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateNetworkAclCommand}
   */
  createNetworkAcl(
    args: CreateNetworkAclCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateNetworkAclCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateNetworkAclEntryCommand}
   */
  createNetworkAclEntry(
    args: CreateNetworkAclEntryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateNetworkAclEntryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateNetworkInsightsAccessScopeCommand}
   */
  createNetworkInsightsAccessScope(
    args: CreateNetworkInsightsAccessScopeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateNetworkInsightsAccessScopeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateNetworkInsightsPathCommand}
   */
  createNetworkInsightsPath(
    args: CreateNetworkInsightsPathCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateNetworkInsightsPathCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateNetworkInterfaceCommand}
   */
  createNetworkInterface(
    args: CreateNetworkInterfaceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateNetworkInterfaceCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateNetworkInterfacePermissionCommand}
   */
  createNetworkInterfacePermission(
    args: CreateNetworkInterfacePermissionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateNetworkInterfacePermissionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreatePlacementGroupCommand}
   */
  createPlacementGroup(
    args: CreatePlacementGroupCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreatePlacementGroupCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreatePublicIpv4PoolCommand}
   */
  createPublicIpv4Pool(
    args: CreatePublicIpv4PoolCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreatePublicIpv4PoolCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateReplaceRootVolumeTaskCommand}
   */
  createReplaceRootVolumeTask(
    args: CreateReplaceRootVolumeTaskCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateReplaceRootVolumeTaskCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateReservedInstancesListingCommand}
   */
  createReservedInstancesListing(
    args: CreateReservedInstancesListingCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateReservedInstancesListingCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateRestoreImageTaskCommand}
   */
  createRestoreImageTask(
    args: CreateRestoreImageTaskCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateRestoreImageTaskCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateRouteCommand}
   */
  createRoute(
    args: CreateRouteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateRouteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateRouteServerCommand}
   */
  createRouteServer(
    args: CreateRouteServerCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateRouteServerCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateRouteServerEndpointCommand}
   */
  createRouteServerEndpoint(
    args: CreateRouteServerEndpointCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateRouteServerEndpointCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateRouteServerPeerCommand}
   */
  createRouteServerPeer(
    args: CreateRouteServerPeerCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateRouteServerPeerCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateRouteTableCommand}
   */
  createRouteTable(
    args: CreateRouteTableCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateRouteTableCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateSecondaryNetworkCommand}
   */
  createSecondaryNetwork(
    args: CreateSecondaryNetworkCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateSecondaryNetworkCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateSecondarySubnetCommand}
   */
  createSecondarySubnet(
    args: CreateSecondarySubnetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateSecondarySubnetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateSecurityGroupCommand}
   */
  createSecurityGroup(
    args: CreateSecurityGroupCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateSecurityGroupCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateSnapshotCommand}
   */
  createSnapshot(
    args: CreateSnapshotCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateSnapshotCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateSnapshotsCommand}
   */
  createSnapshots(
    args: CreateSnapshotsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateSnapshotsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateSpotDatafeedSubscriptionCommand}
   */
  createSpotDatafeedSubscription(
    args: CreateSpotDatafeedSubscriptionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateSpotDatafeedSubscriptionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateStoreImageTaskCommand}
   */
  createStoreImageTask(
    args: CreateStoreImageTaskCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateStoreImageTaskCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateSubnetCommand}
   */
  createSubnet(
    args: CreateSubnetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateSubnetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateSubnetCidrReservationCommand}
   */
  createSubnetCidrReservation(
    args: CreateSubnetCidrReservationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateSubnetCidrReservationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTagsCommand}
   */
  createTags(
    args: CreateTagsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTagsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTrafficMirrorFilterCommand}
   */
  createTrafficMirrorFilter(
    args: CreateTrafficMirrorFilterCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTrafficMirrorFilterCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTrafficMirrorFilterRuleCommand}
   */
  createTrafficMirrorFilterRule(
    args: CreateTrafficMirrorFilterRuleCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTrafficMirrorFilterRuleCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTrafficMirrorSessionCommand}
   */
  createTrafficMirrorSession(
    args: CreateTrafficMirrorSessionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTrafficMirrorSessionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTrafficMirrorTargetCommand}
   */
  createTrafficMirrorTarget(
    args: CreateTrafficMirrorTargetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTrafficMirrorTargetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTransitGatewayCommand}
   */
  createTransitGateway(
    args: CreateTransitGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTransitGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTransitGatewayConnectCommand}
   */
  createTransitGatewayConnect(
    args: CreateTransitGatewayConnectCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTransitGatewayConnectCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTransitGatewayConnectPeerCommand}
   */
  createTransitGatewayConnectPeer(
    args: CreateTransitGatewayConnectPeerCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTransitGatewayConnectPeerCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTransitGatewayMeteringPolicyCommand}
   */
  createTransitGatewayMeteringPolicy(
    args: CreateTransitGatewayMeteringPolicyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTransitGatewayMeteringPolicyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTransitGatewayMeteringPolicyEntryCommand}
   */
  createTransitGatewayMeteringPolicyEntry(
    args: CreateTransitGatewayMeteringPolicyEntryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    CreateTransitGatewayMeteringPolicyEntryCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link CreateTransitGatewayMulticastDomainCommand}
   */
  createTransitGatewayMulticastDomain(
    args: CreateTransitGatewayMulticastDomainCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTransitGatewayMulticastDomainCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTransitGatewayPeeringAttachmentCommand}
   */
  createTransitGatewayPeeringAttachment(
    args: CreateTransitGatewayPeeringAttachmentCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTransitGatewayPeeringAttachmentCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTransitGatewayPolicyTableCommand}
   */
  createTransitGatewayPolicyTable(
    args: CreateTransitGatewayPolicyTableCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTransitGatewayPolicyTableCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTransitGatewayPolicyTableEntryCommand}
   */
  createTransitGatewayPolicyTableEntry(
    args: CreateTransitGatewayPolicyTableEntryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTransitGatewayPolicyTableEntryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTransitGatewayPrefixListReferenceCommand}
   */
  createTransitGatewayPrefixListReference(
    args: CreateTransitGatewayPrefixListReferenceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    CreateTransitGatewayPrefixListReferenceCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link CreateTransitGatewayRouteCommand}
   */
  createTransitGatewayRoute(
    args: CreateTransitGatewayRouteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTransitGatewayRouteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTransitGatewayRouteTableCommand}
   */
  createTransitGatewayRouteTable(
    args: CreateTransitGatewayRouteTableCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTransitGatewayRouteTableCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateTransitGatewayRouteTableAnnouncementCommand}
   */
  createTransitGatewayRouteTableAnnouncement(
    args: CreateTransitGatewayRouteTableAnnouncementCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    CreateTransitGatewayRouteTableAnnouncementCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link CreateTransitGatewayVpcAttachmentCommand}
   */
  createTransitGatewayVpcAttachment(
    args: CreateTransitGatewayVpcAttachmentCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateTransitGatewayVpcAttachmentCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVerifiedAccessEndpointCommand}
   */
  createVerifiedAccessEndpoint(
    args: CreateVerifiedAccessEndpointCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVerifiedAccessEndpointCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVerifiedAccessGroupCommand}
   */
  createVerifiedAccessGroup(
    args: CreateVerifiedAccessGroupCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVerifiedAccessGroupCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVerifiedAccessInstanceCommand}
   */
  createVerifiedAccessInstance(
    args: CreateVerifiedAccessInstanceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVerifiedAccessInstanceCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVerifiedAccessTrustProviderCommand}
   */
  createVerifiedAccessTrustProvider(
    args: CreateVerifiedAccessTrustProviderCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVerifiedAccessTrustProviderCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVolumeCommand}
   */
  createVolume(
    args: CreateVolumeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVolumeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVpcCommand}
   */
  createVpc(
    args: CreateVpcCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVpcCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVpcBlockPublicAccessExclusionCommand}
   */
  createVpcBlockPublicAccessExclusion(
    args: CreateVpcBlockPublicAccessExclusionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVpcBlockPublicAccessExclusionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVpcEncryptionControlCommand}
   */
  createVpcEncryptionControl(
    args: CreateVpcEncryptionControlCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVpcEncryptionControlCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVpcEndpointCommand}
   */
  createVpcEndpoint(
    args: CreateVpcEndpointCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVpcEndpointCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVpcEndpointConnectionNotificationCommand}
   */
  createVpcEndpointConnectionNotification(
    args: CreateVpcEndpointConnectionNotificationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    CreateVpcEndpointConnectionNotificationCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link CreateVpcEndpointServiceConfigurationCommand}
   */
  createVpcEndpointServiceConfiguration(
    args: CreateVpcEndpointServiceConfigurationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVpcEndpointServiceConfigurationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVpcPeeringConnectionCommand}
   */
  createVpcPeeringConnection(
    args: CreateVpcPeeringConnectionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVpcPeeringConnectionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVpnConcentratorCommand}
   */
  createVpnConcentrator(
    args: CreateVpnConcentratorCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVpnConcentratorCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVpnConnectionCommand}
   */
  createVpnConnection(
    args: CreateVpnConnectionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVpnConnectionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVpnConnectionRouteCommand}
   */
  createVpnConnectionRoute(
    args: CreateVpnConnectionRouteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVpnConnectionRouteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link CreateVpnGatewayCommand}
   */
  createVpnGateway(
    args: CreateVpnGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<CreateVpnGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteApplicationStatusCheckCommand}
   */
  deleteApplicationStatusCheck(
    args: DeleteApplicationStatusCheckCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteApplicationStatusCheckCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteCapacityManagerDataExportCommand}
   */
  deleteCapacityManagerDataExport(
    args: DeleteCapacityManagerDataExportCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteCapacityManagerDataExportCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteCarrierGatewayCommand}
   */
  deleteCarrierGateway(
    args: DeleteCarrierGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteCarrierGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteClientVpnEndpointCommand}
   */
  deleteClientVpnEndpoint(
    args: DeleteClientVpnEndpointCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteClientVpnEndpointCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteClientVpnRouteCommand}
   */
  deleteClientVpnRoute(
    args: DeleteClientVpnRouteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteClientVpnRouteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteCoipCidrCommand}
   */
  deleteCoipCidr(
    args: DeleteCoipCidrCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteCoipCidrCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteCoipPoolCommand}
   */
  deleteCoipPool(
    args: DeleteCoipPoolCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteCoipPoolCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteCustomerGatewayCommand}
   */
  deleteCustomerGateway(
    args: DeleteCustomerGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteCustomerGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteDhcpOptionsCommand}
   */
  deleteDhcpOptions(
    args: DeleteDhcpOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteDhcpOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteEgressOnlyInternetGatewayCommand}
   */
  deleteEgressOnlyInternetGateway(
    args: DeleteEgressOnlyInternetGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteEgressOnlyInternetGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteFleetsCommand}
   */
  deleteFleets(
    args: DeleteFleetsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteFleetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteFlowLogsCommand}
   */
  deleteFlowLogs(
    args: DeleteFlowLogsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteFlowLogsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteFpgaImageCommand}
   */
  deleteFpgaImage(
    args: DeleteFpgaImageCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteFpgaImageCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteImageUsageReportCommand}
   */
  deleteImageUsageReport(
    args: DeleteImageUsageReportCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteImageUsageReportCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteInstanceConnectEndpointCommand}
   */
  deleteInstanceConnectEndpoint(
    args: DeleteInstanceConnectEndpointCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteInstanceConnectEndpointCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteInstanceEventWindowCommand}
   */
  deleteInstanceEventWindow(
    args: DeleteInstanceEventWindowCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteInstanceEventWindowCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteInternetGatewayCommand}
   */
  deleteInternetGateway(
    args: DeleteInternetGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteInternetGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteIpamCommand}
   */
  deleteIpam(
    args: DeleteIpamCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteIpamCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteIpamExternalResourceVerificationTokenCommand}
   */
  deleteIpamExternalResourceVerificationToken(
    args: DeleteIpamExternalResourceVerificationTokenCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DeleteIpamExternalResourceVerificationTokenCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DeleteIpamInternetRegistryAssociationCommand}
   */
  deleteIpamInternetRegistryAssociation(
    args: DeleteIpamInternetRegistryAssociationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteIpamInternetRegistryAssociationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteIpamPolicyCommand}
   */
  deleteIpamPolicy(
    args: DeleteIpamPolicyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteIpamPolicyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteIpamPoolCommand}
   */
  deleteIpamPool(
    args: DeleteIpamPoolCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteIpamPoolCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteIpamPrefixListResolverCommand}
   */
  deleteIpamPrefixListResolver(
    args: DeleteIpamPrefixListResolverCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteIpamPrefixListResolverCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteIpamPrefixListResolverTargetCommand}
   */
  deleteIpamPrefixListResolverTarget(
    args: DeleteIpamPrefixListResolverTargetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteIpamPrefixListResolverTargetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteIpamResourceDiscoveryCommand}
   */
  deleteIpamResourceDiscovery(
    args: DeleteIpamResourceDiscoveryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteIpamResourceDiscoveryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteIpamRoutingPolicyRegistrationCommand}
   */
  deleteIpamRoutingPolicyRegistration(
    args: DeleteIpamRoutingPolicyRegistrationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteIpamRoutingPolicyRegistrationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteIpamScopeCommand}
   */
  deleteIpamScope(
    args: DeleteIpamScopeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteIpamScopeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteKeyPairCommand}
   */
  deleteKeyPair(
    args: DeleteKeyPairCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteKeyPairCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteLaunchTemplateCommand}
   */
  deleteLaunchTemplate(
    args: DeleteLaunchTemplateCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteLaunchTemplateCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteLaunchTemplateVersionsCommand}
   */
  deleteLaunchTemplateVersions(
    args: DeleteLaunchTemplateVersionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteLaunchTemplateVersionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteLocalGatewayRouteCommand}
   */
  deleteLocalGatewayRoute(
    args: DeleteLocalGatewayRouteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteLocalGatewayRouteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteLocalGatewayRouteTableCommand}
   */
  deleteLocalGatewayRouteTable(
    args: DeleteLocalGatewayRouteTableCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteLocalGatewayRouteTableCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationCommand}
   */
  deleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(
    args: DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DeleteLocalGatewayRouteTableVpcAssociationCommand}
   */
  deleteLocalGatewayRouteTableVpcAssociation(
    args: DeleteLocalGatewayRouteTableVpcAssociationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DeleteLocalGatewayRouteTableVpcAssociationCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DeleteLocalGatewayVirtualInterfaceCommand}
   */
  deleteLocalGatewayVirtualInterface(
    args: DeleteLocalGatewayVirtualInterfaceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteLocalGatewayVirtualInterfaceCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteLocalGatewayVirtualInterfaceGroupCommand}
   */
  deleteLocalGatewayVirtualInterfaceGroup(
    args: DeleteLocalGatewayVirtualInterfaceGroupCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DeleteLocalGatewayVirtualInterfaceGroupCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DeleteManagedPrefixListCommand}
   */
  deleteManagedPrefixList(
    args: DeleteManagedPrefixListCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteManagedPrefixListCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteNatGatewayCommand}
   */
  deleteNatGateway(
    args: DeleteNatGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteNatGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteNetworkAclCommand}
   */
  deleteNetworkAcl(
    args: DeleteNetworkAclCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteNetworkAclCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteNetworkAclEntryCommand}
   */
  deleteNetworkAclEntry(
    args: DeleteNetworkAclEntryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteNetworkAclEntryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteNetworkInsightsAccessScopeCommand}
   */
  deleteNetworkInsightsAccessScope(
    args: DeleteNetworkInsightsAccessScopeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteNetworkInsightsAccessScopeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteNetworkInsightsAccessScopeAnalysisCommand}
   */
  deleteNetworkInsightsAccessScopeAnalysis(
    args: DeleteNetworkInsightsAccessScopeAnalysisCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DeleteNetworkInsightsAccessScopeAnalysisCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DeleteNetworkInsightsAnalysisCommand}
   */
  deleteNetworkInsightsAnalysis(
    args: DeleteNetworkInsightsAnalysisCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteNetworkInsightsAnalysisCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteNetworkInsightsPathCommand}
   */
  deleteNetworkInsightsPath(
    args: DeleteNetworkInsightsPathCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteNetworkInsightsPathCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteNetworkInterfaceCommand}
   */
  deleteNetworkInterface(
    args: DeleteNetworkInterfaceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteNetworkInterfaceCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteNetworkInterfacePermissionCommand}
   */
  deleteNetworkInterfacePermission(
    args: DeleteNetworkInterfacePermissionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteNetworkInterfacePermissionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeletePlacementGroupCommand}
   */
  deletePlacementGroup(
    args: DeletePlacementGroupCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeletePlacementGroupCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeletePublicIpv4PoolCommand}
   */
  deletePublicIpv4Pool(
    args: DeletePublicIpv4PoolCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeletePublicIpv4PoolCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteQueuedReservedInstancesCommand}
   */
  deleteQueuedReservedInstances(
    args: DeleteQueuedReservedInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteQueuedReservedInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteRouteCommand}
   */
  deleteRoute(
    args: DeleteRouteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteRouteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteRouteServerCommand}
   */
  deleteRouteServer(
    args: DeleteRouteServerCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteRouteServerCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteRouteServerEndpointCommand}
   */
  deleteRouteServerEndpoint(
    args: DeleteRouteServerEndpointCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteRouteServerEndpointCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteRouteServerPeerCommand}
   */
  deleteRouteServerPeer(
    args: DeleteRouteServerPeerCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteRouteServerPeerCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteRouteTableCommand}
   */
  deleteRouteTable(
    args: DeleteRouteTableCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteRouteTableCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteSecondaryNetworkCommand}
   */
  deleteSecondaryNetwork(
    args: DeleteSecondaryNetworkCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteSecondaryNetworkCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteSecondarySubnetCommand}
   */
  deleteSecondarySubnet(
    args: DeleteSecondarySubnetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteSecondarySubnetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteSecurityGroupCommand}
   */
  deleteSecurityGroup(
    args: DeleteSecurityGroupCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteSecurityGroupCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteSnapshotCommand}
   */
  deleteSnapshot(
    args: DeleteSnapshotCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteSnapshotCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteSpotDatafeedSubscriptionCommand}
   */
  deleteSpotDatafeedSubscription(
    args: DeleteSpotDatafeedSubscriptionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteSpotDatafeedSubscriptionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteSubnetCommand}
   */
  deleteSubnet(
    args: DeleteSubnetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteSubnetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteSubnetCidrReservationCommand}
   */
  deleteSubnetCidrReservation(
    args: DeleteSubnetCidrReservationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteSubnetCidrReservationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTagsCommand}
   */
  deleteTags(
    args: DeleteTagsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTagsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTrafficMirrorFilterCommand}
   */
  deleteTrafficMirrorFilter(
    args: DeleteTrafficMirrorFilterCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTrafficMirrorFilterCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTrafficMirrorFilterRuleCommand}
   */
  deleteTrafficMirrorFilterRule(
    args: DeleteTrafficMirrorFilterRuleCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTrafficMirrorFilterRuleCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTrafficMirrorSessionCommand}
   */
  deleteTrafficMirrorSession(
    args: DeleteTrafficMirrorSessionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTrafficMirrorSessionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTrafficMirrorTargetCommand}
   */
  deleteTrafficMirrorTarget(
    args: DeleteTrafficMirrorTargetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTrafficMirrorTargetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTransitGatewayCommand}
   */
  deleteTransitGateway(
    args: DeleteTransitGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTransitGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTransitGatewayClientVpnAttachmentCommand}
   */
  deleteTransitGatewayClientVpnAttachment(
    args: DeleteTransitGatewayClientVpnAttachmentCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DeleteTransitGatewayClientVpnAttachmentCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DeleteTransitGatewayConnectCommand}
   */
  deleteTransitGatewayConnect(
    args: DeleteTransitGatewayConnectCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTransitGatewayConnectCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTransitGatewayConnectPeerCommand}
   */
  deleteTransitGatewayConnectPeer(
    args: DeleteTransitGatewayConnectPeerCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTransitGatewayConnectPeerCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTransitGatewayMeteringPolicyCommand}
   */
  deleteTransitGatewayMeteringPolicy(
    args: DeleteTransitGatewayMeteringPolicyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTransitGatewayMeteringPolicyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTransitGatewayMeteringPolicyEntryCommand}
   */
  deleteTransitGatewayMeteringPolicyEntry(
    args: DeleteTransitGatewayMeteringPolicyEntryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DeleteTransitGatewayMeteringPolicyEntryCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DeleteTransitGatewayMulticastDomainCommand}
   */
  deleteTransitGatewayMulticastDomain(
    args: DeleteTransitGatewayMulticastDomainCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTransitGatewayMulticastDomainCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTransitGatewayPeeringAttachmentCommand}
   */
  deleteTransitGatewayPeeringAttachment(
    args: DeleteTransitGatewayPeeringAttachmentCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTransitGatewayPeeringAttachmentCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTransitGatewayPolicyTableCommand}
   */
  deleteTransitGatewayPolicyTable(
    args: DeleteTransitGatewayPolicyTableCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTransitGatewayPolicyTableCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTransitGatewayPolicyTableEntryCommand}
   */
  deleteTransitGatewayPolicyTableEntry(
    args: DeleteTransitGatewayPolicyTableEntryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTransitGatewayPolicyTableEntryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTransitGatewayPrefixListReferenceCommand}
   */
  deleteTransitGatewayPrefixListReference(
    args: DeleteTransitGatewayPrefixListReferenceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DeleteTransitGatewayPrefixListReferenceCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DeleteTransitGatewayRouteCommand}
   */
  deleteTransitGatewayRoute(
    args: DeleteTransitGatewayRouteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTransitGatewayRouteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTransitGatewayRouteTableCommand}
   */
  deleteTransitGatewayRouteTable(
    args: DeleteTransitGatewayRouteTableCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTransitGatewayRouteTableCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteTransitGatewayRouteTableAnnouncementCommand}
   */
  deleteTransitGatewayRouteTableAnnouncement(
    args: DeleteTransitGatewayRouteTableAnnouncementCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DeleteTransitGatewayRouteTableAnnouncementCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DeleteTransitGatewayVpcAttachmentCommand}
   */
  deleteTransitGatewayVpcAttachment(
    args: DeleteTransitGatewayVpcAttachmentCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteTransitGatewayVpcAttachmentCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVerifiedAccessEndpointCommand}
   */
  deleteVerifiedAccessEndpoint(
    args: DeleteVerifiedAccessEndpointCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVerifiedAccessEndpointCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVerifiedAccessGroupCommand}
   */
  deleteVerifiedAccessGroup(
    args: DeleteVerifiedAccessGroupCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVerifiedAccessGroupCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVerifiedAccessInstanceCommand}
   */
  deleteVerifiedAccessInstance(
    args: DeleteVerifiedAccessInstanceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVerifiedAccessInstanceCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVerifiedAccessTrustProviderCommand}
   */
  deleteVerifiedAccessTrustProvider(
    args: DeleteVerifiedAccessTrustProviderCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVerifiedAccessTrustProviderCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVolumeCommand}
   */
  deleteVolume(
    args: DeleteVolumeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVolumeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVpcCommand}
   */
  deleteVpc(
    args: DeleteVpcCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVpcCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVpcBlockPublicAccessExclusionCommand}
   */
  deleteVpcBlockPublicAccessExclusion(
    args: DeleteVpcBlockPublicAccessExclusionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVpcBlockPublicAccessExclusionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVpcEncryptionControlCommand}
   */
  deleteVpcEncryptionControl(
    args: DeleteVpcEncryptionControlCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVpcEncryptionControlCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVpcEndpointConnectionNotificationsCommand}
   */
  deleteVpcEndpointConnectionNotifications(
    args: DeleteVpcEndpointConnectionNotificationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DeleteVpcEndpointConnectionNotificationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DeleteVpcEndpointServiceConfigurationsCommand}
   */
  deleteVpcEndpointServiceConfigurations(
    args: DeleteVpcEndpointServiceConfigurationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVpcEndpointServiceConfigurationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVpcEndpointsCommand}
   */
  deleteVpcEndpoints(
    args: DeleteVpcEndpointsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVpcEndpointsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVpcPeeringConnectionCommand}
   */
  deleteVpcPeeringConnection(
    args: DeleteVpcPeeringConnectionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVpcPeeringConnectionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVpnConcentratorCommand}
   */
  deleteVpnConcentrator(
    args: DeleteVpnConcentratorCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVpnConcentratorCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVpnConnectionCommand}
   */
  deleteVpnConnection(
    args: DeleteVpnConnectionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVpnConnectionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVpnConnectionRouteCommand}
   */
  deleteVpnConnectionRoute(
    args: DeleteVpnConnectionRouteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVpnConnectionRouteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeleteVpnGatewayCommand}
   */
  deleteVpnGateway(
    args: DeleteVpnGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeleteVpnGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeprovisionByoipCidrCommand}
   */
  deprovisionByoipCidr(
    args: DeprovisionByoipCidrCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeprovisionByoipCidrCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeprovisionIpamByoasnCommand}
   */
  deprovisionIpamByoasn(
    args: DeprovisionIpamByoasnCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeprovisionIpamByoasnCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeprovisionIpamPoolCidrCommand}
   */
  deprovisionIpamPoolCidr(
    args: DeprovisionIpamPoolCidrCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeprovisionIpamPoolCidrCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeprovisionPublicIpv4PoolCidrCommand}
   */
  deprovisionPublicIpv4PoolCidr(
    args: DeprovisionPublicIpv4PoolCidrCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeprovisionPublicIpv4PoolCidrCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeregisterImageCommand}
   */
  deregisterImage(
    args: DeregisterImageCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DeregisterImageCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DeregisterInstanceEventNotificationAttributesCommand}
   */
  deregisterInstanceEventNotificationAttributes(
    args: DeregisterInstanceEventNotificationAttributesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DeregisterInstanceEventNotificationAttributesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DeregisterTransitGatewayMulticastGroupMembersCommand}
   */
  deregisterTransitGatewayMulticastGroupMembers(
    args: DeregisterTransitGatewayMulticastGroupMembersCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DeregisterTransitGatewayMulticastGroupMembersCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DeregisterTransitGatewayMulticastGroupSourcesCommand}
   */
  deregisterTransitGatewayMulticastGroupSources(
    args: DeregisterTransitGatewayMulticastGroupSourcesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DeregisterTransitGatewayMulticastGroupSourcesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeAccountAttributesCommand}
   */
  describeAccountAttributes(
    args: DescribeAccountAttributesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeAccountAttributesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeAccountVpcEncryptionControlCommand}
   */
  describeAccountVpcEncryptionControl(
    args: DescribeAccountVpcEncryptionControlCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeAccountVpcEncryptionControlCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeAddressTransfersCommand}
   */
  describeAddressTransfers(
    args: DescribeAddressTransfersCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeAddressTransfersCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeAddressTransfersStream(
    args: DescribeAddressTransfersCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeAddressTransfersCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeAddressesCommand}
   */
  describeAddresses(
    args: DescribeAddressesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeAddressesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeAddressesAttributeCommand}
   */
  describeAddressesAttribute(
    args: DescribeAddressesAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeAddressesAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeAddressesAttributeStream(
    args: DescribeAddressesAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeAddressesAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeAggregateIdFormatCommand}
   */
  describeAggregateIdFormat(
    args: DescribeAggregateIdFormatCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeAggregateIdFormatCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeApplicationStatusCommand}
   */
  describeApplicationStatus(
    args: DescribeApplicationStatusCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeApplicationStatusCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeApplicationStatusCheckAssociationsCommand}
   */
  describeApplicationStatusCheckAssociations(
    args: DescribeApplicationStatusCheckAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeApplicationStatusCheckAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeApplicationStatusChecksCommand}
   */
  describeApplicationStatusChecks(
    args: DescribeApplicationStatusChecksCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeApplicationStatusChecksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeAvailabilityZonesCommand}
   */
  describeAvailabilityZones(
    args: DescribeAvailabilityZonesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeAvailabilityZonesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeAwsNetworkPerformanceMetricSubscriptionsCommand}
   */
  describeAwsNetworkPerformanceMetricSubscriptions(
    args: DescribeAwsNetworkPerformanceMetricSubscriptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeAwsNetworkPerformanceMetricSubscriptionsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  describeAwsNetworkPerformanceMetricSubscriptionsStream(
    args: DescribeAwsNetworkPerformanceMetricSubscriptionsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    DescribeAwsNetworkPerformanceMetricSubscriptionsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeBundleTasksCommand}
   */
  describeBundleTasks(
    args: DescribeBundleTasksCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeBundleTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeByoipCidrsCommand}
   */
  describeByoipCidrs(
    args: DescribeByoipCidrsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeByoipCidrsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeByoipCidrsStream(
    args: DescribeByoipCidrsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeByoipCidrsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeCapacityBlockExtensionHistoryCommand}
   */
  describeCapacityBlockExtensionHistory(
    args: DescribeCapacityBlockExtensionHistoryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeCapacityBlockExtensionHistoryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeCapacityBlockExtensionHistoryStream(
    args: DescribeCapacityBlockExtensionHistoryCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeCapacityBlockExtensionHistoryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeCapacityBlockExtensionOfferingsCommand}
   */
  describeCapacityBlockExtensionOfferings(
    args: DescribeCapacityBlockExtensionOfferingsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeCapacityBlockExtensionOfferingsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  describeCapacityBlockExtensionOfferingsStream(
    args: DescribeCapacityBlockExtensionOfferingsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    DescribeCapacityBlockExtensionOfferingsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeCapacityBlockOfferingsCommand}
   */
  describeCapacityBlockOfferings(
    args: DescribeCapacityBlockOfferingsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeCapacityBlockOfferingsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeCapacityBlockOfferingsStream(
    args: DescribeCapacityBlockOfferingsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeCapacityBlockOfferingsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeCapacityBlockStatusCommand}
   */
  describeCapacityBlockStatus(
    args: DescribeCapacityBlockStatusCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeCapacityBlockStatusCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeCapacityBlockStatusStream(
    args: DescribeCapacityBlockStatusCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeCapacityBlockStatusCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeCapacityBlocksCommand}
   */
  describeCapacityBlocks(
    args: DescribeCapacityBlocksCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeCapacityBlocksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeCapacityBlocksStream(
    args: DescribeCapacityBlocksCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeCapacityBlocksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeCapacityManagerDataExportsCommand}
   */
  describeCapacityManagerDataExports(
    args: DescribeCapacityManagerDataExportsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeCapacityManagerDataExportsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeCapacityManagerDataExportsStream(
    args: DescribeCapacityManagerDataExportsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeCapacityManagerDataExportsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeCapacityReservationBillingRequestsCommand}
   */
  describeCapacityReservationBillingRequests(
    args: DescribeCapacityReservationBillingRequestsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeCapacityReservationBillingRequestsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  describeCapacityReservationBillingRequestsStream(
    args: DescribeCapacityReservationBillingRequestsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    DescribeCapacityReservationBillingRequestsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeCapacityReservationCancellationQuotesCommand}
   */
  describeCapacityReservationCancellationQuotes(
    args: DescribeCapacityReservationCancellationQuotesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeCapacityReservationCancellationQuotesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeCapacityReservationDateChangeQuotesCommand}
   */
  describeCapacityReservationDateChangeQuotes(
    args: DescribeCapacityReservationDateChangeQuotesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeCapacityReservationDateChangeQuotesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  describeCapacityReservationDateChangeQuotesStream(
    args: DescribeCapacityReservationDateChangeQuotesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    DescribeCapacityReservationDateChangeQuotesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeCapacityReservationFleetsCommand}
   */
  describeCapacityReservationFleets(
    args: DescribeCapacityReservationFleetsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeCapacityReservationFleetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeCapacityReservationFleetsStream(
    args: DescribeCapacityReservationFleetsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeCapacityReservationFleetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeCapacityReservationTopologyCommand}
   */
  describeCapacityReservationTopology(
    args: DescribeCapacityReservationTopologyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeCapacityReservationTopologyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeCapacityReservationsCommand}
   */
  describeCapacityReservations(
    args: DescribeCapacityReservationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeCapacityReservationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeCapacityReservationsStream(
    args: DescribeCapacityReservationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeCapacityReservationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeCarrierGatewaysCommand}
   */
  describeCarrierGateways(
    args: DescribeCarrierGatewaysCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeCarrierGatewaysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeCarrierGatewaysStream(
    args: DescribeCarrierGatewaysCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeCarrierGatewaysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeClassicLinkInstancesCommand}
   */
  describeClassicLinkInstances(
    args: DescribeClassicLinkInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeClassicLinkInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeClassicLinkInstancesStream(
    args: DescribeClassicLinkInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeClassicLinkInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeClientVpnAuthorizationRulesCommand}
   */
  describeClientVpnAuthorizationRules(
    args: DescribeClientVpnAuthorizationRulesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeClientVpnAuthorizationRulesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeClientVpnAuthorizationRulesStream(
    args: DescribeClientVpnAuthorizationRulesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeClientVpnAuthorizationRulesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeClientVpnConnectionsCommand}
   */
  describeClientVpnConnections(
    args: DescribeClientVpnConnectionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeClientVpnConnectionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeClientVpnConnectionsStream(
    args: DescribeClientVpnConnectionsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeClientVpnConnectionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeClientVpnEndpointsCommand}
   */
  describeClientVpnEndpoints(
    args: DescribeClientVpnEndpointsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeClientVpnEndpointsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeClientVpnEndpointsStream(
    args: DescribeClientVpnEndpointsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeClientVpnEndpointsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeClientVpnRoutesCommand}
   */
  describeClientVpnRoutes(
    args: DescribeClientVpnRoutesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeClientVpnRoutesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeClientVpnRoutesStream(
    args: DescribeClientVpnRoutesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeClientVpnRoutesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeClientVpnTargetNetworksCommand}
   */
  describeClientVpnTargetNetworks(
    args: DescribeClientVpnTargetNetworksCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeClientVpnTargetNetworksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeClientVpnTargetNetworksStream(
    args: DescribeClientVpnTargetNetworksCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeClientVpnTargetNetworksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeCoipPoolsCommand}
   */
  describeCoipPools(
    args: DescribeCoipPoolsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeCoipPoolsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeCoipPoolsStream(
    args: DescribeCoipPoolsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeCoipPoolsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeConversionTasksCommand}
   */
  describeConversionTasks(
    args: DescribeConversionTasksCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeConversionTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeCustomerGatewaysCommand}
   */
  describeCustomerGateways(
    args: DescribeCustomerGatewaysCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeCustomerGatewaysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeDeclarativePoliciesReportsCommand}
   */
  describeDeclarativePoliciesReports(
    args: DescribeDeclarativePoliciesReportsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeDeclarativePoliciesReportsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeDhcpOptionsCommand}
   */
  describeDhcpOptions(
    args: DescribeDhcpOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeDhcpOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeDhcpOptionsStream(
    args: DescribeDhcpOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeDhcpOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeEgressOnlyInternetGatewaysCommand}
   */
  describeEgressOnlyInternetGateways(
    args: DescribeEgressOnlyInternetGatewaysCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeEgressOnlyInternetGatewaysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeEgressOnlyInternetGatewaysStream(
    args: DescribeEgressOnlyInternetGatewaysCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeEgressOnlyInternetGatewaysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeElasticGpusCommand}
   */
  describeElasticGpus(
    args: DescribeElasticGpusCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeElasticGpusCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeExportImageTasksCommand}
   */
  describeExportImageTasks(
    args: DescribeExportImageTasksCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeExportImageTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeExportImageTasksStream(
    args: DescribeExportImageTasksCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeExportImageTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeExportTasksCommand}
   */
  describeExportTasks(
    args: DescribeExportTasksCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeExportTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeFastLaunchImagesCommand}
   */
  describeFastLaunchImages(
    args: DescribeFastLaunchImagesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeFastLaunchImagesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeFastLaunchImagesStream(
    args: DescribeFastLaunchImagesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeFastLaunchImagesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeFastSnapshotRestoresCommand}
   */
  describeFastSnapshotRestores(
    args: DescribeFastSnapshotRestoresCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeFastSnapshotRestoresCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeFastSnapshotRestoresStream(
    args: DescribeFastSnapshotRestoresCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeFastSnapshotRestoresCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeFleetHistoryCommand}
   */
  describeFleetHistory(
    args: DescribeFleetHistoryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeFleetHistoryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeFleetInstancesCommand}
   */
  describeFleetInstances(
    args: DescribeFleetInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeFleetInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeFleetsCommand}
   */
  describeFleets(
    args: DescribeFleetsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeFleetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeFleetsStream(
    args: DescribeFleetsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeFleetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeFlowLogsCommand}
   */
  describeFlowLogs(
    args: DescribeFlowLogsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeFlowLogsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeFlowLogsStream(
    args: DescribeFlowLogsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeFlowLogsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeFpgaImageAttributeCommand}
   */
  describeFpgaImageAttribute(
    args: DescribeFpgaImageAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeFpgaImageAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeFpgaImagesCommand}
   */
  describeFpgaImages(
    args: DescribeFpgaImagesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeFpgaImagesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeFpgaImagesStream(
    args: DescribeFpgaImagesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeFpgaImagesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeHostReservationOfferingsCommand}
   */
  describeHostReservationOfferings(
    args: DescribeHostReservationOfferingsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeHostReservationOfferingsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeHostReservationOfferingsStream(
    args: DescribeHostReservationOfferingsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeHostReservationOfferingsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeHostReservationsCommand}
   */
  describeHostReservations(
    args: DescribeHostReservationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeHostReservationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeHostReservationsStream(
    args: DescribeHostReservationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeHostReservationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeHostsCommand}
   */
  describeHosts(
    args: DescribeHostsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeHostsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeHostsStream(
    args: DescribeHostsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeHostsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeIamInstanceProfileAssociationsCommand}
   */
  describeIamInstanceProfileAssociations(
    args: DescribeIamInstanceProfileAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeIamInstanceProfileAssociationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeIamInstanceProfileAssociationsStream(
    args: DescribeIamInstanceProfileAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeIamInstanceProfileAssociationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeIdFormatCommand}
   */
  describeIdFormat(
    args: DescribeIdFormatCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeIdFormatCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeIdentityIdFormatCommand}
   */
  describeIdentityIdFormat(
    args: DescribeIdentityIdFormatCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeIdentityIdFormatCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeImageAttributeCommand}
   */
  describeImageAttribute(
    args: DescribeImageAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeImageAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeImageReferencesCommand}
   */
  describeImageReferences(
    args: DescribeImageReferencesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeImageReferencesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeImageReferencesStream(
    args: DescribeImageReferencesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeImageReferencesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeImageUsageReportEntriesCommand}
   */
  describeImageUsageReportEntries(
    args: DescribeImageUsageReportEntriesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeImageUsageReportEntriesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeImageUsageReportEntriesStream(
    args: DescribeImageUsageReportEntriesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeImageUsageReportEntriesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeImageUsageReportsCommand}
   */
  describeImageUsageReports(
    args: DescribeImageUsageReportsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeImageUsageReportsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeImageUsageReportsStream(
    args: DescribeImageUsageReportsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeImageUsageReportsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeImagesCommand}
   */
  describeImages(
    args: DescribeImagesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeImagesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeImagesStream(
    args: DescribeImagesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeImagesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeImportImageTasksCommand}
   */
  describeImportImageTasks(
    args: DescribeImportImageTasksCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeImportImageTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeImportImageTasksStream(
    args: DescribeImportImageTasksCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeImportImageTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeImportSnapshotTasksCommand}
   */
  describeImportSnapshotTasks(
    args: DescribeImportSnapshotTasksCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeImportSnapshotTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeImportSnapshotTasksStream(
    args: DescribeImportSnapshotTasksCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeImportSnapshotTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeInstanceAttributeCommand}
   */
  describeInstanceAttribute(
    args: DescribeInstanceAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeInstanceAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeInstanceConnectEndpointsCommand}
   */
  describeInstanceConnectEndpoints(
    args: DescribeInstanceConnectEndpointsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeInstanceConnectEndpointsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeInstanceConnectEndpointsStream(
    args: DescribeInstanceConnectEndpointsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeInstanceConnectEndpointsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeInstanceCreditSpecificationsCommand}
   */
  describeInstanceCreditSpecifications(
    args: DescribeInstanceCreditSpecificationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeInstanceCreditSpecificationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeInstanceCreditSpecificationsStream(
    args: DescribeInstanceCreditSpecificationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeInstanceCreditSpecificationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeInstanceEventNotificationAttributesCommand}
   */
  describeInstanceEventNotificationAttributes(
    args: DescribeInstanceEventNotificationAttributesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeInstanceEventNotificationAttributesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeInstanceEventWindowsCommand}
   */
  describeInstanceEventWindows(
    args: DescribeInstanceEventWindowsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeInstanceEventWindowsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeInstanceEventWindowsStream(
    args: DescribeInstanceEventWindowsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeInstanceEventWindowsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeInstanceImageMetadataCommand}
   */
  describeInstanceImageMetadata(
    args: DescribeInstanceImageMetadataCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeInstanceImageMetadataCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeInstanceImageMetadataStream(
    args: DescribeInstanceImageMetadataCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeInstanceImageMetadataCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeInstanceSqlHaHistoryStatesCommand}
   */
  describeInstanceSqlHaHistoryStates(
    args: DescribeInstanceSqlHaHistoryStatesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeInstanceSqlHaHistoryStatesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeInstanceSqlHaStatesCommand}
   */
  describeInstanceSqlHaStates(
    args: DescribeInstanceSqlHaStatesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeInstanceSqlHaStatesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeInstanceStatusCommand}
   */
  describeInstanceStatus(
    args: DescribeInstanceStatusCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeInstanceStatusCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeInstanceStatusStream(
    args: DescribeInstanceStatusCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeInstanceStatusCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeInstanceTopologyCommand}
   */
  describeInstanceTopology(
    args: DescribeInstanceTopologyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeInstanceTopologyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeInstanceTopologyStream(
    args: DescribeInstanceTopologyCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeInstanceTopologyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeInstanceTypeOfferingsCommand}
   */
  describeInstanceTypeOfferings(
    args: DescribeInstanceTypeOfferingsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeInstanceTypeOfferingsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeInstanceTypeOfferingsStream(
    args: DescribeInstanceTypeOfferingsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeInstanceTypeOfferingsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeInstanceTypesCommand}
   */
  describeInstanceTypes(
    args: DescribeInstanceTypesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeInstanceTypesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeInstanceTypesStream(
    args: DescribeInstanceTypesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeInstanceTypesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeInstancesCommand}
   */
  describeInstances(
    args: DescribeInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeInstancesStream(
    args: DescribeInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeInternetGatewaysCommand}
   */
  describeInternetGateways(
    args: DescribeInternetGatewaysCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeInternetGatewaysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeInternetGatewaysStream(
    args: DescribeInternetGatewaysCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeInternetGatewaysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeIpamByoasnCommand}
   */
  describeIpamByoasn(
    args: DescribeIpamByoasnCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeIpamByoasnCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeIpamExternalResourceVerificationTokensCommand}
   */
  describeIpamExternalResourceVerificationTokens(
    args: DescribeIpamExternalResourceVerificationTokensCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeIpamExternalResourceVerificationTokensCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeIpamInternetRegistryAssociationsCommand}
   */
  describeIpamInternetRegistryAssociations(
    args: DescribeIpamInternetRegistryAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeIpamInternetRegistryAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeIpamPoliciesCommand}
   */
  describeIpamPolicies(
    args: DescribeIpamPoliciesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeIpamPoliciesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeIpamPoolAllocationsCommand}
   */
  describeIpamPoolAllocations(
    args: DescribeIpamPoolAllocationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeIpamPoolAllocationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeIpamPoolAllocationsStream(
    args: DescribeIpamPoolAllocationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeIpamPoolAllocationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeIpamPoolsCommand}
   */
  describeIpamPools(
    args: DescribeIpamPoolsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeIpamPoolsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeIpamPoolsStream(
    args: DescribeIpamPoolsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeIpamPoolsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeIpamPrefixListResolverTargetsCommand}
   */
  describeIpamPrefixListResolverTargets(
    args: DescribeIpamPrefixListResolverTargetsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeIpamPrefixListResolverTargetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeIpamPrefixListResolverTargetsStream(
    args: DescribeIpamPrefixListResolverTargetsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeIpamPrefixListResolverTargetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeIpamPrefixListResolversCommand}
   */
  describeIpamPrefixListResolvers(
    args: DescribeIpamPrefixListResolversCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeIpamPrefixListResolversCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeIpamPrefixListResolversStream(
    args: DescribeIpamPrefixListResolversCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeIpamPrefixListResolversCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeIpamResourceDiscoveriesCommand}
   */
  describeIpamResourceDiscoveries(
    args: DescribeIpamResourceDiscoveriesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeIpamResourceDiscoveriesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeIpamResourceDiscoveriesStream(
    args: DescribeIpamResourceDiscoveriesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeIpamResourceDiscoveriesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeIpamResourceDiscoveryAssociationsCommand}
   */
  describeIpamResourceDiscoveryAssociations(
    args: DescribeIpamResourceDiscoveryAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeIpamResourceDiscoveryAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  describeIpamResourceDiscoveryAssociationsStream(
    args: DescribeIpamResourceDiscoveryAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    DescribeIpamResourceDiscoveryAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeIpamScopesCommand}
   */
  describeIpamScopes(
    args: DescribeIpamScopesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeIpamScopesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeIpamScopesStream(
    args: DescribeIpamScopesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeIpamScopesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeIpamsCommand}
   */
  describeIpams(
    args: DescribeIpamsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeIpamsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeIpamsStream(
    args: DescribeIpamsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeIpamsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeIpv6PoolsCommand}
   */
  describeIpv6Pools(
    args: DescribeIpv6PoolsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeIpv6PoolsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeIpv6PoolsStream(
    args: DescribeIpv6PoolsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeIpv6PoolsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeKeyPairsCommand}
   */
  describeKeyPairs(
    args: DescribeKeyPairsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeKeyPairsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeLaunchTemplateVersionsCommand}
   */
  describeLaunchTemplateVersions(
    args: DescribeLaunchTemplateVersionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeLaunchTemplateVersionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeLaunchTemplateVersionsStream(
    args: DescribeLaunchTemplateVersionsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeLaunchTemplateVersionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeLaunchTemplatesCommand}
   */
  describeLaunchTemplates(
    args: DescribeLaunchTemplatesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeLaunchTemplatesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeLaunchTemplatesStream(
    args: DescribeLaunchTemplatesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeLaunchTemplatesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsCommand}
   */
  describeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(
    args: DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  describeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsStream(
    args: DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeLocalGatewayRouteTableVpcAssociationsCommand}
   */
  describeLocalGatewayRouteTableVpcAssociations(
    args: DescribeLocalGatewayRouteTableVpcAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeLocalGatewayRouteTableVpcAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  describeLocalGatewayRouteTableVpcAssociationsStream(
    args: DescribeLocalGatewayRouteTableVpcAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    DescribeLocalGatewayRouteTableVpcAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeLocalGatewayRouteTablesCommand}
   */
  describeLocalGatewayRouteTables(
    args: DescribeLocalGatewayRouteTablesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeLocalGatewayRouteTablesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeLocalGatewayRouteTablesStream(
    args: DescribeLocalGatewayRouteTablesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeLocalGatewayRouteTablesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeLocalGatewayVirtualInterfaceGroupsCommand}
   */
  describeLocalGatewayVirtualInterfaceGroups(
    args: DescribeLocalGatewayVirtualInterfaceGroupsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeLocalGatewayVirtualInterfaceGroupsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  describeLocalGatewayVirtualInterfaceGroupsStream(
    args: DescribeLocalGatewayVirtualInterfaceGroupsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    DescribeLocalGatewayVirtualInterfaceGroupsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeLocalGatewayVirtualInterfacesCommand}
   */
  describeLocalGatewayVirtualInterfaces(
    args: DescribeLocalGatewayVirtualInterfacesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeLocalGatewayVirtualInterfacesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeLocalGatewayVirtualInterfacesStream(
    args: DescribeLocalGatewayVirtualInterfacesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeLocalGatewayVirtualInterfacesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeLocalGatewaysCommand}
   */
  describeLocalGateways(
    args: DescribeLocalGatewaysCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeLocalGatewaysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeLocalGatewaysStream(
    args: DescribeLocalGatewaysCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeLocalGatewaysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeLockedSnapshotsCommand}
   */
  describeLockedSnapshots(
    args: DescribeLockedSnapshotsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeLockedSnapshotsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeMacHostsCommand}
   */
  describeMacHosts(
    args: DescribeMacHostsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeMacHostsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeMacHostsStream(
    args: DescribeMacHostsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeMacHostsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeMacModificationTasksCommand}
   */
  describeMacModificationTasks(
    args: DescribeMacModificationTasksCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeMacModificationTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeMacModificationTasksStream(
    args: DescribeMacModificationTasksCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeMacModificationTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeManagedPrefixListsCommand}
   */
  describeManagedPrefixLists(
    args: DescribeManagedPrefixListsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeManagedPrefixListsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeManagedPrefixListsStream(
    args: DescribeManagedPrefixListsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeManagedPrefixListsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeMovingAddressesCommand}
   */
  describeMovingAddresses(
    args: DescribeMovingAddressesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeMovingAddressesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeMovingAddressesStream(
    args: DescribeMovingAddressesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeMovingAddressesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeNatGatewaysCommand}
   */
  describeNatGateways(
    args: DescribeNatGatewaysCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeNatGatewaysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeNatGatewaysStream(
    args: DescribeNatGatewaysCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeNatGatewaysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeNetworkAclsCommand}
   */
  describeNetworkAcls(
    args: DescribeNetworkAclsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeNetworkAclsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeNetworkAclsStream(
    args: DescribeNetworkAclsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeNetworkAclsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeNetworkInsightsAccessScopeAnalysesCommand}
   */
  describeNetworkInsightsAccessScopeAnalyses(
    args: DescribeNetworkInsightsAccessScopeAnalysesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeNetworkInsightsAccessScopeAnalysesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  describeNetworkInsightsAccessScopeAnalysesStream(
    args: DescribeNetworkInsightsAccessScopeAnalysesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    DescribeNetworkInsightsAccessScopeAnalysesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeNetworkInsightsAccessScopesCommand}
   */
  describeNetworkInsightsAccessScopes(
    args: DescribeNetworkInsightsAccessScopesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeNetworkInsightsAccessScopesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeNetworkInsightsAccessScopesStream(
    args: DescribeNetworkInsightsAccessScopesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeNetworkInsightsAccessScopesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeNetworkInsightsAnalysesCommand}
   */
  describeNetworkInsightsAnalyses(
    args: DescribeNetworkInsightsAnalysesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeNetworkInsightsAnalysesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeNetworkInsightsAnalysesStream(
    args: DescribeNetworkInsightsAnalysesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeNetworkInsightsAnalysesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeNetworkInsightsPathsCommand}
   */
  describeNetworkInsightsPaths(
    args: DescribeNetworkInsightsPathsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeNetworkInsightsPathsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeNetworkInsightsPathsStream(
    args: DescribeNetworkInsightsPathsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeNetworkInsightsPathsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeNetworkInterfaceAttributeCommand}
   */
  describeNetworkInterfaceAttribute(
    args: DescribeNetworkInterfaceAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeNetworkInterfaceAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeNetworkInterfacePermissionsCommand}
   */
  describeNetworkInterfacePermissions(
    args: DescribeNetworkInterfacePermissionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeNetworkInterfacePermissionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeNetworkInterfacePermissionsStream(
    args: DescribeNetworkInterfacePermissionsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeNetworkInterfacePermissionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeNetworkInterfacesCommand}
   */
  describeNetworkInterfaces(
    args: DescribeNetworkInterfacesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeNetworkInterfacesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeNetworkInterfacesStream(
    args: DescribeNetworkInterfacesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeNetworkInterfacesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeOutpostLagsCommand}
   */
  describeOutpostLags(
    args: DescribeOutpostLagsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeOutpostLagsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribePlacementGroupsCommand}
   */
  describePlacementGroups(
    args: DescribePlacementGroupsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribePlacementGroupsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribePrefixListsCommand}
   */
  describePrefixLists(
    args: DescribePrefixListsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribePrefixListsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describePrefixListsStream(
    args: DescribePrefixListsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribePrefixListsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribePrincipalIdFormatCommand}
   */
  describePrincipalIdFormat(
    args: DescribePrincipalIdFormatCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribePrincipalIdFormatCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describePrincipalIdFormatStream(
    args: DescribePrincipalIdFormatCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribePrincipalIdFormatCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribePublicIpv4PoolsCommand}
   */
  describePublicIpv4Pools(
    args: DescribePublicIpv4PoolsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribePublicIpv4PoolsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describePublicIpv4PoolsStream(
    args: DescribePublicIpv4PoolsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribePublicIpv4PoolsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeRegionsCommand}
   */
  describeRegions(
    args: DescribeRegionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeRegionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeReplaceRootVolumeTasksCommand}
   */
  describeReplaceRootVolumeTasks(
    args: DescribeReplaceRootVolumeTasksCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeReplaceRootVolumeTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeReplaceRootVolumeTasksStream(
    args: DescribeReplaceRootVolumeTasksCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeReplaceRootVolumeTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeReservedInstancesCommand}
   */
  describeReservedInstances(
    args: DescribeReservedInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeReservedInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeReservedInstancesListingsCommand}
   */
  describeReservedInstancesListings(
    args: DescribeReservedInstancesListingsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeReservedInstancesListingsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeReservedInstancesModificationsCommand}
   */
  describeReservedInstancesModifications(
    args: DescribeReservedInstancesModificationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeReservedInstancesModificationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeReservedInstancesModificationsStream(
    args: DescribeReservedInstancesModificationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeReservedInstancesModificationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeReservedInstancesOfferingsCommand}
   */
  describeReservedInstancesOfferings(
    args: DescribeReservedInstancesOfferingsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeReservedInstancesOfferingsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeReservedInstancesOfferingsStream(
    args: DescribeReservedInstancesOfferingsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeReservedInstancesOfferingsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeRouteServerEndpointsCommand}
   */
  describeRouteServerEndpoints(
    args: DescribeRouteServerEndpointsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeRouteServerEndpointsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeRouteServerEndpointsStream(
    args: DescribeRouteServerEndpointsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeRouteServerEndpointsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeRouteServerPeersCommand}
   */
  describeRouteServerPeers(
    args: DescribeRouteServerPeersCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeRouteServerPeersCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeRouteServerPeersStream(
    args: DescribeRouteServerPeersCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeRouteServerPeersCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeRouteServersCommand}
   */
  describeRouteServers(
    args: DescribeRouteServersCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeRouteServersCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeRouteServersStream(
    args: DescribeRouteServersCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeRouteServersCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeRouteTablesCommand}
   */
  describeRouteTables(
    args: DescribeRouteTablesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeRouteTablesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeRouteTablesStream(
    args: DescribeRouteTablesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeRouteTablesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeScheduledInstanceAvailabilityCommand}
   */
  describeScheduledInstanceAvailability(
    args: DescribeScheduledInstanceAvailabilityCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeScheduledInstanceAvailabilityCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeScheduledInstanceAvailabilityStream(
    args: DescribeScheduledInstanceAvailabilityCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeScheduledInstanceAvailabilityCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeScheduledInstancesCommand}
   */
  describeScheduledInstances(
    args: DescribeScheduledInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeScheduledInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeScheduledInstancesStream(
    args: DescribeScheduledInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeScheduledInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSecondaryInterfacesCommand}
   */
  describeSecondaryInterfaces(
    args: DescribeSecondaryInterfacesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSecondaryInterfacesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeSecondaryInterfacesStream(
    args: DescribeSecondaryInterfacesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeSecondaryInterfacesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSecondaryNetworksCommand}
   */
  describeSecondaryNetworks(
    args: DescribeSecondaryNetworksCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSecondaryNetworksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeSecondaryNetworksStream(
    args: DescribeSecondaryNetworksCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeSecondaryNetworksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSecondarySubnetsCommand}
   */
  describeSecondarySubnets(
    args: DescribeSecondarySubnetsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSecondarySubnetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeSecondarySubnetsStream(
    args: DescribeSecondarySubnetsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeSecondarySubnetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSecurityGroupReferencesCommand}
   */
  describeSecurityGroupReferences(
    args: DescribeSecurityGroupReferencesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSecurityGroupReferencesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSecurityGroupRulesCommand}
   */
  describeSecurityGroupRules(
    args: DescribeSecurityGroupRulesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSecurityGroupRulesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeSecurityGroupRulesStream(
    args: DescribeSecurityGroupRulesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeSecurityGroupRulesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSecurityGroupVpcAssociationsCommand}
   */
  describeSecurityGroupVpcAssociations(
    args: DescribeSecurityGroupVpcAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSecurityGroupVpcAssociationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeSecurityGroupVpcAssociationsStream(
    args: DescribeSecurityGroupVpcAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeSecurityGroupVpcAssociationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSecurityGroupsCommand}
   */
  describeSecurityGroups(
    args: DescribeSecurityGroupsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSecurityGroupsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeSecurityGroupsStream(
    args: DescribeSecurityGroupsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeSecurityGroupsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeServiceLinkVirtualInterfacesCommand}
   */
  describeServiceLinkVirtualInterfaces(
    args: DescribeServiceLinkVirtualInterfacesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeServiceLinkVirtualInterfacesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSnapshotAttributeCommand}
   */
  describeSnapshotAttribute(
    args: DescribeSnapshotAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSnapshotAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSnapshotTierStatusCommand}
   */
  describeSnapshotTierStatus(
    args: DescribeSnapshotTierStatusCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSnapshotTierStatusCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeSnapshotTierStatusStream(
    args: DescribeSnapshotTierStatusCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeSnapshotTierStatusCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSnapshotsCommand}
   */
  describeSnapshots(
    args: DescribeSnapshotsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSnapshotsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeSnapshotsStream(
    args: DescribeSnapshotsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeSnapshotsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSpotDatafeedSubscriptionCommand}
   */
  describeSpotDatafeedSubscription(
    args: DescribeSpotDatafeedSubscriptionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSpotDatafeedSubscriptionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSpotFleetInstancesCommand}
   */
  describeSpotFleetInstances(
    args: DescribeSpotFleetInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSpotFleetInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSpotFleetRequestHistoryCommand}
   */
  describeSpotFleetRequestHistory(
    args: DescribeSpotFleetRequestHistoryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSpotFleetRequestHistoryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSpotFleetRequestsCommand}
   */
  describeSpotFleetRequests(
    args: DescribeSpotFleetRequestsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSpotFleetRequestsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeSpotFleetRequestsStream(
    args: DescribeSpotFleetRequestsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeSpotFleetRequestsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSpotInstanceRequestsCommand}
   */
  describeSpotInstanceRequests(
    args: DescribeSpotInstanceRequestsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSpotInstanceRequestsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeSpotInstanceRequestsStream(
    args: DescribeSpotInstanceRequestsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeSpotInstanceRequestsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSpotPriceHistoryCommand}
   */
  describeSpotPriceHistory(
    args: DescribeSpotPriceHistoryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSpotPriceHistoryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeSpotPriceHistoryStream(
    args: DescribeSpotPriceHistoryCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeSpotPriceHistoryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeStaleSecurityGroupsCommand}
   */
  describeStaleSecurityGroups(
    args: DescribeStaleSecurityGroupsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeStaleSecurityGroupsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeStaleSecurityGroupsStream(
    args: DescribeStaleSecurityGroupsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeStaleSecurityGroupsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeStoreImageTasksCommand}
   */
  describeStoreImageTasks(
    args: DescribeStoreImageTasksCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeStoreImageTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeStoreImageTasksStream(
    args: DescribeStoreImageTasksCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeStoreImageTasksCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeSubnetsCommand}
   */
  describeSubnets(
    args: DescribeSubnetsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeSubnetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeSubnetsStream(
    args: DescribeSubnetsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeSubnetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTagsCommand}
   */
  describeTags(
    args: DescribeTagsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTagsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeTagsStream(
    args: DescribeTagsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeTagsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTrafficMirrorFilterRulesCommand}
   */
  describeTrafficMirrorFilterRules(
    args: DescribeTrafficMirrorFilterRulesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTrafficMirrorFilterRulesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTrafficMirrorFiltersCommand}
   */
  describeTrafficMirrorFilters(
    args: DescribeTrafficMirrorFiltersCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTrafficMirrorFiltersCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeTrafficMirrorFiltersStream(
    args: DescribeTrafficMirrorFiltersCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeTrafficMirrorFiltersCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTrafficMirrorSessionsCommand}
   */
  describeTrafficMirrorSessions(
    args: DescribeTrafficMirrorSessionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTrafficMirrorSessionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeTrafficMirrorSessionsStream(
    args: DescribeTrafficMirrorSessionsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeTrafficMirrorSessionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTrafficMirrorTargetsCommand}
   */
  describeTrafficMirrorTargets(
    args: DescribeTrafficMirrorTargetsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTrafficMirrorTargetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeTrafficMirrorTargetsStream(
    args: DescribeTrafficMirrorTargetsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeTrafficMirrorTargetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTransitGatewayAttachmentsCommand}
   */
  describeTransitGatewayAttachments(
    args: DescribeTransitGatewayAttachmentsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTransitGatewayAttachmentsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeTransitGatewayAttachmentsStream(
    args: DescribeTransitGatewayAttachmentsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeTransitGatewayAttachmentsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTransitGatewayConnectPeersCommand}
   */
  describeTransitGatewayConnectPeers(
    args: DescribeTransitGatewayConnectPeersCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTransitGatewayConnectPeersCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeTransitGatewayConnectPeersStream(
    args: DescribeTransitGatewayConnectPeersCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeTransitGatewayConnectPeersCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTransitGatewayConnectsCommand}
   */
  describeTransitGatewayConnects(
    args: DescribeTransitGatewayConnectsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTransitGatewayConnectsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeTransitGatewayConnectsStream(
    args: DescribeTransitGatewayConnectsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeTransitGatewayConnectsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTransitGatewayMeteringPoliciesCommand}
   */
  describeTransitGatewayMeteringPolicies(
    args: DescribeTransitGatewayMeteringPoliciesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTransitGatewayMeteringPoliciesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTransitGatewayMulticastDomainsCommand}
   */
  describeTransitGatewayMulticastDomains(
    args: DescribeTransitGatewayMulticastDomainsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTransitGatewayMulticastDomainsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeTransitGatewayMulticastDomainsStream(
    args: DescribeTransitGatewayMulticastDomainsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeTransitGatewayMulticastDomainsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTransitGatewayPeeringAttachmentsCommand}
   */
  describeTransitGatewayPeeringAttachments(
    args: DescribeTransitGatewayPeeringAttachmentsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeTransitGatewayPeeringAttachmentsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  describeTransitGatewayPeeringAttachmentsStream(
    args: DescribeTransitGatewayPeeringAttachmentsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    DescribeTransitGatewayPeeringAttachmentsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeTransitGatewayPolicyTablesCommand}
   */
  describeTransitGatewayPolicyTables(
    args: DescribeTransitGatewayPolicyTablesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTransitGatewayPolicyTablesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeTransitGatewayPolicyTablesStream(
    args: DescribeTransitGatewayPolicyTablesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeTransitGatewayPolicyTablesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTransitGatewayRouteTableAnnouncementsCommand}
   */
  describeTransitGatewayRouteTableAnnouncements(
    args: DescribeTransitGatewayRouteTableAnnouncementsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeTransitGatewayRouteTableAnnouncementsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  describeTransitGatewayRouteTableAnnouncementsStream(
    args: DescribeTransitGatewayRouteTableAnnouncementsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    DescribeTransitGatewayRouteTableAnnouncementsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeTransitGatewayRouteTablesCommand}
   */
  describeTransitGatewayRouteTables(
    args: DescribeTransitGatewayRouteTablesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTransitGatewayRouteTablesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeTransitGatewayRouteTablesStream(
    args: DescribeTransitGatewayRouteTablesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeTransitGatewayRouteTablesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTransitGatewayVpcAttachmentsCommand}
   */
  describeTransitGatewayVpcAttachments(
    args: DescribeTransitGatewayVpcAttachmentsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTransitGatewayVpcAttachmentsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeTransitGatewayVpcAttachmentsStream(
    args: DescribeTransitGatewayVpcAttachmentsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeTransitGatewayVpcAttachmentsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTransitGatewaysCommand}
   */
  describeTransitGateways(
    args: DescribeTransitGatewaysCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTransitGatewaysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeTransitGatewaysStream(
    args: DescribeTransitGatewaysCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeTransitGatewaysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeTrunkInterfaceAssociationsCommand}
   */
  describeTrunkInterfaceAssociations(
    args: DescribeTrunkInterfaceAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeTrunkInterfaceAssociationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeTrunkInterfaceAssociationsStream(
    args: DescribeTrunkInterfaceAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeTrunkInterfaceAssociationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVerifiedAccessEndpointsCommand}
   */
  describeVerifiedAccessEndpoints(
    args: DescribeVerifiedAccessEndpointsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVerifiedAccessEndpointsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeVerifiedAccessEndpointsStream(
    args: DescribeVerifiedAccessEndpointsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeVerifiedAccessEndpointsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVerifiedAccessGroupsCommand}
   */
  describeVerifiedAccessGroups(
    args: DescribeVerifiedAccessGroupsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVerifiedAccessGroupsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeVerifiedAccessGroupsStream(
    args: DescribeVerifiedAccessGroupsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeVerifiedAccessGroupsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVerifiedAccessInstanceLoggingConfigurationsCommand}
   */
  describeVerifiedAccessInstanceLoggingConfigurations(
    args: DescribeVerifiedAccessInstanceLoggingConfigurationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeVerifiedAccessInstanceLoggingConfigurationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  describeVerifiedAccessInstanceLoggingConfigurationsStream(
    args: DescribeVerifiedAccessInstanceLoggingConfigurationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    DescribeVerifiedAccessInstanceLoggingConfigurationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeVerifiedAccessInstancesCommand}
   */
  describeVerifiedAccessInstances(
    args: DescribeVerifiedAccessInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVerifiedAccessInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeVerifiedAccessInstancesStream(
    args: DescribeVerifiedAccessInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeVerifiedAccessInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVerifiedAccessTrustProvidersCommand}
   */
  describeVerifiedAccessTrustProviders(
    args: DescribeVerifiedAccessTrustProvidersCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVerifiedAccessTrustProvidersCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeVerifiedAccessTrustProvidersStream(
    args: DescribeVerifiedAccessTrustProvidersCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeVerifiedAccessTrustProvidersCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVolumeAttributeCommand}
   */
  describeVolumeAttribute(
    args: DescribeVolumeAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVolumeAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVolumeStatusCommand}
   */
  describeVolumeStatus(
    args: DescribeVolumeStatusCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVolumeStatusCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeVolumeStatusStream(
    args: DescribeVolumeStatusCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeVolumeStatusCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVolumesCommand}
   */
  describeVolumes(
    args: DescribeVolumesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVolumesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeVolumesStream(
    args: DescribeVolumesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeVolumesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVolumesModificationsCommand}
   */
  describeVolumesModifications(
    args: DescribeVolumesModificationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVolumesModificationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeVolumesModificationsStream(
    args: DescribeVolumesModificationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeVolumesModificationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpcAttributeCommand}
   */
  describeVpcAttribute(
    args: DescribeVpcAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpcAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpcBlockPublicAccessExclusionsCommand}
   */
  describeVpcBlockPublicAccessExclusions(
    args: DescribeVpcBlockPublicAccessExclusionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpcBlockPublicAccessExclusionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpcBlockPublicAccessOptionsCommand}
   */
  describeVpcBlockPublicAccessOptions(
    args: DescribeVpcBlockPublicAccessOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpcBlockPublicAccessOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpcClassicLinkCommand}
   */
  describeVpcClassicLink(
    args: DescribeVpcClassicLinkCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpcClassicLinkCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpcClassicLinkDnsSupportCommand}
   */
  describeVpcClassicLinkDnsSupport(
    args: DescribeVpcClassicLinkDnsSupportCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpcClassicLinkDnsSupportCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeVpcClassicLinkDnsSupportStream(
    args: DescribeVpcClassicLinkDnsSupportCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeVpcClassicLinkDnsSupportCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpcEncryptionControlsCommand}
   */
  describeVpcEncryptionControls(
    args: DescribeVpcEncryptionControlsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpcEncryptionControlsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpcEndpointAssociationsCommand}
   */
  describeVpcEndpointAssociations(
    args: DescribeVpcEndpointAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpcEndpointAssociationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpcEndpointConnectionNotificationsCommand}
   */
  describeVpcEndpointConnectionNotifications(
    args: DescribeVpcEndpointConnectionNotificationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeVpcEndpointConnectionNotificationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  describeVpcEndpointConnectionNotificationsStream(
    args: DescribeVpcEndpointConnectionNotificationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    DescribeVpcEndpointConnectionNotificationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeVpcEndpointConnectionsCommand}
   */
  describeVpcEndpointConnections(
    args: DescribeVpcEndpointConnectionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpcEndpointConnectionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeVpcEndpointConnectionsStream(
    args: DescribeVpcEndpointConnectionsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeVpcEndpointConnectionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpcEndpointServiceConfigurationsCommand}
   */
  describeVpcEndpointServiceConfigurations(
    args: DescribeVpcEndpointServiceConfigurationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DescribeVpcEndpointServiceConfigurationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  describeVpcEndpointServiceConfigurationsStream(
    args: DescribeVpcEndpointServiceConfigurationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    DescribeVpcEndpointServiceConfigurationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DescribeVpcEndpointServicePermissionsCommand}
   */
  describeVpcEndpointServicePermissions(
    args: DescribeVpcEndpointServicePermissionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpcEndpointServicePermissionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeVpcEndpointServicePermissionsStream(
    args: DescribeVpcEndpointServicePermissionsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeVpcEndpointServicePermissionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpcEndpointServicesCommand}
   */
  describeVpcEndpointServices(
    args: DescribeVpcEndpointServicesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpcEndpointServicesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpcEndpointsCommand}
   */
  describeVpcEndpoints(
    args: DescribeVpcEndpointsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpcEndpointsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeVpcEndpointsStream(
    args: DescribeVpcEndpointsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeVpcEndpointsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpcPeeringConnectionsCommand}
   */
  describeVpcPeeringConnections(
    args: DescribeVpcPeeringConnectionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpcPeeringConnectionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeVpcPeeringConnectionsStream(
    args: DescribeVpcPeeringConnectionsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeVpcPeeringConnectionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpcsCommand}
   */
  describeVpcs(
    args: DescribeVpcsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpcsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeVpcsStream(
    args: DescribeVpcsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeVpcsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpnConcentratorsCommand}
   */
  describeVpnConcentrators(
    args: DescribeVpnConcentratorsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpnConcentratorsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  describeVpnConcentratorsStream(
    args: DescribeVpnConcentratorsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<DescribeVpnConcentratorsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpnConnectionsCommand}
   */
  describeVpnConnections(
    args: DescribeVpnConnectionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpnConnectionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DescribeVpnGatewaysCommand}
   */
  describeVpnGateways(
    args: DescribeVpnGatewaysCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DescribeVpnGatewaysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DetachClassicLinkVpcCommand}
   */
  detachClassicLinkVpc(
    args: DetachClassicLinkVpcCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DetachClassicLinkVpcCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DetachImageWatermarkCommand}
   */
  detachImageWatermark(
    args: DetachImageWatermarkCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DetachImageWatermarkCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DetachInternetGatewayCommand}
   */
  detachInternetGateway(
    args: DetachInternetGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DetachInternetGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DetachNetworkInterfaceCommand}
   */
  detachNetworkInterface(
    args: DetachNetworkInterfaceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DetachNetworkInterfaceCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DetachVerifiedAccessTrustProviderCommand}
   */
  detachVerifiedAccessTrustProvider(
    args: DetachVerifiedAccessTrustProviderCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DetachVerifiedAccessTrustProviderCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DetachVolumeCommand}
   */
  detachVolume(
    args: DetachVolumeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DetachVolumeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DetachVpnGatewayCommand}
   */
  detachVpnGateway(
    args: DetachVpnGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DetachVpnGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableAddressTransferCommand}
   */
  disableAddressTransfer(
    args: DisableAddressTransferCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableAddressTransferCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableAllowedImagesSettingsCommand}
   */
  disableAllowedImagesSettings(
    args: DisableAllowedImagesSettingsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableAllowedImagesSettingsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableApplicationStatusCheckSuppressionCommand}
   */
  disableApplicationStatusCheckSuppression(
    args: DisableApplicationStatusCheckSuppressionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DisableApplicationStatusCheckSuppressionCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DisableAwsNetworkPerformanceMetricSubscriptionCommand}
   */
  disableAwsNetworkPerformanceMetricSubscription(
    args: DisableAwsNetworkPerformanceMetricSubscriptionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DisableAwsNetworkPerformanceMetricSubscriptionCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DisableCapacityManagerCommand}
   */
  disableCapacityManager(
    args: DisableCapacityManagerCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableCapacityManagerCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableEbsEncryptionByDefaultCommand}
   */
  disableEbsEncryptionByDefault(
    args: DisableEbsEncryptionByDefaultCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableEbsEncryptionByDefaultCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableFastLaunchCommand}
   */
  disableFastLaunch(
    args: DisableFastLaunchCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableFastLaunchCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableFastSnapshotRestoresCommand}
   */
  disableFastSnapshotRestores(
    args: DisableFastSnapshotRestoresCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableFastSnapshotRestoresCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableImageCommand}
   */
  disableImage(
    args: DisableImageCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableImageCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableImageBlockPublicAccessCommand}
   */
  disableImageBlockPublicAccess(
    args: DisableImageBlockPublicAccessCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableImageBlockPublicAccessCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableImageDeprecationCommand}
   */
  disableImageDeprecation(
    args: DisableImageDeprecationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableImageDeprecationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableImageDeregistrationProtectionCommand}
   */
  disableImageDeregistrationProtection(
    args: DisableImageDeregistrationProtectionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableImageDeregistrationProtectionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableInstanceSqlHaStandbyDetectionsCommand}
   */
  disableInstanceSqlHaStandbyDetections(
    args: DisableInstanceSqlHaStandbyDetectionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableInstanceSqlHaStandbyDetectionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableIpamOrganizationAdminAccountCommand}
   */
  disableIpamOrganizationAdminAccount(
    args: DisableIpamOrganizationAdminAccountCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableIpamOrganizationAdminAccountCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableIpamPolicyCommand}
   */
  disableIpamPolicy(
    args: DisableIpamPolicyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableIpamPolicyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableRouteServerPropagationCommand}
   */
  disableRouteServerPropagation(
    args: DisableRouteServerPropagationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableRouteServerPropagationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableSerialConsoleAccessCommand}
   */
  disableSerialConsoleAccess(
    args: DisableSerialConsoleAccessCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableSerialConsoleAccessCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableSnapshotBlockPublicAccessCommand}
   */
  disableSnapshotBlockPublicAccess(
    args: DisableSnapshotBlockPublicAccessCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableSnapshotBlockPublicAccessCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableTransitGatewayRouteTablePropagationCommand}
   */
  disableTransitGatewayRouteTablePropagation(
    args: DisableTransitGatewayRouteTablePropagationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DisableTransitGatewayRouteTablePropagationCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DisableVgwRoutePropagationCommand}
   */
  disableVgwRoutePropagation(
    args: DisableVgwRoutePropagationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableVgwRoutePropagationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableVpcClassicLinkCommand}
   */
  disableVpcClassicLink(
    args: DisableVpcClassicLinkCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableVpcClassicLinkCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisableVpcClassicLinkDnsSupportCommand}
   */
  disableVpcClassicLinkDnsSupport(
    args: DisableVpcClassicLinkDnsSupportCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisableVpcClassicLinkDnsSupportCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateAddressCommand}
   */
  disassociateAddress(
    args: DisassociateAddressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateAddressCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateApplicationStatusCheckCommand}
   */
  disassociateApplicationStatusCheck(
    args: DisassociateApplicationStatusCheckCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateApplicationStatusCheckCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateCapacityReservationBillingOwnerCommand}
   */
  disassociateCapacityReservationBillingOwner(
    args: DisassociateCapacityReservationBillingOwnerCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DisassociateCapacityReservationBillingOwnerCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DisassociateClientVpnTargetNetworkCommand}
   */
  disassociateClientVpnTargetNetwork(
    args: DisassociateClientVpnTargetNetworkCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateClientVpnTargetNetworkCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateEnclaveCertificateIamRoleCommand}
   */
  disassociateEnclaveCertificateIamRole(
    args: DisassociateEnclaveCertificateIamRoleCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateEnclaveCertificateIamRoleCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateIamInstanceProfileCommand}
   */
  disassociateIamInstanceProfile(
    args: DisassociateIamInstanceProfileCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateIamInstanceProfileCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateInstanceEventWindowCommand}
   */
  disassociateInstanceEventWindow(
    args: DisassociateInstanceEventWindowCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateInstanceEventWindowCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateIpamByoasnCommand}
   */
  disassociateIpamByoasn(
    args: DisassociateIpamByoasnCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateIpamByoasnCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateIpamResourceDiscoveryCommand}
   */
  disassociateIpamResourceDiscovery(
    args: DisassociateIpamResourceDiscoveryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateIpamResourceDiscoveryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateNatGatewayAddressCommand}
   */
  disassociateNatGatewayAddress(
    args: DisassociateNatGatewayAddressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateNatGatewayAddressCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateRouteServerCommand}
   */
  disassociateRouteServer(
    args: DisassociateRouteServerCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateRouteServerCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateRouteTableCommand}
   */
  disassociateRouteTable(
    args: DisassociateRouteTableCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateRouteTableCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateSecurityGroupVpcCommand}
   */
  disassociateSecurityGroupVpc(
    args: DisassociateSecurityGroupVpcCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateSecurityGroupVpcCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateSubnetCidrBlockCommand}
   */
  disassociateSubnetCidrBlock(
    args: DisassociateSubnetCidrBlockCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateSubnetCidrBlockCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateTransitGatewayMulticastDomainCommand}
   */
  disassociateTransitGatewayMulticastDomain(
    args: DisassociateTransitGatewayMulticastDomainCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    DisassociateTransitGatewayMulticastDomainCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link DisassociateTransitGatewayPolicyTableCommand}
   */
  disassociateTransitGatewayPolicyTable(
    args: DisassociateTransitGatewayPolicyTableCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateTransitGatewayPolicyTableCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateTransitGatewayRouteTableCommand}
   */
  disassociateTransitGatewayRouteTable(
    args: DisassociateTransitGatewayRouteTableCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateTransitGatewayRouteTableCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateTrunkInterfaceCommand}
   */
  disassociateTrunkInterface(
    args: DisassociateTrunkInterfaceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateTrunkInterfaceCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link DisassociateVpcCidrBlockCommand}
   */
  disassociateVpcCidrBlock(
    args: DisassociateVpcCidrBlockCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<DisassociateVpcCidrBlockCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableAddressTransferCommand}
   */
  enableAddressTransfer(
    args: EnableAddressTransferCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableAddressTransferCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableAllowedImagesSettingsCommand}
   */
  enableAllowedImagesSettings(
    args: EnableAllowedImagesSettingsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableAllowedImagesSettingsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableApplicationStatusCheckSuppressionCommand}
   */
  enableApplicationStatusCheckSuppression(
    args: EnableApplicationStatusCheckSuppressionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    EnableApplicationStatusCheckSuppressionCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link EnableAwsNetworkPerformanceMetricSubscriptionCommand}
   */
  enableAwsNetworkPerformanceMetricSubscription(
    args: EnableAwsNetworkPerformanceMetricSubscriptionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    EnableAwsNetworkPerformanceMetricSubscriptionCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link EnableCapacityManagerCommand}
   */
  enableCapacityManager(
    args: EnableCapacityManagerCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableCapacityManagerCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableEbsEncryptionByDefaultCommand}
   */
  enableEbsEncryptionByDefault(
    args: EnableEbsEncryptionByDefaultCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableEbsEncryptionByDefaultCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableFastLaunchCommand}
   */
  enableFastLaunch(
    args: EnableFastLaunchCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableFastLaunchCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableFastSnapshotRestoresCommand}
   */
  enableFastSnapshotRestores(
    args: EnableFastSnapshotRestoresCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableFastSnapshotRestoresCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableImageCommand}
   */
  enableImage(
    args: EnableImageCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableImageCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableImageBlockPublicAccessCommand}
   */
  enableImageBlockPublicAccess(
    args: EnableImageBlockPublicAccessCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableImageBlockPublicAccessCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableImageDeprecationCommand}
   */
  enableImageDeprecation(
    args: EnableImageDeprecationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableImageDeprecationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableImageDeregistrationProtectionCommand}
   */
  enableImageDeregistrationProtection(
    args: EnableImageDeregistrationProtectionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableImageDeregistrationProtectionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableInstanceSqlHaStandbyDetectionsCommand}
   */
  enableInstanceSqlHaStandbyDetections(
    args: EnableInstanceSqlHaStandbyDetectionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableInstanceSqlHaStandbyDetectionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableIpamInternetRegistryAssociationCommand}
   */
  enableIpamInternetRegistryAssociation(
    args: EnableIpamInternetRegistryAssociationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableIpamInternetRegistryAssociationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableIpamOrganizationAdminAccountCommand}
   */
  enableIpamOrganizationAdminAccount(
    args: EnableIpamOrganizationAdminAccountCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableIpamOrganizationAdminAccountCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableIpamPolicyCommand}
   */
  enableIpamPolicy(
    args: EnableIpamPolicyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableIpamPolicyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableReachabilityAnalyzerOrganizationSharingCommand}
   */
  enableReachabilityAnalyzerOrganizationSharing(
    args: EnableReachabilityAnalyzerOrganizationSharingCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    EnableReachabilityAnalyzerOrganizationSharingCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link EnableRouteServerPropagationCommand}
   */
  enableRouteServerPropagation(
    args: EnableRouteServerPropagationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableRouteServerPropagationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableSerialConsoleAccessCommand}
   */
  enableSerialConsoleAccess(
    args: EnableSerialConsoleAccessCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableSerialConsoleAccessCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableSnapshotBlockPublicAccessCommand}
   */
  enableSnapshotBlockPublicAccess(
    args: EnableSnapshotBlockPublicAccessCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableSnapshotBlockPublicAccessCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableTransitGatewayRouteTablePropagationCommand}
   */
  enableTransitGatewayRouteTablePropagation(
    args: EnableTransitGatewayRouteTablePropagationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    EnableTransitGatewayRouteTablePropagationCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link EnableVgwRoutePropagationCommand}
   */
  enableVgwRoutePropagation(
    args: EnableVgwRoutePropagationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableVgwRoutePropagationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableVolumeIOCommand}
   */
  enableVolumeIO(
    args: EnableVolumeIOCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableVolumeIOCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableVpcClassicLinkCommand}
   */
  enableVpcClassicLink(
    args: EnableVpcClassicLinkCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableVpcClassicLinkCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link EnableVpcClassicLinkDnsSupportCommand}
   */
  enableVpcClassicLinkDnsSupport(
    args: EnableVpcClassicLinkDnsSupportCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<EnableVpcClassicLinkDnsSupportCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ExportClientVpnClientCertificateRevocationListCommand}
   */
  exportClientVpnClientCertificateRevocationList(
    args: ExportClientVpnClientCertificateRevocationListCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    ExportClientVpnClientCertificateRevocationListCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link ExportClientVpnClientConfigurationCommand}
   */
  exportClientVpnClientConfiguration(
    args: ExportClientVpnClientConfigurationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ExportClientVpnClientConfigurationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ExportImageCommand}
   */
  exportImage(
    args: ExportImageCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ExportImageCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ExportTransitGatewayRoutesCommand}
   */
  exportTransitGatewayRoutes(
    args: ExportTransitGatewayRoutesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ExportTransitGatewayRoutesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ExportVerifiedAccessInstanceClientConfigurationCommand}
   */
  exportVerifiedAccessInstanceClientConfiguration(
    args: ExportVerifiedAccessInstanceClientConfigurationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    ExportVerifiedAccessInstanceClientConfigurationCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link GetActiveVpnTunnelStatusCommand}
   */
  getActiveVpnTunnelStatus(
    args: GetActiveVpnTunnelStatusCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetActiveVpnTunnelStatusCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetAllowedImagesSettingsCommand}
   */
  getAllowedImagesSettings(
    args: GetAllowedImagesSettingsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetAllowedImagesSettingsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetAssociatedEnclaveCertificateIamRolesCommand}
   */
  getAssociatedEnclaveCertificateIamRoles(
    args: GetAssociatedEnclaveCertificateIamRolesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    GetAssociatedEnclaveCertificateIamRolesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link GetAssociatedIpv6PoolCidrsCommand}
   */
  getAssociatedIpv6PoolCidrs(
    args: GetAssociatedIpv6PoolCidrsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetAssociatedIpv6PoolCidrsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getAssociatedIpv6PoolCidrsStream(
    args: GetAssociatedIpv6PoolCidrsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetAssociatedIpv6PoolCidrsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetAwsNetworkPerformanceDataCommand}
   */
  getAwsNetworkPerformanceData(
    args: GetAwsNetworkPerformanceDataCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetAwsNetworkPerformanceDataCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getAwsNetworkPerformanceDataStream(
    args: GetAwsNetworkPerformanceDataCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetAwsNetworkPerformanceDataCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetCapacityManagerAttributesCommand}
   */
  getCapacityManagerAttributes(
    args: GetCapacityManagerAttributesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetCapacityManagerAttributesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetCapacityManagerMetricDataCommand}
   */
  getCapacityManagerMetricData(
    args: GetCapacityManagerMetricDataCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetCapacityManagerMetricDataCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getCapacityManagerMetricDataStream(
    args: GetCapacityManagerMetricDataCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetCapacityManagerMetricDataCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetCapacityManagerMetricDimensionsCommand}
   */
  getCapacityManagerMetricDimensions(
    args: GetCapacityManagerMetricDimensionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetCapacityManagerMetricDimensionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getCapacityManagerMetricDimensionsStream(
    args: GetCapacityManagerMetricDimensionsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetCapacityManagerMetricDimensionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetCapacityManagerMonitoredTagKeysCommand}
   */
  getCapacityManagerMonitoredTagKeys(
    args: GetCapacityManagerMonitoredTagKeysCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetCapacityManagerMonitoredTagKeysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getCapacityManagerMonitoredTagKeysStream(
    args: GetCapacityManagerMonitoredTagKeysCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetCapacityManagerMonitoredTagKeysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetCapacityReservationUsageCommand}
   */
  getCapacityReservationUsage(
    args: GetCapacityReservationUsageCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetCapacityReservationUsageCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetCoipPoolUsageCommand}
   */
  getCoipPoolUsage(
    args: GetCoipPoolUsageCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetCoipPoolUsageCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetConsoleOutputCommand}
   */
  getConsoleOutput(
    args: GetConsoleOutputCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetConsoleOutputCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetConsoleScreenshotCommand}
   */
  getConsoleScreenshot(
    args: GetConsoleScreenshotCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetConsoleScreenshotCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetDeclarativePoliciesReportSummaryCommand}
   */
  getDeclarativePoliciesReportSummary(
    args: GetDeclarativePoliciesReportSummaryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetDeclarativePoliciesReportSummaryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetDefaultCreditSpecificationCommand}
   */
  getDefaultCreditSpecification(
    args: GetDefaultCreditSpecificationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetDefaultCreditSpecificationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetEbsDefaultKmsKeyIdCommand}
   */
  getEbsDefaultKmsKeyId(
    args: GetEbsDefaultKmsKeyIdCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetEbsDefaultKmsKeyIdCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetEbsEncryptionByDefaultCommand}
   */
  getEbsEncryptionByDefault(
    args: GetEbsEncryptionByDefaultCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetEbsEncryptionByDefaultCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetEnabledIpamPolicyCommand}
   */
  getEnabledIpamPolicy(
    args: GetEnabledIpamPolicyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetEnabledIpamPolicyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetFlowLogsIntegrationTemplateCommand}
   */
  getFlowLogsIntegrationTemplate(
    args: GetFlowLogsIntegrationTemplateCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetFlowLogsIntegrationTemplateCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetGroupsForCapacityReservationCommand}
   */
  getGroupsForCapacityReservation(
    args: GetGroupsForCapacityReservationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetGroupsForCapacityReservationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getGroupsForCapacityReservationStream(
    args: GetGroupsForCapacityReservationCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetGroupsForCapacityReservationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetHostReservationPurchasePreviewCommand}
   */
  getHostReservationPurchasePreview(
    args: GetHostReservationPurchasePreviewCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetHostReservationPurchasePreviewCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetImageAncestryCommand}
   */
  getImageAncestry(
    args: GetImageAncestryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetImageAncestryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetImageBlockPublicAccessStateCommand}
   */
  getImageBlockPublicAccessState(
    args: GetImageBlockPublicAccessStateCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetImageBlockPublicAccessStateCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetInstanceMetadataDefaultsCommand}
   */
  getInstanceMetadataDefaults(
    args: GetInstanceMetadataDefaultsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetInstanceMetadataDefaultsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetInstanceTpmEkPubCommand}
   */
  getInstanceTpmEkPub(
    args: GetInstanceTpmEkPubCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetInstanceTpmEkPubCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetInstanceTypesFromInstanceRequirementsCommand}
   */
  getInstanceTypesFromInstanceRequirements(
    args: GetInstanceTypesFromInstanceRequirementsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    GetInstanceTypesFromInstanceRequirementsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  getInstanceTypesFromInstanceRequirementsStream(
    args: GetInstanceTypesFromInstanceRequirementsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    GetInstanceTypesFromInstanceRequirementsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link GetInstanceUefiDataCommand}
   */
  getInstanceUefiData(
    args: GetInstanceUefiDataCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetInstanceUefiDataCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamAddressHistoryCommand}
   */
  getIpamAddressHistory(
    args: GetIpamAddressHistoryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamAddressHistoryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getIpamAddressHistoryStream(
    args: GetIpamAddressHistoryCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetIpamAddressHistoryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamDiscoveredAccountsCommand}
   */
  getIpamDiscoveredAccounts(
    args: GetIpamDiscoveredAccountsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamDiscoveredAccountsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getIpamDiscoveredAccountsStream(
    args: GetIpamDiscoveredAccountsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetIpamDiscoveredAccountsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamDiscoveredPublicAddressesCommand}
   */
  getIpamDiscoveredPublicAddresses(
    args: GetIpamDiscoveredPublicAddressesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamDiscoveredPublicAddressesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamDiscoveredResourceCidrsCommand}
   */
  getIpamDiscoveredResourceCidrs(
    args: GetIpamDiscoveredResourceCidrsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamDiscoveredResourceCidrsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getIpamDiscoveredResourceCidrsStream(
    args: GetIpamDiscoveredResourceCidrsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetIpamDiscoveredResourceCidrsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamDiscoveredRoutesCommand}
   */
  getIpamDiscoveredRoutes(
    args: GetIpamDiscoveredRoutesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamDiscoveredRoutesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamInternetRegistryAssociationAsnsCommand}
   */
  getIpamInternetRegistryAssociationAsns(
    args: GetIpamInternetRegistryAssociationAsnsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamInternetRegistryAssociationAsnsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamInternetRegistryAssociationCidrsCommand}
   */
  getIpamInternetRegistryAssociationCidrs(
    args: GetIpamInternetRegistryAssociationCidrsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    GetIpamInternetRegistryAssociationCidrsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link GetIpamPolicyAllocationRulesCommand}
   */
  getIpamPolicyAllocationRules(
    args: GetIpamPolicyAllocationRulesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamPolicyAllocationRulesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamPolicyOrganizationTargetsCommand}
   */
  getIpamPolicyOrganizationTargets(
    args: GetIpamPolicyOrganizationTargetsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamPolicyOrganizationTargetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamPoolAllocationsCommand}
   */
  getIpamPoolAllocations(
    args: GetIpamPoolAllocationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamPoolAllocationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getIpamPoolAllocationsStream(
    args: GetIpamPoolAllocationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetIpamPoolAllocationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamPoolCidrsCommand}
   */
  getIpamPoolCidrs(
    args: GetIpamPoolCidrsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamPoolCidrsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getIpamPoolCidrsStream(
    args: GetIpamPoolCidrsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetIpamPoolCidrsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamPrefixListResolverRulesCommand}
   */
  getIpamPrefixListResolverRules(
    args: GetIpamPrefixListResolverRulesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamPrefixListResolverRulesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getIpamPrefixListResolverRulesStream(
    args: GetIpamPrefixListResolverRulesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetIpamPrefixListResolverRulesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamPrefixListResolverVersionEntriesCommand}
   */
  getIpamPrefixListResolverVersionEntries(
    args: GetIpamPrefixListResolverVersionEntriesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    GetIpamPrefixListResolverVersionEntriesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  getIpamPrefixListResolverVersionEntriesStream(
    args: GetIpamPrefixListResolverVersionEntriesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    GetIpamPrefixListResolverVersionEntriesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link GetIpamPrefixListResolverVersionsCommand}
   */
  getIpamPrefixListResolverVersions(
    args: GetIpamPrefixListResolverVersionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamPrefixListResolverVersionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getIpamPrefixListResolverVersionsStream(
    args: GetIpamPrefixListResolverVersionsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetIpamPrefixListResolverVersionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamResourceCidrsCommand}
   */
  getIpamResourceCidrs(
    args: GetIpamResourceCidrsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamResourceCidrsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getIpamResourceCidrsStream(
    args: GetIpamResourceCidrsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetIpamResourceCidrsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamRouteOriginAuthorizationsCommand}
   */
  getIpamRouteOriginAuthorizations(
    args: GetIpamRouteOriginAuthorizationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamRouteOriginAuthorizationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamRouteProtectionFindingsCommand}
   */
  getIpamRouteProtectionFindings(
    args: GetIpamRouteProtectionFindingsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamRouteProtectionFindingsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamRoutingPolicyRegistrationDeltasCommand}
   */
  getIpamRoutingPolicyRegistrationDeltas(
    args: GetIpamRoutingPolicyRegistrationDeltasCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamRoutingPolicyRegistrationDeltasCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetIpamRoutingPolicyRegistrationsCommand}
   */
  getIpamRoutingPolicyRegistrations(
    args: GetIpamRoutingPolicyRegistrationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetIpamRoutingPolicyRegistrationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetLaunchTemplateDataCommand}
   */
  getLaunchTemplateData(
    args: GetLaunchTemplateDataCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetLaunchTemplateDataCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetManagedPrefixListAssociationsCommand}
   */
  getManagedPrefixListAssociations(
    args: GetManagedPrefixListAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetManagedPrefixListAssociationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getManagedPrefixListAssociationsStream(
    args: GetManagedPrefixListAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetManagedPrefixListAssociationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetManagedPrefixListEntriesCommand}
   */
  getManagedPrefixListEntries(
    args: GetManagedPrefixListEntriesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetManagedPrefixListEntriesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getManagedPrefixListEntriesStream(
    args: GetManagedPrefixListEntriesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetManagedPrefixListEntriesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetManagedResourceVisibilityCommand}
   */
  getManagedResourceVisibility(
    args: GetManagedResourceVisibilityCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetManagedResourceVisibilityCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetNetworkInsightsAccessScopeAnalysisFindingsCommand}
   */
  getNetworkInsightsAccessScopeAnalysisFindings(
    args: GetNetworkInsightsAccessScopeAnalysisFindingsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    GetNetworkInsightsAccessScopeAnalysisFindingsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  getNetworkInsightsAccessScopeAnalysisFindingsStream(
    args: GetNetworkInsightsAccessScopeAnalysisFindingsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    GetNetworkInsightsAccessScopeAnalysisFindingsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link GetNetworkInsightsAccessScopeContentCommand}
   */
  getNetworkInsightsAccessScopeContent(
    args: GetNetworkInsightsAccessScopeContentCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetNetworkInsightsAccessScopeContentCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetPasswordDataCommand}
   */
  getPasswordData(
    args: GetPasswordDataCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetPasswordDataCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetReservedInstancesExchangeQuoteCommand}
   */
  getReservedInstancesExchangeQuote(
    args: GetReservedInstancesExchangeQuoteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetReservedInstancesExchangeQuoteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetRouteServerAssociationsCommand}
   */
  getRouteServerAssociations(
    args: GetRouteServerAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetRouteServerAssociationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetRouteServerPropagationsCommand}
   */
  getRouteServerPropagations(
    args: GetRouteServerPropagationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetRouteServerPropagationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetRouteServerRoutingDatabaseCommand}
   */
  getRouteServerRoutingDatabase(
    args: GetRouteServerRoutingDatabaseCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetRouteServerRoutingDatabaseCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetSecurityGroupsForVpcCommand}
   */
  getSecurityGroupsForVpc(
    args: GetSecurityGroupsForVpcCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetSecurityGroupsForVpcCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getSecurityGroupsForVpcStream(
    args: GetSecurityGroupsForVpcCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetSecurityGroupsForVpcCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetSerialConsoleAccessStatusCommand}
   */
  getSerialConsoleAccessStatus(
    args: GetSerialConsoleAccessStatusCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetSerialConsoleAccessStatusCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetSnapshotBlockPublicAccessStateCommand}
   */
  getSnapshotBlockPublicAccessState(
    args: GetSnapshotBlockPublicAccessStateCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetSnapshotBlockPublicAccessStateCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetSpotPlacementScoresCommand}
   */
  getSpotPlacementScores(
    args: GetSpotPlacementScoresCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetSpotPlacementScoresCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getSpotPlacementScoresStream(
    args: GetSpotPlacementScoresCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetSpotPlacementScoresCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetSubnetCidrReservationsCommand}
   */
  getSubnetCidrReservations(
    args: GetSubnetCidrReservationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetSubnetCidrReservationsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetTransitGatewayAttachmentPropagationsCommand}
   */
  getTransitGatewayAttachmentPropagations(
    args: GetTransitGatewayAttachmentPropagationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    GetTransitGatewayAttachmentPropagationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  getTransitGatewayAttachmentPropagationsStream(
    args: GetTransitGatewayAttachmentPropagationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    GetTransitGatewayAttachmentPropagationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link GetTransitGatewayMeteringPolicyEntriesCommand}
   */
  getTransitGatewayMeteringPolicyEntries(
    args: GetTransitGatewayMeteringPolicyEntriesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetTransitGatewayMeteringPolicyEntriesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetTransitGatewayMulticastDomainAssociationsCommand}
   */
  getTransitGatewayMulticastDomainAssociations(
    args: GetTransitGatewayMulticastDomainAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    GetTransitGatewayMulticastDomainAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  getTransitGatewayMulticastDomainAssociationsStream(
    args: GetTransitGatewayMulticastDomainAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    GetTransitGatewayMulticastDomainAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link GetTransitGatewayPolicyTableAssociationsCommand}
   */
  getTransitGatewayPolicyTableAssociations(
    args: GetTransitGatewayPolicyTableAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    GetTransitGatewayPolicyTableAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  getTransitGatewayPolicyTableAssociationsStream(
    args: GetTransitGatewayPolicyTableAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    GetTransitGatewayPolicyTableAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link GetTransitGatewayPolicyTableEntriesCommand}
   */
  getTransitGatewayPolicyTableEntries(
    args: GetTransitGatewayPolicyTableEntriesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetTransitGatewayPolicyTableEntriesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getTransitGatewayPolicyTableEntriesStream(
    args: GetTransitGatewayPolicyTableEntriesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetTransitGatewayPolicyTableEntriesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetTransitGatewayPrefixListReferencesCommand}
   */
  getTransitGatewayPrefixListReferences(
    args: GetTransitGatewayPrefixListReferencesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetTransitGatewayPrefixListReferencesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getTransitGatewayPrefixListReferencesStream(
    args: GetTransitGatewayPrefixListReferencesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetTransitGatewayPrefixListReferencesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetTransitGatewayRouteTableAssociationsCommand}
   */
  getTransitGatewayRouteTableAssociations(
    args: GetTransitGatewayRouteTableAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    GetTransitGatewayRouteTableAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  getTransitGatewayRouteTableAssociationsStream(
    args: GetTransitGatewayRouteTableAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    GetTransitGatewayRouteTableAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link GetTransitGatewayRouteTablePropagationsCommand}
   */
  getTransitGatewayRouteTablePropagations(
    args: GetTransitGatewayRouteTablePropagationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    GetTransitGatewayRouteTablePropagationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  getTransitGatewayRouteTablePropagationsStream(
    args: GetTransitGatewayRouteTablePropagationsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<
    GetTransitGatewayRouteTablePropagationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link GetVerifiedAccessEndpointPolicyCommand}
   */
  getVerifiedAccessEndpointPolicy(
    args: GetVerifiedAccessEndpointPolicyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetVerifiedAccessEndpointPolicyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetVerifiedAccessEndpointTargetsCommand}
   */
  getVerifiedAccessEndpointTargets(
    args: GetVerifiedAccessEndpointTargetsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetVerifiedAccessEndpointTargetsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetVerifiedAccessGroupPolicyCommand}
   */
  getVerifiedAccessGroupPolicy(
    args: GetVerifiedAccessGroupPolicyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetVerifiedAccessGroupPolicyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetVpcResourcesBlockingEncryptionEnforcementCommand}
   */
  getVpcResourcesBlockingEncryptionEnforcement(
    args: GetVpcResourcesBlockingEncryptionEnforcementCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    GetVpcResourcesBlockingEncryptionEnforcementCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link GetVpnConnectionDeviceSampleConfigurationCommand}
   */
  getVpnConnectionDeviceSampleConfiguration(
    args: GetVpnConnectionDeviceSampleConfigurationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    GetVpnConnectionDeviceSampleConfigurationCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link GetVpnConnectionDeviceTypesCommand}
   */
  getVpnConnectionDeviceTypes(
    args: GetVpnConnectionDeviceTypesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetVpnConnectionDeviceTypesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  getVpnConnectionDeviceTypesStream(
    args: GetVpnConnectionDeviceTypesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<GetVpnConnectionDeviceTypesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link GetVpnTunnelReplacementStatusCommand}
   */
  getVpnTunnelReplacementStatus(
    args: GetVpnTunnelReplacementStatusCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<GetVpnTunnelReplacementStatusCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ImportClientVpnClientCertificateRevocationListCommand}
   */
  importClientVpnClientCertificateRevocationList(
    args: ImportClientVpnClientCertificateRevocationListCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    ImportClientVpnClientCertificateRevocationListCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link ImportImageCommand}
   */
  importImage(
    args: ImportImageCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ImportImageCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ImportInstanceCommand}
   */
  importInstance(
    args: ImportInstanceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ImportInstanceCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ImportKeyPairCommand}
   */
  importKeyPair(
    args: ImportKeyPairCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ImportKeyPairCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ImportSnapshotCommand}
   */
  importSnapshot(
    args: ImportSnapshotCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ImportSnapshotCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ImportVolumeCommand}
   */
  importVolume(
    args: ImportVolumeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ImportVolumeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ListImagesInRecycleBinCommand}
   */
  listImagesInRecycleBin(
    args: ListImagesInRecycleBinCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ListImagesInRecycleBinCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  listImagesInRecycleBinStream(
    args: ListImagesInRecycleBinCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<ListImagesInRecycleBinCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ListSnapshotsInRecycleBinCommand}
   */
  listSnapshotsInRecycleBin(
    args: ListSnapshotsInRecycleBinCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ListSnapshotsInRecycleBinCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  listSnapshotsInRecycleBinStream(
    args: ListSnapshotsInRecycleBinCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<ListSnapshotsInRecycleBinCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ListVolumesInRecycleBinCommand}
   */
  listVolumesInRecycleBin(
    args: ListVolumesInRecycleBinCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ListVolumesInRecycleBinCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link LockSnapshotCommand}
   */
  lockSnapshot(
    args: LockSnapshotCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<LockSnapshotCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyAccountVpcEncryptionControlCommand}
   */
  modifyAccountVpcEncryptionControl(
    args: ModifyAccountVpcEncryptionControlCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyAccountVpcEncryptionControlCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyAddressAttributeCommand}
   */
  modifyAddressAttribute(
    args: ModifyAddressAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyAddressAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyApplicationStatusCheckCommand}
   */
  modifyApplicationStatusCheck(
    args: ModifyApplicationStatusCheckCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyApplicationStatusCheckCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyAvailabilityZoneGroupCommand}
   */
  modifyAvailabilityZoneGroup(
    args: ModifyAvailabilityZoneGroupCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyAvailabilityZoneGroupCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyCapacityReservationCommand}
   */
  modifyCapacityReservation(
    args: ModifyCapacityReservationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyCapacityReservationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyCapacityReservationFleetCommand}
   */
  modifyCapacityReservationFleet(
    args: ModifyCapacityReservationFleetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyCapacityReservationFleetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyClientVpnEndpointCommand}
   */
  modifyClientVpnEndpoint(
    args: ModifyClientVpnEndpointCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyClientVpnEndpointCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyDefaultCreditSpecificationCommand}
   */
  modifyDefaultCreditSpecification(
    args: ModifyDefaultCreditSpecificationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyDefaultCreditSpecificationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyEbsDefaultKmsKeyIdCommand}
   */
  modifyEbsDefaultKmsKeyId(
    args: ModifyEbsDefaultKmsKeyIdCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyEbsDefaultKmsKeyIdCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyFleetCommand}
   */
  modifyFleet(
    args: ModifyFleetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyFleetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyFpgaImageAttributeCommand}
   */
  modifyFpgaImageAttribute(
    args: ModifyFpgaImageAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyFpgaImageAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyHostsCommand}
   */
  modifyHosts(
    args: ModifyHostsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyHostsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyIdFormatCommand}
   */
  modifyIdFormat(
    args: ModifyIdFormatCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyIdFormatCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyIdentityIdFormatCommand}
   */
  modifyIdentityIdFormat(
    args: ModifyIdentityIdFormatCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyIdentityIdFormatCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyImageAttributeCommand}
   */
  modifyImageAttribute(
    args: ModifyImageAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyImageAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyInstanceAttributeCommand}
   */
  modifyInstanceAttribute(
    args: ModifyInstanceAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyInstanceAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyInstanceCapacityReservationAttributesCommand}
   */
  modifyInstanceCapacityReservationAttributes(
    args: ModifyInstanceCapacityReservationAttributesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    ModifyInstanceCapacityReservationAttributesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link ModifyInstanceConnectEndpointCommand}
   */
  modifyInstanceConnectEndpoint(
    args: ModifyInstanceConnectEndpointCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyInstanceConnectEndpointCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyInstanceCpuOptionsCommand}
   */
  modifyInstanceCpuOptions(
    args: ModifyInstanceCpuOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyInstanceCpuOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyInstanceCreditSpecificationCommand}
   */
  modifyInstanceCreditSpecification(
    args: ModifyInstanceCreditSpecificationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyInstanceCreditSpecificationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyInstanceEventStartTimeCommand}
   */
  modifyInstanceEventStartTime(
    args: ModifyInstanceEventStartTimeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyInstanceEventStartTimeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyInstanceEventWindowCommand}
   */
  modifyInstanceEventWindow(
    args: ModifyInstanceEventWindowCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyInstanceEventWindowCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyInstanceMaintenanceOptionsCommand}
   */
  modifyInstanceMaintenanceOptions(
    args: ModifyInstanceMaintenanceOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyInstanceMaintenanceOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyInstanceMetadataDefaultsCommand}
   */
  modifyInstanceMetadataDefaults(
    args: ModifyInstanceMetadataDefaultsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyInstanceMetadataDefaultsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyInstanceMetadataOptionsCommand}
   */
  modifyInstanceMetadataOptions(
    args: ModifyInstanceMetadataOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyInstanceMetadataOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyInstanceNetworkPerformanceOptionsCommand}
   */
  modifyInstanceNetworkPerformanceOptions(
    args: ModifyInstanceNetworkPerformanceOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    ModifyInstanceNetworkPerformanceOptionsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link ModifyInstancePlacementCommand}
   */
  modifyInstancePlacement(
    args: ModifyInstancePlacementCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyInstancePlacementCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyIpamCommand}
   */
  modifyIpam(
    args: ModifyIpamCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyIpamCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyIpamPolicyAllocationRulesCommand}
   */
  modifyIpamPolicyAllocationRules(
    args: ModifyIpamPolicyAllocationRulesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyIpamPolicyAllocationRulesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyIpamPoolCommand}
   */
  modifyIpamPool(
    args: ModifyIpamPoolCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyIpamPoolCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyIpamPoolAllocationCommand}
   */
  modifyIpamPoolAllocation(
    args: ModifyIpamPoolAllocationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyIpamPoolAllocationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyIpamPrefixListResolverCommand}
   */
  modifyIpamPrefixListResolver(
    args: ModifyIpamPrefixListResolverCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyIpamPrefixListResolverCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyIpamPrefixListResolverTargetCommand}
   */
  modifyIpamPrefixListResolverTarget(
    args: ModifyIpamPrefixListResolverTargetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyIpamPrefixListResolverTargetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyIpamResourceCidrCommand}
   */
  modifyIpamResourceCidr(
    args: ModifyIpamResourceCidrCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyIpamResourceCidrCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyIpamResourceDiscoveryCommand}
   */
  modifyIpamResourceDiscovery(
    args: ModifyIpamResourceDiscoveryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyIpamResourceDiscoveryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyIpamRoutingPolicyRegistrationCommand}
   */
  modifyIpamRoutingPolicyRegistration(
    args: ModifyIpamRoutingPolicyRegistrationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyIpamRoutingPolicyRegistrationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyIpamScopeCommand}
   */
  modifyIpamScope(
    args: ModifyIpamScopeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyIpamScopeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyLaunchTemplateCommand}
   */
  modifyLaunchTemplate(
    args: ModifyLaunchTemplateCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyLaunchTemplateCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyLocalGatewayRouteCommand}
   */
  modifyLocalGatewayRoute(
    args: ModifyLocalGatewayRouteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyLocalGatewayRouteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyManagedPrefixListCommand}
   */
  modifyManagedPrefixList(
    args: ModifyManagedPrefixListCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyManagedPrefixListCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyManagedResourceVisibilityCommand}
   */
  modifyManagedResourceVisibility(
    args: ModifyManagedResourceVisibilityCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyManagedResourceVisibilityCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyNetworkInterfaceAttributeCommand}
   */
  modifyNetworkInterfaceAttribute(
    args: ModifyNetworkInterfaceAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyNetworkInterfaceAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyPrivateDnsNameOptionsCommand}
   */
  modifyPrivateDnsNameOptions(
    args: ModifyPrivateDnsNameOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyPrivateDnsNameOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyPublicIpDnsNameOptionsCommand}
   */
  modifyPublicIpDnsNameOptions(
    args: ModifyPublicIpDnsNameOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyPublicIpDnsNameOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyReservedInstancesCommand}
   */
  modifyReservedInstances(
    args: ModifyReservedInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyReservedInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyRouteServerCommand}
   */
  modifyRouteServer(
    args: ModifyRouteServerCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyRouteServerCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifySecurityGroupRulesCommand}
   */
  modifySecurityGroupRules(
    args: ModifySecurityGroupRulesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifySecurityGroupRulesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifySnapshotAttributeCommand}
   */
  modifySnapshotAttribute(
    args: ModifySnapshotAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifySnapshotAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifySnapshotTierCommand}
   */
  modifySnapshotTier(
    args: ModifySnapshotTierCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifySnapshotTierCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifySpotFleetRequestCommand}
   */
  modifySpotFleetRequest(
    args: ModifySpotFleetRequestCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifySpotFleetRequestCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifySubnetAttributeCommand}
   */
  modifySubnetAttribute(
    args: ModifySubnetAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifySubnetAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyTrafficMirrorFilterNetworkServicesCommand}
   */
  modifyTrafficMirrorFilterNetworkServices(
    args: ModifyTrafficMirrorFilterNetworkServicesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    ModifyTrafficMirrorFilterNetworkServicesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link ModifyTrafficMirrorFilterRuleCommand}
   */
  modifyTrafficMirrorFilterRule(
    args: ModifyTrafficMirrorFilterRuleCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyTrafficMirrorFilterRuleCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyTrafficMirrorSessionCommand}
   */
  modifyTrafficMirrorSession(
    args: ModifyTrafficMirrorSessionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyTrafficMirrorSessionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyTransitGatewayCommand}
   */
  modifyTransitGateway(
    args: ModifyTransitGatewayCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyTransitGatewayCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyTransitGatewayMeteringPolicyCommand}
   */
  modifyTransitGatewayMeteringPolicy(
    args: ModifyTransitGatewayMeteringPolicyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyTransitGatewayMeteringPolicyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyTransitGatewayPolicyTableEntryCommand}
   */
  modifyTransitGatewayPolicyTableEntry(
    args: ModifyTransitGatewayPolicyTableEntryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyTransitGatewayPolicyTableEntryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyTransitGatewayPrefixListReferenceCommand}
   */
  modifyTransitGatewayPrefixListReference(
    args: ModifyTransitGatewayPrefixListReferenceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    ModifyTransitGatewayPrefixListReferenceCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link ModifyTransitGatewayVpcAttachmentCommand}
   */
  modifyTransitGatewayVpcAttachment(
    args: ModifyTransitGatewayVpcAttachmentCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyTransitGatewayVpcAttachmentCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVerifiedAccessEndpointCommand}
   */
  modifyVerifiedAccessEndpoint(
    args: ModifyVerifiedAccessEndpointCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVerifiedAccessEndpointCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVerifiedAccessEndpointPolicyCommand}
   */
  modifyVerifiedAccessEndpointPolicy(
    args: ModifyVerifiedAccessEndpointPolicyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVerifiedAccessEndpointPolicyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVerifiedAccessGroupCommand}
   */
  modifyVerifiedAccessGroup(
    args: ModifyVerifiedAccessGroupCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVerifiedAccessGroupCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVerifiedAccessGroupPolicyCommand}
   */
  modifyVerifiedAccessGroupPolicy(
    args: ModifyVerifiedAccessGroupPolicyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVerifiedAccessGroupPolicyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVerifiedAccessInstanceCommand}
   */
  modifyVerifiedAccessInstance(
    args: ModifyVerifiedAccessInstanceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVerifiedAccessInstanceCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVerifiedAccessInstanceLoggingConfigurationCommand}
   */
  modifyVerifiedAccessInstanceLoggingConfiguration(
    args: ModifyVerifiedAccessInstanceLoggingConfigurationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    ModifyVerifiedAccessInstanceLoggingConfigurationCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link ModifyVerifiedAccessTrustProviderCommand}
   */
  modifyVerifiedAccessTrustProvider(
    args: ModifyVerifiedAccessTrustProviderCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVerifiedAccessTrustProviderCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVolumeCommand}
   */
  modifyVolume(
    args: ModifyVolumeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVolumeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVolumeAttributeCommand}
   */
  modifyVolumeAttribute(
    args: ModifyVolumeAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVolumeAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVpcAttributeCommand}
   */
  modifyVpcAttribute(
    args: ModifyVpcAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVpcAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVpcBlockPublicAccessExclusionCommand}
   */
  modifyVpcBlockPublicAccessExclusion(
    args: ModifyVpcBlockPublicAccessExclusionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVpcBlockPublicAccessExclusionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVpcBlockPublicAccessOptionsCommand}
   */
  modifyVpcBlockPublicAccessOptions(
    args: ModifyVpcBlockPublicAccessOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVpcBlockPublicAccessOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVpcEncryptionControlCommand}
   */
  modifyVpcEncryptionControl(
    args: ModifyVpcEncryptionControlCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVpcEncryptionControlCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVpcEndpointCommand}
   */
  modifyVpcEndpoint(
    args: ModifyVpcEndpointCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVpcEndpointCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVpcEndpointConnectionNotificationCommand}
   */
  modifyVpcEndpointConnectionNotification(
    args: ModifyVpcEndpointConnectionNotificationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    ModifyVpcEndpointConnectionNotificationCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link ModifyVpcEndpointPayerResponsibilityCommand}
   */
  modifyVpcEndpointPayerResponsibility(
    args: ModifyVpcEndpointPayerResponsibilityCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVpcEndpointPayerResponsibilityCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVpcEndpointServiceConfigurationCommand}
   */
  modifyVpcEndpointServiceConfiguration(
    args: ModifyVpcEndpointServiceConfigurationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVpcEndpointServiceConfigurationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVpcEndpointServicePayerResponsibilityCommand}
   */
  modifyVpcEndpointServicePayerResponsibility(
    args: ModifyVpcEndpointServicePayerResponsibilityCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    ModifyVpcEndpointServicePayerResponsibilityCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link ModifyVpcEndpointServicePermissionsCommand}
   */
  modifyVpcEndpointServicePermissions(
    args: ModifyVpcEndpointServicePermissionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVpcEndpointServicePermissionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVpcPeeringConnectionOptionsCommand}
   */
  modifyVpcPeeringConnectionOptions(
    args: ModifyVpcPeeringConnectionOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVpcPeeringConnectionOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVpcTenancyCommand}
   */
  modifyVpcTenancy(
    args: ModifyVpcTenancyCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVpcTenancyCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVpnConnectionCommand}
   */
  modifyVpnConnection(
    args: ModifyVpnConnectionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVpnConnectionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVpnConnectionOptionsCommand}
   */
  modifyVpnConnectionOptions(
    args: ModifyVpnConnectionOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVpnConnectionOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVpnTunnelCertificateCommand}
   */
  modifyVpnTunnelCertificate(
    args: ModifyVpnTunnelCertificateCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVpnTunnelCertificateCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ModifyVpnTunnelOptionsCommand}
   */
  modifyVpnTunnelOptions(
    args: ModifyVpnTunnelOptionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ModifyVpnTunnelOptionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link MonitorInstancesCommand}
   */
  monitorInstances(
    args: MonitorInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<MonitorInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link MoveAddressToVpcCommand}
   */
  moveAddressToVpc(
    args: MoveAddressToVpcCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<MoveAddressToVpcCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link MoveByoipCidrToIpamCommand}
   */
  moveByoipCidrToIpam(
    args: MoveByoipCidrToIpamCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<MoveByoipCidrToIpamCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link MoveCapacityReservationInstancesCommand}
   */
  moveCapacityReservationInstances(
    args: MoveCapacityReservationInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<MoveCapacityReservationInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ProvisionByoipCidrCommand}
   */
  provisionByoipCidr(
    args: ProvisionByoipCidrCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ProvisionByoipCidrCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ProvisionIpamByoasnCommand}
   */
  provisionIpamByoasn(
    args: ProvisionIpamByoasnCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ProvisionIpamByoasnCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ProvisionIpamPoolCidrCommand}
   */
  provisionIpamPoolCidr(
    args: ProvisionIpamPoolCidrCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ProvisionIpamPoolCidrCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ProvisionPublicIpv4PoolCidrCommand}
   */
  provisionPublicIpv4PoolCidr(
    args: ProvisionPublicIpv4PoolCidrCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ProvisionPublicIpv4PoolCidrCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link PurchaseCapacityBlockCommand}
   */
  purchaseCapacityBlock(
    args: PurchaseCapacityBlockCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<PurchaseCapacityBlockCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link PurchaseCapacityBlockExtensionCommand}
   */
  purchaseCapacityBlockExtension(
    args: PurchaseCapacityBlockExtensionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<PurchaseCapacityBlockExtensionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link PurchaseHostReservationCommand}
   */
  purchaseHostReservation(
    args: PurchaseHostReservationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<PurchaseHostReservationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link PurchaseReservedInstancesOfferingCommand}
   */
  purchaseReservedInstancesOffering(
    args: PurchaseReservedInstancesOfferingCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<PurchaseReservedInstancesOfferingCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link PurchaseScheduledInstancesCommand}
   */
  purchaseScheduledInstances(
    args: PurchaseScheduledInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<PurchaseScheduledInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RebootInstancesCommand}
   */
  rebootInstances(
    args: RebootInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RebootInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RegisterImageCommand}
   */
  registerImage(
    args: RegisterImageCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RegisterImageCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RegisterInstanceEventNotificationAttributesCommand}
   */
  registerInstanceEventNotificationAttributes(
    args: RegisterInstanceEventNotificationAttributesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    RegisterInstanceEventNotificationAttributesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link RegisterTransitGatewayMulticastGroupMembersCommand}
   */
  registerTransitGatewayMulticastGroupMembers(
    args: RegisterTransitGatewayMulticastGroupMembersCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    RegisterTransitGatewayMulticastGroupMembersCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link RegisterTransitGatewayMulticastGroupSourcesCommand}
   */
  registerTransitGatewayMulticastGroupSources(
    args: RegisterTransitGatewayMulticastGroupSourcesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    RegisterTransitGatewayMulticastGroupSourcesCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link RejectCapacityReservationBillingOwnershipCommand}
   */
  rejectCapacityReservationBillingOwnership(
    args: RejectCapacityReservationBillingOwnershipCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    RejectCapacityReservationBillingOwnershipCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link RejectTransitGatewayClientVpnAttachmentCommand}
   */
  rejectTransitGatewayClientVpnAttachment(
    args: RejectTransitGatewayClientVpnAttachmentCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    RejectTransitGatewayClientVpnAttachmentCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link RejectTransitGatewayMulticastDomainAssociationsCommand}
   */
  rejectTransitGatewayMulticastDomainAssociations(
    args: RejectTransitGatewayMulticastDomainAssociationsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    RejectTransitGatewayMulticastDomainAssociationsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link RejectTransitGatewayPeeringAttachmentCommand}
   */
  rejectTransitGatewayPeeringAttachment(
    args: RejectTransitGatewayPeeringAttachmentCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RejectTransitGatewayPeeringAttachmentCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RejectTransitGatewayVpcAttachmentCommand}
   */
  rejectTransitGatewayVpcAttachment(
    args: RejectTransitGatewayVpcAttachmentCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RejectTransitGatewayVpcAttachmentCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RejectVpcEndpointConnectionsCommand}
   */
  rejectVpcEndpointConnections(
    args: RejectVpcEndpointConnectionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RejectVpcEndpointConnectionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RejectVpcPeeringConnectionCommand}
   */
  rejectVpcPeeringConnection(
    args: RejectVpcPeeringConnectionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RejectVpcPeeringConnectionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ReleaseAddressCommand}
   */
  releaseAddress(
    args: ReleaseAddressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ReleaseAddressCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ReleaseHostsCommand}
   */
  releaseHosts(
    args: ReleaseHostsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ReleaseHostsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ReleaseIpamPoolAllocationCommand}
   */
  releaseIpamPoolAllocation(
    args: ReleaseIpamPoolAllocationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ReleaseIpamPoolAllocationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ReplaceIamInstanceProfileAssociationCommand}
   */
  replaceIamInstanceProfileAssociation(
    args: ReplaceIamInstanceProfileAssociationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ReplaceIamInstanceProfileAssociationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ReplaceImageCriteriaInAllowedImagesSettingsCommand}
   */
  replaceImageCriteriaInAllowedImagesSettings(
    args: ReplaceImageCriteriaInAllowedImagesSettingsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    ReplaceImageCriteriaInAllowedImagesSettingsCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link ReplaceImageInstanceTypeSpecificationCommand}
   */
  replaceImageInstanceTypeSpecification(
    args: ReplaceImageInstanceTypeSpecificationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ReplaceImageInstanceTypeSpecificationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ReplaceNetworkAclAssociationCommand}
   */
  replaceNetworkAclAssociation(
    args: ReplaceNetworkAclAssociationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ReplaceNetworkAclAssociationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ReplaceNetworkAclEntryCommand}
   */
  replaceNetworkAclEntry(
    args: ReplaceNetworkAclEntryCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ReplaceNetworkAclEntryCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ReplaceRouteCommand}
   */
  replaceRoute(
    args: ReplaceRouteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ReplaceRouteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ReplaceRouteTableAssociationCommand}
   */
  replaceRouteTableAssociation(
    args: ReplaceRouteTableAssociationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ReplaceRouteTableAssociationCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ReplaceTransitGatewayRouteCommand}
   */
  replaceTransitGatewayRoute(
    args: ReplaceTransitGatewayRouteCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ReplaceTransitGatewayRouteCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ReplaceVpnTunnelCommand}
   */
  replaceVpnTunnel(
    args: ReplaceVpnTunnelCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ReplaceVpnTunnelCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ReportInstanceStatusCommand}
   */
  reportInstanceStatus(
    args: ReportInstanceStatusCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ReportInstanceStatusCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RequestSpotFleetCommand}
   */
  requestSpotFleet(
    args: RequestSpotFleetCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RequestSpotFleetCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RequestSpotInstancesCommand}
   */
  requestSpotInstances(
    args: RequestSpotInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RequestSpotInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ResetAddressAttributeCommand}
   */
  resetAddressAttribute(
    args: ResetAddressAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ResetAddressAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ResetEbsDefaultKmsKeyIdCommand}
   */
  resetEbsDefaultKmsKeyId(
    args: ResetEbsDefaultKmsKeyIdCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ResetEbsDefaultKmsKeyIdCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ResetFpgaImageAttributeCommand}
   */
  resetFpgaImageAttribute(
    args: ResetFpgaImageAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ResetFpgaImageAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ResetImageAttributeCommand}
   */
  resetImageAttribute(
    args: ResetImageAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ResetImageAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ResetInstanceAttributeCommand}
   */
  resetInstanceAttribute(
    args: ResetInstanceAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ResetInstanceAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ResetNetworkInterfaceAttributeCommand}
   */
  resetNetworkInterfaceAttribute(
    args: ResetNetworkInterfaceAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ResetNetworkInterfaceAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link ResetSnapshotAttributeCommand}
   */
  resetSnapshotAttribute(
    args: ResetSnapshotAttributeCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<ResetSnapshotAttributeCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RestoreAddressToClassicCommand}
   */
  restoreAddressToClassic(
    args: RestoreAddressToClassicCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RestoreAddressToClassicCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RestoreImageFromRecycleBinCommand}
   */
  restoreImageFromRecycleBin(
    args: RestoreImageFromRecycleBinCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RestoreImageFromRecycleBinCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RestoreManagedPrefixListVersionCommand}
   */
  restoreManagedPrefixListVersion(
    args: RestoreManagedPrefixListVersionCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RestoreManagedPrefixListVersionCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RestoreSnapshotFromRecycleBinCommand}
   */
  restoreSnapshotFromRecycleBin(
    args: RestoreSnapshotFromRecycleBinCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RestoreSnapshotFromRecycleBinCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RestoreSnapshotTierCommand}
   */
  restoreSnapshotTier(
    args: RestoreSnapshotTierCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RestoreSnapshotTierCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RestoreVolumeFromRecycleBinCommand}
   */
  restoreVolumeFromRecycleBin(
    args: RestoreVolumeFromRecycleBinCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RestoreVolumeFromRecycleBinCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RevokeClientVpnIngressCommand}
   */
  revokeClientVpnIngress(
    args: RevokeClientVpnIngressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RevokeClientVpnIngressCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RevokeSecurityGroupEgressCommand}
   */
  revokeSecurityGroupEgress(
    args: RevokeSecurityGroupEgressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RevokeSecurityGroupEgressCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RevokeSecurityGroupIngressCommand}
   */
  revokeSecurityGroupIngress(
    args: RevokeSecurityGroupIngressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RevokeSecurityGroupIngressCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RunInstancesCommand}
   */
  runInstances(
    args: RunInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RunInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link RunScheduledInstancesCommand}
   */
  runScheduledInstances(
    args: RunScheduledInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<RunScheduledInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link SearchLocalGatewayRoutesCommand}
   */
  searchLocalGatewayRoutes(
    args: SearchLocalGatewayRoutesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<SearchLocalGatewayRoutesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  searchLocalGatewayRoutesStream(
    args: SearchLocalGatewayRoutesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<SearchLocalGatewayRoutesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link SearchTransitGatewayMulticastGroupsCommand}
   */
  searchTransitGatewayMulticastGroups(
    args: SearchTransitGatewayMulticastGroupsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<SearchTransitGatewayMulticastGroupsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  searchTransitGatewayMulticastGroupsStream(
    args: SearchTransitGatewayMulticastGroupsCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<SearchTransitGatewayMulticastGroupsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link SearchTransitGatewayRoutesCommand}
   */
  searchTransitGatewayRoutes(
    args: SearchTransitGatewayRoutesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<SearchTransitGatewayRoutesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  searchTransitGatewayRoutesStream(
    args: SearchTransitGatewayRoutesCommandInput,
    options?: HttpHandlerOptions
  ): Stream.Stream<SearchTransitGatewayRoutesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link SendDiagnosticInterruptCommand}
   */
  sendDiagnosticInterrupt(
    args: SendDiagnosticInterruptCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<SendDiagnosticInterruptCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link StartDeclarativePoliciesReportCommand}
   */
  startDeclarativePoliciesReport(
    args: StartDeclarativePoliciesReportCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<StartDeclarativePoliciesReportCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link StartInstancesCommand}
   */
  startInstances(
    args: StartInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<StartInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link StartNetworkInsightsAccessScopeAnalysisCommand}
   */
  startNetworkInsightsAccessScopeAnalysis(
    args: StartNetworkInsightsAccessScopeAnalysisCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    StartNetworkInsightsAccessScopeAnalysisCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link StartNetworkInsightsAnalysisCommand}
   */
  startNetworkInsightsAnalysis(
    args: StartNetworkInsightsAnalysisCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<StartNetworkInsightsAnalysisCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link StartVpcEndpointServicePrivateDnsVerificationCommand}
   */
  startVpcEndpointServicePrivateDnsVerification(
    args: StartVpcEndpointServicePrivateDnsVerificationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    StartVpcEndpointServicePrivateDnsVerificationCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link StopInstancesCommand}
   */
  stopInstances(
    args: StopInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<StopInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link TerminateClientVpnConnectionsCommand}
   */
  terminateClientVpnConnections(
    args: TerminateClientVpnConnectionsCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<TerminateClientVpnConnectionsCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link TerminateInstancesCommand}
   */
  terminateInstances(
    args: TerminateInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<TerminateInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link UnassignIpv6AddressesCommand}
   */
  unassignIpv6Addresses(
    args: UnassignIpv6AddressesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<UnassignIpv6AddressesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link UnassignPrivateIpAddressesCommand}
   */
  unassignPrivateIpAddresses(
    args: UnassignPrivateIpAddressesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<UnassignPrivateIpAddressesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link UnassignPrivateNatGatewayAddressCommand}
   */
  unassignPrivateNatGatewayAddress(
    args: UnassignPrivateNatGatewayAddressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<UnassignPrivateNatGatewayAddressCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link UnlockSnapshotCommand}
   */
  unlockSnapshot(
    args: UnlockSnapshotCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<UnlockSnapshotCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link UnmonitorInstancesCommand}
   */
  unmonitorInstances(
    args: UnmonitorInstancesCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<UnmonitorInstancesCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link UpdateCapacityManagerMonitoredTagKeysCommand}
   */
  updateCapacityManagerMonitoredTagKeys(
    args: UpdateCapacityManagerMonitoredTagKeysCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<UpdateCapacityManagerMonitoredTagKeysCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>

  /**
   * @see {@link UpdateCapacityManagerOrganizationsAccessCommand}
   */
  updateCapacityManagerOrganizationsAccess(
    args: UpdateCapacityManagerOrganizationsAccessCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    UpdateCapacityManagerOrganizationsAccessCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link UpdateInterruptibleCapacityReservationAllocationCommand}
   */
  updateInterruptibleCapacityReservationAllocation(
    args: UpdateInterruptibleCapacityReservationAllocationCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    UpdateInterruptibleCapacityReservationAllocationCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link UpdateSecurityGroupRuleDescriptionsEgressCommand}
   */
  updateSecurityGroupRuleDescriptionsEgress(
    args: UpdateSecurityGroupRuleDescriptionsEgressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    UpdateSecurityGroupRuleDescriptionsEgressCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link UpdateSecurityGroupRuleDescriptionsIngressCommand}
   */
  updateSecurityGroupRuleDescriptionsIngress(
    args: UpdateSecurityGroupRuleDescriptionsIngressCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    UpdateSecurityGroupRuleDescriptionsIngressCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link ValidateSecurityGroupQuotasForInterfaceCommand}
   */
  validateSecurityGroupQuotasForInterface(
    args: ValidateSecurityGroupQuotasForInterfaceCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<
    ValidateSecurityGroupQuotasForInterfaceCommandOutput,
    Cause.TimeoutError | SdkError | EC2ServiceError
  >

  /**
   * @see {@link WithdrawByoipCidrCommand}
   */
  withdrawByoipCidr(
    args: WithdrawByoipCidrCommandInput,
    options?: HttpHandlerOptions
  ): Effect.Effect<WithdrawByoipCidrCommandOutput, Cause.TimeoutError | SdkError | EC2ServiceError>
}