"Fossies" - the Fresh Open Source Software Archive

Member "cells-3.0.3/vendor/github.com/aws/aws-sdk-go/service/ec2/api.go" (30 Nov 2021, 1951938 Bytes) of package /linux/misc/pydio-cells-3.0.3.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Go source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 // THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
    2 
    3 // Package ec2 provides a client for Amazon Elastic Compute Cloud.
    4 package ec2
    5 
    6 import (
    7     "fmt"
    8     "time"
    9 
   10     "github.com/aws/aws-sdk-go/aws/awsutil"
   11     "github.com/aws/aws-sdk-go/aws/request"
   12     "github.com/aws/aws-sdk-go/private/protocol"
   13     "github.com/aws/aws-sdk-go/private/protocol/ec2query"
   14 )
   15 
   16 const opAcceptReservedInstancesExchangeQuote = "AcceptReservedInstancesExchangeQuote"
   17 
   18 // AcceptReservedInstancesExchangeQuoteRequest generates a "aws/request.Request" representing the
   19 // client's request for the AcceptReservedInstancesExchangeQuote operation. The "output" return
   20 // value can be used to capture response data after the request's "Send" method
   21 // is called.
   22 //
   23 // See AcceptReservedInstancesExchangeQuote for usage and error information.
   24 //
   25 // Creating a request object using this method should be used when you want to inject
   26 // custom logic into the request's lifecycle using a custom handler, or if you want to
   27 // access properties on the request object before or after sending the request. If
   28 // you just want the service response, call the AcceptReservedInstancesExchangeQuote method directly
   29 // instead.
   30 //
   31 // Note: You must call the "Send" method on the returned request object in order
   32 // to execute the request.
   33 //
   34 //    // Example sending a request using the AcceptReservedInstancesExchangeQuoteRequest method.
   35 //    req, resp := client.AcceptReservedInstancesExchangeQuoteRequest(params)
   36 //
   37 //    err := req.Send()
   38 //    if err == nil { // resp is now filled
   39 //        fmt.Println(resp)
   40 //    }
   41 //
   42 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptReservedInstancesExchangeQuote
   43 func (c *EC2) AcceptReservedInstancesExchangeQuoteRequest(input *AcceptReservedInstancesExchangeQuoteInput) (req *request.Request, output *AcceptReservedInstancesExchangeQuoteOutput) {
   44     op := &request.Operation{
   45         Name:       opAcceptReservedInstancesExchangeQuote,
   46         HTTPMethod: "POST",
   47         HTTPPath:   "/",
   48     }
   49 
   50     if input == nil {
   51         input = &AcceptReservedInstancesExchangeQuoteInput{}
   52     }
   53 
   54     output = &AcceptReservedInstancesExchangeQuoteOutput{}
   55     req = c.newRequest(op, input, output)
   56     return
   57 }
   58 
   59 // AcceptReservedInstancesExchangeQuote API operation for Amazon Elastic Compute Cloud.
   60 //
   61 // Accepts the Convertible Reserved Instance exchange quote described in the
   62 // GetReservedInstancesExchangeQuote call.
   63 //
   64 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
   65 // with awserr.Error's Code and Message methods to get detailed information about
   66 // the error.
   67 //
   68 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
   69 // API operation AcceptReservedInstancesExchangeQuote for usage and error information.
   70 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptReservedInstancesExchangeQuote
   71 func (c *EC2) AcceptReservedInstancesExchangeQuote(input *AcceptReservedInstancesExchangeQuoteInput) (*AcceptReservedInstancesExchangeQuoteOutput, error) {
   72     req, out := c.AcceptReservedInstancesExchangeQuoteRequest(input)
   73     err := req.Send()
   74     return out, err
   75 }
   76 
   77 const opAcceptVpcPeeringConnection = "AcceptVpcPeeringConnection"
   78 
   79 // AcceptVpcPeeringConnectionRequest generates a "aws/request.Request" representing the
   80 // client's request for the AcceptVpcPeeringConnection operation. The "output" return
   81 // value can be used to capture response data after the request's "Send" method
   82 // is called.
   83 //
   84 // See AcceptVpcPeeringConnection for usage and error information.
   85 //
   86 // Creating a request object using this method should be used when you want to inject
   87 // custom logic into the request's lifecycle using a custom handler, or if you want to
   88 // access properties on the request object before or after sending the request. If
   89 // you just want the service response, call the AcceptVpcPeeringConnection method directly
   90 // instead.
   91 //
   92 // Note: You must call the "Send" method on the returned request object in order
   93 // to execute the request.
   94 //
   95 //    // Example sending a request using the AcceptVpcPeeringConnectionRequest method.
   96 //    req, resp := client.AcceptVpcPeeringConnectionRequest(params)
   97 //
   98 //    err := req.Send()
   99 //    if err == nil { // resp is now filled
  100 //        fmt.Println(resp)
  101 //    }
  102 //
  103 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptVpcPeeringConnection
  104 func (c *EC2) AcceptVpcPeeringConnectionRequest(input *AcceptVpcPeeringConnectionInput) (req *request.Request, output *AcceptVpcPeeringConnectionOutput) {
  105     op := &request.Operation{
  106         Name:       opAcceptVpcPeeringConnection,
  107         HTTPMethod: "POST",
  108         HTTPPath:   "/",
  109     }
  110 
  111     if input == nil {
  112         input = &AcceptVpcPeeringConnectionInput{}
  113     }
  114 
  115     output = &AcceptVpcPeeringConnectionOutput{}
  116     req = c.newRequest(op, input, output)
  117     return
  118 }
  119 
  120 // AcceptVpcPeeringConnection API operation for Amazon Elastic Compute Cloud.
  121 //
  122 // Accept a VPC peering connection request. To accept a request, the VPC peering
  123 // connection must be in the pending-acceptance state, and you must be the owner
  124 // of the peer VPC. Use the DescribeVpcPeeringConnections request to view your
  125 // outstanding VPC peering connection requests.
  126 //
  127 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  128 // with awserr.Error's Code and Message methods to get detailed information about
  129 // the error.
  130 //
  131 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
  132 // API operation AcceptVpcPeeringConnection for usage and error information.
  133 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptVpcPeeringConnection
  134 func (c *EC2) AcceptVpcPeeringConnection(input *AcceptVpcPeeringConnectionInput) (*AcceptVpcPeeringConnectionOutput, error) {
  135     req, out := c.AcceptVpcPeeringConnectionRequest(input)
  136     err := req.Send()
  137     return out, err
  138 }
  139 
  140 const opAllocateAddress = "AllocateAddress"
  141 
  142 // AllocateAddressRequest generates a "aws/request.Request" representing the
  143 // client's request for the AllocateAddress operation. The "output" return
  144 // value can be used to capture response data after the request's "Send" method
  145 // is called.
  146 //
  147 // See AllocateAddress for usage and error information.
  148 //
  149 // Creating a request object using this method should be used when you want to inject
  150 // custom logic into the request's lifecycle using a custom handler, or if you want to
  151 // access properties on the request object before or after sending the request. If
  152 // you just want the service response, call the AllocateAddress method directly
  153 // instead.
  154 //
  155 // Note: You must call the "Send" method on the returned request object in order
  156 // to execute the request.
  157 //
  158 //    // Example sending a request using the AllocateAddressRequest method.
  159 //    req, resp := client.AllocateAddressRequest(params)
  160 //
  161 //    err := req.Send()
  162 //    if err == nil { // resp is now filled
  163 //        fmt.Println(resp)
  164 //    }
  165 //
  166 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateAddress
  167 func (c *EC2) AllocateAddressRequest(input *AllocateAddressInput) (req *request.Request, output *AllocateAddressOutput) {
  168     op := &request.Operation{
  169         Name:       opAllocateAddress,
  170         HTTPMethod: "POST",
  171         HTTPPath:   "/",
  172     }
  173 
  174     if input == nil {
  175         input = &AllocateAddressInput{}
  176     }
  177 
  178     output = &AllocateAddressOutput{}
  179     req = c.newRequest(op, input, output)
  180     return
  181 }
  182 
  183 // AllocateAddress API operation for Amazon Elastic Compute Cloud.
  184 //
  185 // Acquires an Elastic IP address.
  186 //
  187 // An Elastic IP address is for use either in the EC2-Classic platform or in
  188 // a VPC. For more information, see Elastic IP Addresses (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html)
  189 // in the Amazon Elastic Compute Cloud User Guide.
  190 //
  191 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  192 // with awserr.Error's Code and Message methods to get detailed information about
  193 // the error.
  194 //
  195 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
  196 // API operation AllocateAddress for usage and error information.
  197 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateAddress
  198 func (c *EC2) AllocateAddress(input *AllocateAddressInput) (*AllocateAddressOutput, error) {
  199     req, out := c.AllocateAddressRequest(input)
  200     err := req.Send()
  201     return out, err
  202 }
  203 
  204 const opAllocateHosts = "AllocateHosts"
  205 
  206 // AllocateHostsRequest generates a "aws/request.Request" representing the
  207 // client's request for the AllocateHosts operation. The "output" return
  208 // value can be used to capture response data after the request's "Send" method
  209 // is called.
  210 //
  211 // See AllocateHosts for usage and error information.
  212 //
  213 // Creating a request object using this method should be used when you want to inject
  214 // custom logic into the request's lifecycle using a custom handler, or if you want to
  215 // access properties on the request object before or after sending the request. If
  216 // you just want the service response, call the AllocateHosts method directly
  217 // instead.
  218 //
  219 // Note: You must call the "Send" method on the returned request object in order
  220 // to execute the request.
  221 //
  222 //    // Example sending a request using the AllocateHostsRequest method.
  223 //    req, resp := client.AllocateHostsRequest(params)
  224 //
  225 //    err := req.Send()
  226 //    if err == nil { // resp is now filled
  227 //        fmt.Println(resp)
  228 //    }
  229 //
  230 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateHosts
  231 func (c *EC2) AllocateHostsRequest(input *AllocateHostsInput) (req *request.Request, output *AllocateHostsOutput) {
  232     op := &request.Operation{
  233         Name:       opAllocateHosts,
  234         HTTPMethod: "POST",
  235         HTTPPath:   "/",
  236     }
  237 
  238     if input == nil {
  239         input = &AllocateHostsInput{}
  240     }
  241 
  242     output = &AllocateHostsOutput{}
  243     req = c.newRequest(op, input, output)
  244     return
  245 }
  246 
  247 // AllocateHosts API operation for Amazon Elastic Compute Cloud.
  248 //
  249 // Allocates a Dedicated Host to your account. At minimum you need to specify
  250 // the instance size type, Availability Zone, and quantity of hosts you want
  251 // to allocate.
  252 //
  253 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  254 // with awserr.Error's Code and Message methods to get detailed information about
  255 // the error.
  256 //
  257 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
  258 // API operation AllocateHosts for usage and error information.
  259 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateHosts
  260 func (c *EC2) AllocateHosts(input *AllocateHostsInput) (*AllocateHostsOutput, error) {
  261     req, out := c.AllocateHostsRequest(input)
  262     err := req.Send()
  263     return out, err
  264 }
  265 
  266 const opAssignIpv6Addresses = "AssignIpv6Addresses"
  267 
  268 // AssignIpv6AddressesRequest generates a "aws/request.Request" representing the
  269 // client's request for the AssignIpv6Addresses operation. The "output" return
  270 // value can be used to capture response data after the request's "Send" method
  271 // is called.
  272 //
  273 // See AssignIpv6Addresses for usage and error information.
  274 //
  275 // Creating a request object using this method should be used when you want to inject
  276 // custom logic into the request's lifecycle using a custom handler, or if you want to
  277 // access properties on the request object before or after sending the request. If
  278 // you just want the service response, call the AssignIpv6Addresses method directly
  279 // instead.
  280 //
  281 // Note: You must call the "Send" method on the returned request object in order
  282 // to execute the request.
  283 //
  284 //    // Example sending a request using the AssignIpv6AddressesRequest method.
  285 //    req, resp := client.AssignIpv6AddressesRequest(params)
  286 //
  287 //    err := req.Send()
  288 //    if err == nil { // resp is now filled
  289 //        fmt.Println(resp)
  290 //    }
  291 //
  292 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignIpv6Addresses
  293 func (c *EC2) AssignIpv6AddressesRequest(input *AssignIpv6AddressesInput) (req *request.Request, output *AssignIpv6AddressesOutput) {
  294     op := &request.Operation{
  295         Name:       opAssignIpv6Addresses,
  296         HTTPMethod: "POST",
  297         HTTPPath:   "/",
  298     }
  299 
  300     if input == nil {
  301         input = &AssignIpv6AddressesInput{}
  302     }
  303 
  304     output = &AssignIpv6AddressesOutput{}
  305     req = c.newRequest(op, input, output)
  306     return
  307 }
  308 
  309 // AssignIpv6Addresses API operation for Amazon Elastic Compute Cloud.
  310 //
  311 // Assigns one or more IPv6 addresses to the specified network interface. You
  312 // can specify one or more specific IPv6 addresses, or you can specify the number
  313 // of IPv6 addresses to be automatically assigned from within the subnet's IPv6
  314 // CIDR block range. You can assign as many IPv6 addresses to a network interface
  315 // as you can assign private IPv4 addresses, and the limit varies per instance
  316 // type. For information, see IP Addresses Per Network Interface Per Instance
  317 // Type (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html#AvailableIpPerENI)
  318 // in the Amazon Elastic Compute Cloud User Guide.
  319 //
  320 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  321 // with awserr.Error's Code and Message methods to get detailed information about
  322 // the error.
  323 //
  324 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
  325 // API operation AssignIpv6Addresses for usage and error information.
  326 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignIpv6Addresses
  327 func (c *EC2) AssignIpv6Addresses(input *AssignIpv6AddressesInput) (*AssignIpv6AddressesOutput, error) {
  328     req, out := c.AssignIpv6AddressesRequest(input)
  329     err := req.Send()
  330     return out, err
  331 }
  332 
  333 const opAssignPrivateIpAddresses = "AssignPrivateIpAddresses"
  334 
  335 // AssignPrivateIpAddressesRequest generates a "aws/request.Request" representing the
  336 // client's request for the AssignPrivateIpAddresses operation. The "output" return
  337 // value can be used to capture response data after the request's "Send" method
  338 // is called.
  339 //
  340 // See AssignPrivateIpAddresses for usage and error information.
  341 //
  342 // Creating a request object using this method should be used when you want to inject
  343 // custom logic into the request's lifecycle using a custom handler, or if you want to
  344 // access properties on the request object before or after sending the request. If
  345 // you just want the service response, call the AssignPrivateIpAddresses method directly
  346 // instead.
  347 //
  348 // Note: You must call the "Send" method on the returned request object in order
  349 // to execute the request.
  350 //
  351 //    // Example sending a request using the AssignPrivateIpAddressesRequest method.
  352 //    req, resp := client.AssignPrivateIpAddressesRequest(params)
  353 //
  354 //    err := req.Send()
  355 //    if err == nil { // resp is now filled
  356 //        fmt.Println(resp)
  357 //    }
  358 //
  359 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignPrivateIpAddresses
  360 func (c *EC2) AssignPrivateIpAddressesRequest(input *AssignPrivateIpAddressesInput) (req *request.Request, output *AssignPrivateIpAddressesOutput) {
  361     op := &request.Operation{
  362         Name:       opAssignPrivateIpAddresses,
  363         HTTPMethod: "POST",
  364         HTTPPath:   "/",
  365     }
  366 
  367     if input == nil {
  368         input = &AssignPrivateIpAddressesInput{}
  369     }
  370 
  371     output = &AssignPrivateIpAddressesOutput{}
  372     req = c.newRequest(op, input, output)
  373     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
  374     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
  375     return
  376 }
  377 
  378 // AssignPrivateIpAddresses API operation for Amazon Elastic Compute Cloud.
  379 //
  380 // Assigns one or more secondary private IP addresses to the specified network
  381 // interface. You can specify one or more specific secondary IP addresses, or
  382 // you can specify the number of secondary IP addresses to be automatically
  383 // assigned within the subnet's CIDR block range. The number of secondary IP
  384 // addresses that you can assign to an instance varies by instance type. For
  385 // information about instance types, see Instance Types (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html)
  386 // in the Amazon Elastic Compute Cloud User Guide. For more information about
  387 // Elastic IP addresses, see Elastic IP Addresses (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html)
  388 // in the Amazon Elastic Compute Cloud User Guide.
  389 //
  390 // AssignPrivateIpAddresses is available only in EC2-VPC.
  391 //
  392 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  393 // with awserr.Error's Code and Message methods to get detailed information about
  394 // the error.
  395 //
  396 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
  397 // API operation AssignPrivateIpAddresses for usage and error information.
  398 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignPrivateIpAddresses
  399 func (c *EC2) AssignPrivateIpAddresses(input *AssignPrivateIpAddressesInput) (*AssignPrivateIpAddressesOutput, error) {
  400     req, out := c.AssignPrivateIpAddressesRequest(input)
  401     err := req.Send()
  402     return out, err
  403 }
  404 
  405 const opAssociateAddress = "AssociateAddress"
  406 
  407 // AssociateAddressRequest generates a "aws/request.Request" representing the
  408 // client's request for the AssociateAddress operation. The "output" return
  409 // value can be used to capture response data after the request's "Send" method
  410 // is called.
  411 //
  412 // See AssociateAddress for usage and error information.
  413 //
  414 // Creating a request object using this method should be used when you want to inject
  415 // custom logic into the request's lifecycle using a custom handler, or if you want to
  416 // access properties on the request object before or after sending the request. If
  417 // you just want the service response, call the AssociateAddress method directly
  418 // instead.
  419 //
  420 // Note: You must call the "Send" method on the returned request object in order
  421 // to execute the request.
  422 //
  423 //    // Example sending a request using the AssociateAddressRequest method.
  424 //    req, resp := client.AssociateAddressRequest(params)
  425 //
  426 //    err := req.Send()
  427 //    if err == nil { // resp is now filled
  428 //        fmt.Println(resp)
  429 //    }
  430 //
  431 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateAddress
  432 func (c *EC2) AssociateAddressRequest(input *AssociateAddressInput) (req *request.Request, output *AssociateAddressOutput) {
  433     op := &request.Operation{
  434         Name:       opAssociateAddress,
  435         HTTPMethod: "POST",
  436         HTTPPath:   "/",
  437     }
  438 
  439     if input == nil {
  440         input = &AssociateAddressInput{}
  441     }
  442 
  443     output = &AssociateAddressOutput{}
  444     req = c.newRequest(op, input, output)
  445     return
  446 }
  447 
  448 // AssociateAddress API operation for Amazon Elastic Compute Cloud.
  449 //
  450 // Associates an Elastic IP address with an instance or a network interface.
  451 //
  452 // An Elastic IP address is for use in either the EC2-Classic platform or in
  453 // a VPC. For more information, see Elastic IP Addresses (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html)
  454 // in the Amazon Elastic Compute Cloud User Guide.
  455 //
  456 // [EC2-Classic, VPC in an EC2-VPC-only account] If the Elastic IP address is
  457 // already associated with a different instance, it is disassociated from that
  458 // instance and associated with the specified instance.
  459 //
  460 // [VPC in an EC2-Classic account] If you don't specify a private IP address,
  461 // the Elastic IP address is associated with the primary IP address. If the
  462 // Elastic IP address is already associated with a different instance or a network
  463 // interface, you get an error unless you allow reassociation.
  464 //
  465 // This is an idempotent operation. If you perform the operation more than once,
  466 // Amazon EC2 doesn't return an error, and you may be charged for each time
  467 // the Elastic IP address is remapped to the same instance. For more information,
  468 // see the Elastic IP Addresses section of Amazon EC2 Pricing (http://aws.amazon.com/ec2/pricing/).
  469 //
  470 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  471 // with awserr.Error's Code and Message methods to get detailed information about
  472 // the error.
  473 //
  474 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
  475 // API operation AssociateAddress for usage and error information.
  476 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateAddress
  477 func (c *EC2) AssociateAddress(input *AssociateAddressInput) (*AssociateAddressOutput, error) {
  478     req, out := c.AssociateAddressRequest(input)
  479     err := req.Send()
  480     return out, err
  481 }
  482 
  483 const opAssociateDhcpOptions = "AssociateDhcpOptions"
  484 
  485 // AssociateDhcpOptionsRequest generates a "aws/request.Request" representing the
  486 // client's request for the AssociateDhcpOptions operation. The "output" return
  487 // value can be used to capture response data after the request's "Send" method
  488 // is called.
  489 //
  490 // See AssociateDhcpOptions for usage and error information.
  491 //
  492 // Creating a request object using this method should be used when you want to inject
  493 // custom logic into the request's lifecycle using a custom handler, or if you want to
  494 // access properties on the request object before or after sending the request. If
  495 // you just want the service response, call the AssociateDhcpOptions method directly
  496 // instead.
  497 //
  498 // Note: You must call the "Send" method on the returned request object in order
  499 // to execute the request.
  500 //
  501 //    // Example sending a request using the AssociateDhcpOptionsRequest method.
  502 //    req, resp := client.AssociateDhcpOptionsRequest(params)
  503 //
  504 //    err := req.Send()
  505 //    if err == nil { // resp is now filled
  506 //        fmt.Println(resp)
  507 //    }
  508 //
  509 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateDhcpOptions
  510 func (c *EC2) AssociateDhcpOptionsRequest(input *AssociateDhcpOptionsInput) (req *request.Request, output *AssociateDhcpOptionsOutput) {
  511     op := &request.Operation{
  512         Name:       opAssociateDhcpOptions,
  513         HTTPMethod: "POST",
  514         HTTPPath:   "/",
  515     }
  516 
  517     if input == nil {
  518         input = &AssociateDhcpOptionsInput{}
  519     }
  520 
  521     output = &AssociateDhcpOptionsOutput{}
  522     req = c.newRequest(op, input, output)
  523     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
  524     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
  525     return
  526 }
  527 
  528 // AssociateDhcpOptions API operation for Amazon Elastic Compute Cloud.
  529 //
  530 // Associates a set of DHCP options (that you've previously created) with the
  531 // specified VPC, or associates no DHCP options with the VPC.
  532 //
  533 // After you associate the options with the VPC, any existing instances and
  534 // all new instances that you launch in that VPC use the options. You don't
  535 // need to restart or relaunch the instances. They automatically pick up the
  536 // changes within a few hours, depending on how frequently the instance renews
  537 // its DHCP lease. You can explicitly renew the lease using the operating system
  538 // on the instance.
  539 //
  540 // For more information, see DHCP Options Sets (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_DHCP_Options.html)
  541 // in the Amazon Virtual Private Cloud User Guide.
  542 //
  543 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  544 // with awserr.Error's Code and Message methods to get detailed information about
  545 // the error.
  546 //
  547 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
  548 // API operation AssociateDhcpOptions for usage and error information.
  549 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateDhcpOptions
  550 func (c *EC2) AssociateDhcpOptions(input *AssociateDhcpOptionsInput) (*AssociateDhcpOptionsOutput, error) {
  551     req, out := c.AssociateDhcpOptionsRequest(input)
  552     err := req.Send()
  553     return out, err
  554 }
  555 
  556 const opAssociateIamInstanceProfile = "AssociateIamInstanceProfile"
  557 
  558 // AssociateIamInstanceProfileRequest generates a "aws/request.Request" representing the
  559 // client's request for the AssociateIamInstanceProfile operation. The "output" return
  560 // value can be used to capture response data after the request's "Send" method
  561 // is called.
  562 //
  563 // See AssociateIamInstanceProfile for usage and error information.
  564 //
  565 // Creating a request object using this method should be used when you want to inject
  566 // custom logic into the request's lifecycle using a custom handler, or if you want to
  567 // access properties on the request object before or after sending the request. If
  568 // you just want the service response, call the AssociateIamInstanceProfile method directly
  569 // instead.
  570 //
  571 // Note: You must call the "Send" method on the returned request object in order
  572 // to execute the request.
  573 //
  574 //    // Example sending a request using the AssociateIamInstanceProfileRequest method.
  575 //    req, resp := client.AssociateIamInstanceProfileRequest(params)
  576 //
  577 //    err := req.Send()
  578 //    if err == nil { // resp is now filled
  579 //        fmt.Println(resp)
  580 //    }
  581 //
  582 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateIamInstanceProfile
  583 func (c *EC2) AssociateIamInstanceProfileRequest(input *AssociateIamInstanceProfileInput) (req *request.Request, output *AssociateIamInstanceProfileOutput) {
  584     op := &request.Operation{
  585         Name:       opAssociateIamInstanceProfile,
  586         HTTPMethod: "POST",
  587         HTTPPath:   "/",
  588     }
  589 
  590     if input == nil {
  591         input = &AssociateIamInstanceProfileInput{}
  592     }
  593 
  594     output = &AssociateIamInstanceProfileOutput{}
  595     req = c.newRequest(op, input, output)
  596     return
  597 }
  598 
  599 // AssociateIamInstanceProfile API operation for Amazon Elastic Compute Cloud.
  600 //
  601 // Associates an IAM instance profile with a running or stopped instance. You
  602 // cannot associate more than one IAM instance profile with an instance.
  603 //
  604 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  605 // with awserr.Error's Code and Message methods to get detailed information about
  606 // the error.
  607 //
  608 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
  609 // API operation AssociateIamInstanceProfile for usage and error information.
  610 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateIamInstanceProfile
  611 func (c *EC2) AssociateIamInstanceProfile(input *AssociateIamInstanceProfileInput) (*AssociateIamInstanceProfileOutput, error) {
  612     req, out := c.AssociateIamInstanceProfileRequest(input)
  613     err := req.Send()
  614     return out, err
  615 }
  616 
  617 const opAssociateRouteTable = "AssociateRouteTable"
  618 
  619 // AssociateRouteTableRequest generates a "aws/request.Request" representing the
  620 // client's request for the AssociateRouteTable operation. The "output" return
  621 // value can be used to capture response data after the request's "Send" method
  622 // is called.
  623 //
  624 // See AssociateRouteTable for usage and error information.
  625 //
  626 // Creating a request object using this method should be used when you want to inject
  627 // custom logic into the request's lifecycle using a custom handler, or if you want to
  628 // access properties on the request object before or after sending the request. If
  629 // you just want the service response, call the AssociateRouteTable method directly
  630 // instead.
  631 //
  632 // Note: You must call the "Send" method on the returned request object in order
  633 // to execute the request.
  634 //
  635 //    // Example sending a request using the AssociateRouteTableRequest method.
  636 //    req, resp := client.AssociateRouteTableRequest(params)
  637 //
  638 //    err := req.Send()
  639 //    if err == nil { // resp is now filled
  640 //        fmt.Println(resp)
  641 //    }
  642 //
  643 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateRouteTable
  644 func (c *EC2) AssociateRouteTableRequest(input *AssociateRouteTableInput) (req *request.Request, output *AssociateRouteTableOutput) {
  645     op := &request.Operation{
  646         Name:       opAssociateRouteTable,
  647         HTTPMethod: "POST",
  648         HTTPPath:   "/",
  649     }
  650 
  651     if input == nil {
  652         input = &AssociateRouteTableInput{}
  653     }
  654 
  655     output = &AssociateRouteTableOutput{}
  656     req = c.newRequest(op, input, output)
  657     return
  658 }
  659 
  660 // AssociateRouteTable API operation for Amazon Elastic Compute Cloud.
  661 //
  662 // Associates a subnet with a route table. The subnet and route table must be
  663 // in the same VPC. This association causes traffic originating from the subnet
  664 // to be routed according to the routes in the route table. The action returns
  665 // an association ID, which you need in order to disassociate the route table
  666 // from the subnet later. A route table can be associated with multiple subnets.
  667 //
  668 // For more information about route tables, see Route Tables (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Route_Tables.html)
  669 // in the Amazon Virtual Private Cloud User Guide.
  670 //
  671 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  672 // with awserr.Error's Code and Message methods to get detailed information about
  673 // the error.
  674 //
  675 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
  676 // API operation AssociateRouteTable for usage and error information.
  677 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateRouteTable
  678 func (c *EC2) AssociateRouteTable(input *AssociateRouteTableInput) (*AssociateRouteTableOutput, error) {
  679     req, out := c.AssociateRouteTableRequest(input)
  680     err := req.Send()
  681     return out, err
  682 }
  683 
  684 const opAssociateSubnetCidrBlock = "AssociateSubnetCidrBlock"
  685 
  686 // AssociateSubnetCidrBlockRequest generates a "aws/request.Request" representing the
  687 // client's request for the AssociateSubnetCidrBlock operation. The "output" return
  688 // value can be used to capture response data after the request's "Send" method
  689 // is called.
  690 //
  691 // See AssociateSubnetCidrBlock for usage and error information.
  692 //
  693 // Creating a request object using this method should be used when you want to inject
  694 // custom logic into the request's lifecycle using a custom handler, or if you want to
  695 // access properties on the request object before or after sending the request. If
  696 // you just want the service response, call the AssociateSubnetCidrBlock method directly
  697 // instead.
  698 //
  699 // Note: You must call the "Send" method on the returned request object in order
  700 // to execute the request.
  701 //
  702 //    // Example sending a request using the AssociateSubnetCidrBlockRequest method.
  703 //    req, resp := client.AssociateSubnetCidrBlockRequest(params)
  704 //
  705 //    err := req.Send()
  706 //    if err == nil { // resp is now filled
  707 //        fmt.Println(resp)
  708 //    }
  709 //
  710 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateSubnetCidrBlock
  711 func (c *EC2) AssociateSubnetCidrBlockRequest(input *AssociateSubnetCidrBlockInput) (req *request.Request, output *AssociateSubnetCidrBlockOutput) {
  712     op := &request.Operation{
  713         Name:       opAssociateSubnetCidrBlock,
  714         HTTPMethod: "POST",
  715         HTTPPath:   "/",
  716     }
  717 
  718     if input == nil {
  719         input = &AssociateSubnetCidrBlockInput{}
  720     }
  721 
  722     output = &AssociateSubnetCidrBlockOutput{}
  723     req = c.newRequest(op, input, output)
  724     return
  725 }
  726 
  727 // AssociateSubnetCidrBlock API operation for Amazon Elastic Compute Cloud.
  728 //
  729 // Associates a CIDR block with your subnet. You can only associate a single
  730 // IPv6 CIDR block with your subnet. An IPv6 CIDR block must have a prefix length
  731 // of /64.
  732 //
  733 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  734 // with awserr.Error's Code and Message methods to get detailed information about
  735 // the error.
  736 //
  737 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
  738 // API operation AssociateSubnetCidrBlock for usage and error information.
  739 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateSubnetCidrBlock
  740 func (c *EC2) AssociateSubnetCidrBlock(input *AssociateSubnetCidrBlockInput) (*AssociateSubnetCidrBlockOutput, error) {
  741     req, out := c.AssociateSubnetCidrBlockRequest(input)
  742     err := req.Send()
  743     return out, err
  744 }
  745 
  746 const opAssociateVpcCidrBlock = "AssociateVpcCidrBlock"
  747 
  748 // AssociateVpcCidrBlockRequest generates a "aws/request.Request" representing the
  749 // client's request for the AssociateVpcCidrBlock operation. The "output" return
  750 // value can be used to capture response data after the request's "Send" method
  751 // is called.
  752 //
  753 // See AssociateVpcCidrBlock for usage and error information.
  754 //
  755 // Creating a request object using this method should be used when you want to inject
  756 // custom logic into the request's lifecycle using a custom handler, or if you want to
  757 // access properties on the request object before or after sending the request. If
  758 // you just want the service response, call the AssociateVpcCidrBlock method directly
  759 // instead.
  760 //
  761 // Note: You must call the "Send" method on the returned request object in order
  762 // to execute the request.
  763 //
  764 //    // Example sending a request using the AssociateVpcCidrBlockRequest method.
  765 //    req, resp := client.AssociateVpcCidrBlockRequest(params)
  766 //
  767 //    err := req.Send()
  768 //    if err == nil { // resp is now filled
  769 //        fmt.Println(resp)
  770 //    }
  771 //
  772 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateVpcCidrBlock
  773 func (c *EC2) AssociateVpcCidrBlockRequest(input *AssociateVpcCidrBlockInput) (req *request.Request, output *AssociateVpcCidrBlockOutput) {
  774     op := &request.Operation{
  775         Name:       opAssociateVpcCidrBlock,
  776         HTTPMethod: "POST",
  777         HTTPPath:   "/",
  778     }
  779 
  780     if input == nil {
  781         input = &AssociateVpcCidrBlockInput{}
  782     }
  783 
  784     output = &AssociateVpcCidrBlockOutput{}
  785     req = c.newRequest(op, input, output)
  786     return
  787 }
  788 
  789 // AssociateVpcCidrBlock API operation for Amazon Elastic Compute Cloud.
  790 //
  791 // Associates a CIDR block with your VPC. You can only associate a single Amazon-provided
  792 // IPv6 CIDR block with your VPC. The IPv6 CIDR block size is fixed at /56.
  793 //
  794 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  795 // with awserr.Error's Code and Message methods to get detailed information about
  796 // the error.
  797 //
  798 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
  799 // API operation AssociateVpcCidrBlock for usage and error information.
  800 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateVpcCidrBlock
  801 func (c *EC2) AssociateVpcCidrBlock(input *AssociateVpcCidrBlockInput) (*AssociateVpcCidrBlockOutput, error) {
  802     req, out := c.AssociateVpcCidrBlockRequest(input)
  803     err := req.Send()
  804     return out, err
  805 }
  806 
  807 const opAttachClassicLinkVpc = "AttachClassicLinkVpc"
  808 
  809 // AttachClassicLinkVpcRequest generates a "aws/request.Request" representing the
  810 // client's request for the AttachClassicLinkVpc operation. The "output" return
  811 // value can be used to capture response data after the request's "Send" method
  812 // is called.
  813 //
  814 // See AttachClassicLinkVpc for usage and error information.
  815 //
  816 // Creating a request object using this method should be used when you want to inject
  817 // custom logic into the request's lifecycle using a custom handler, or if you want to
  818 // access properties on the request object before or after sending the request. If
  819 // you just want the service response, call the AttachClassicLinkVpc method directly
  820 // instead.
  821 //
  822 // Note: You must call the "Send" method on the returned request object in order
  823 // to execute the request.
  824 //
  825 //    // Example sending a request using the AttachClassicLinkVpcRequest method.
  826 //    req, resp := client.AttachClassicLinkVpcRequest(params)
  827 //
  828 //    err := req.Send()
  829 //    if err == nil { // resp is now filled
  830 //        fmt.Println(resp)
  831 //    }
  832 //
  833 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachClassicLinkVpc
  834 func (c *EC2) AttachClassicLinkVpcRequest(input *AttachClassicLinkVpcInput) (req *request.Request, output *AttachClassicLinkVpcOutput) {
  835     op := &request.Operation{
  836         Name:       opAttachClassicLinkVpc,
  837         HTTPMethod: "POST",
  838         HTTPPath:   "/",
  839     }
  840 
  841     if input == nil {
  842         input = &AttachClassicLinkVpcInput{}
  843     }
  844 
  845     output = &AttachClassicLinkVpcOutput{}
  846     req = c.newRequest(op, input, output)
  847     return
  848 }
  849 
  850 // AttachClassicLinkVpc API operation for Amazon Elastic Compute Cloud.
  851 //
  852 // Links an EC2-Classic instance to a ClassicLink-enabled VPC through one or
  853 // more of the VPC's security groups. You cannot link an EC2-Classic instance
  854 // to more than one VPC at a time. You can only link an instance that's in the
  855 // running state. An instance is automatically unlinked from a VPC when it's
  856 // stopped - you can link it to the VPC again when you restart it.
  857 //
  858 // After you've linked an instance, you cannot change the VPC security groups
  859 // that are associated with it. To change the security groups, you must first
  860 // unlink the instance, and then link it again.
  861 //
  862 // Linking your instance to a VPC is sometimes referred to as attaching your
  863 // instance.
  864 //
  865 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  866 // with awserr.Error's Code and Message methods to get detailed information about
  867 // the error.
  868 //
  869 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
  870 // API operation AttachClassicLinkVpc for usage and error information.
  871 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachClassicLinkVpc
  872 func (c *EC2) AttachClassicLinkVpc(input *AttachClassicLinkVpcInput) (*AttachClassicLinkVpcOutput, error) {
  873     req, out := c.AttachClassicLinkVpcRequest(input)
  874     err := req.Send()
  875     return out, err
  876 }
  877 
  878 const opAttachInternetGateway = "AttachInternetGateway"
  879 
  880 // AttachInternetGatewayRequest generates a "aws/request.Request" representing the
  881 // client's request for the AttachInternetGateway operation. The "output" return
  882 // value can be used to capture response data after the request's "Send" method
  883 // is called.
  884 //
  885 // See AttachInternetGateway for usage and error information.
  886 //
  887 // Creating a request object using this method should be used when you want to inject
  888 // custom logic into the request's lifecycle using a custom handler, or if you want to
  889 // access properties on the request object before or after sending the request. If
  890 // you just want the service response, call the AttachInternetGateway method directly
  891 // instead.
  892 //
  893 // Note: You must call the "Send" method on the returned request object in order
  894 // to execute the request.
  895 //
  896 //    // Example sending a request using the AttachInternetGatewayRequest method.
  897 //    req, resp := client.AttachInternetGatewayRequest(params)
  898 //
  899 //    err := req.Send()
  900 //    if err == nil { // resp is now filled
  901 //        fmt.Println(resp)
  902 //    }
  903 //
  904 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachInternetGateway
  905 func (c *EC2) AttachInternetGatewayRequest(input *AttachInternetGatewayInput) (req *request.Request, output *AttachInternetGatewayOutput) {
  906     op := &request.Operation{
  907         Name:       opAttachInternetGateway,
  908         HTTPMethod: "POST",
  909         HTTPPath:   "/",
  910     }
  911 
  912     if input == nil {
  913         input = &AttachInternetGatewayInput{}
  914     }
  915 
  916     output = &AttachInternetGatewayOutput{}
  917     req = c.newRequest(op, input, output)
  918     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
  919     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
  920     return
  921 }
  922 
  923 // AttachInternetGateway API operation for Amazon Elastic Compute Cloud.
  924 //
  925 // Attaches an Internet gateway to a VPC, enabling connectivity between the
  926 // Internet and the VPC. For more information about your VPC and Internet gateway,
  927 // see the Amazon Virtual Private Cloud User Guide (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/).
  928 //
  929 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  930 // with awserr.Error's Code and Message methods to get detailed information about
  931 // the error.
  932 //
  933 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
  934 // API operation AttachInternetGateway for usage and error information.
  935 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachInternetGateway
  936 func (c *EC2) AttachInternetGateway(input *AttachInternetGatewayInput) (*AttachInternetGatewayOutput, error) {
  937     req, out := c.AttachInternetGatewayRequest(input)
  938     err := req.Send()
  939     return out, err
  940 }
  941 
  942 const opAttachNetworkInterface = "AttachNetworkInterface"
  943 
  944 // AttachNetworkInterfaceRequest generates a "aws/request.Request" representing the
  945 // client's request for the AttachNetworkInterface operation. The "output" return
  946 // value can be used to capture response data after the request's "Send" method
  947 // is called.
  948 //
  949 // See AttachNetworkInterface for usage and error information.
  950 //
  951 // Creating a request object using this method should be used when you want to inject
  952 // custom logic into the request's lifecycle using a custom handler, or if you want to
  953 // access properties on the request object before or after sending the request. If
  954 // you just want the service response, call the AttachNetworkInterface method directly
  955 // instead.
  956 //
  957 // Note: You must call the "Send" method on the returned request object in order
  958 // to execute the request.
  959 //
  960 //    // Example sending a request using the AttachNetworkInterfaceRequest method.
  961 //    req, resp := client.AttachNetworkInterfaceRequest(params)
  962 //
  963 //    err := req.Send()
  964 //    if err == nil { // resp is now filled
  965 //        fmt.Println(resp)
  966 //    }
  967 //
  968 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachNetworkInterface
  969 func (c *EC2) AttachNetworkInterfaceRequest(input *AttachNetworkInterfaceInput) (req *request.Request, output *AttachNetworkInterfaceOutput) {
  970     op := &request.Operation{
  971         Name:       opAttachNetworkInterface,
  972         HTTPMethod: "POST",
  973         HTTPPath:   "/",
  974     }
  975 
  976     if input == nil {
  977         input = &AttachNetworkInterfaceInput{}
  978     }
  979 
  980     output = &AttachNetworkInterfaceOutput{}
  981     req = c.newRequest(op, input, output)
  982     return
  983 }
  984 
  985 // AttachNetworkInterface API operation for Amazon Elastic Compute Cloud.
  986 //
  987 // Attaches a network interface to an instance.
  988 //
  989 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
  990 // with awserr.Error's Code and Message methods to get detailed information about
  991 // the error.
  992 //
  993 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
  994 // API operation AttachNetworkInterface for usage and error information.
  995 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachNetworkInterface
  996 func (c *EC2) AttachNetworkInterface(input *AttachNetworkInterfaceInput) (*AttachNetworkInterfaceOutput, error) {
  997     req, out := c.AttachNetworkInterfaceRequest(input)
  998     err := req.Send()
  999     return out, err
 1000 }
 1001 
 1002 const opAttachVolume = "AttachVolume"
 1003 
 1004 // AttachVolumeRequest generates a "aws/request.Request" representing the
 1005 // client's request for the AttachVolume operation. The "output" return
 1006 // value can be used to capture response data after the request's "Send" method
 1007 // is called.
 1008 //
 1009 // See AttachVolume for usage and error information.
 1010 //
 1011 // Creating a request object using this method should be used when you want to inject
 1012 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1013 // access properties on the request object before or after sending the request. If
 1014 // you just want the service response, call the AttachVolume method directly
 1015 // instead.
 1016 //
 1017 // Note: You must call the "Send" method on the returned request object in order
 1018 // to execute the request.
 1019 //
 1020 //    // Example sending a request using the AttachVolumeRequest method.
 1021 //    req, resp := client.AttachVolumeRequest(params)
 1022 //
 1023 //    err := req.Send()
 1024 //    if err == nil { // resp is now filled
 1025 //        fmt.Println(resp)
 1026 //    }
 1027 //
 1028 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVolume
 1029 func (c *EC2) AttachVolumeRequest(input *AttachVolumeInput) (req *request.Request, output *VolumeAttachment) {
 1030     op := &request.Operation{
 1031         Name:       opAttachVolume,
 1032         HTTPMethod: "POST",
 1033         HTTPPath:   "/",
 1034     }
 1035 
 1036     if input == nil {
 1037         input = &AttachVolumeInput{}
 1038     }
 1039 
 1040     output = &VolumeAttachment{}
 1041     req = c.newRequest(op, input, output)
 1042     return
 1043 }
 1044 
 1045 // AttachVolume API operation for Amazon Elastic Compute Cloud.
 1046 //
 1047 // Attaches an EBS volume to a running or stopped instance and exposes it to
 1048 // the instance with the specified device name.
 1049 //
 1050 // Encrypted EBS volumes may only be attached to instances that support Amazon
 1051 // EBS encryption. For more information, see Amazon EBS Encryption (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html)
 1052 // in the Amazon Elastic Compute Cloud User Guide.
 1053 //
 1054 // For a list of supported device names, see Attaching an EBS Volume to an Instance
 1055 // (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-attaching-volume.html).
 1056 // Any device names that aren't reserved for instance store volumes can be used
 1057 // for EBS volumes. For more information, see Amazon EC2 Instance Store (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html)
 1058 // in the Amazon Elastic Compute Cloud User Guide.
 1059 //
 1060 // If a volume has an AWS Marketplace product code:
 1061 //
 1062 //    * The volume can be attached only to a stopped instance.
 1063 //
 1064 //    * AWS Marketplace product codes are copied from the volume to the instance.
 1065 //
 1066 //    * You must be subscribed to the product.
 1067 //
 1068 //    * The instance type and operating system of the instance must support
 1069 //    the product. For example, you can't detach a volume from a Windows instance
 1070 //    and attach it to a Linux instance.
 1071 //
 1072 // For an overview of the AWS Marketplace, see Introducing AWS Marketplace (https://aws.amazon.com/marketplace/help/200900000).
 1073 //
 1074 // For more information about EBS volumes, see Attaching Amazon EBS Volumes
 1075 // (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-attaching-volume.html)
 1076 // in the Amazon Elastic Compute Cloud User Guide.
 1077 //
 1078 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 1079 // with awserr.Error's Code and Message methods to get detailed information about
 1080 // the error.
 1081 //
 1082 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 1083 // API operation AttachVolume for usage and error information.
 1084 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVolume
 1085 func (c *EC2) AttachVolume(input *AttachVolumeInput) (*VolumeAttachment, error) {
 1086     req, out := c.AttachVolumeRequest(input)
 1087     err := req.Send()
 1088     return out, err
 1089 }
 1090 
 1091 const opAttachVpnGateway = "AttachVpnGateway"
 1092 
 1093 // AttachVpnGatewayRequest generates a "aws/request.Request" representing the
 1094 // client's request for the AttachVpnGateway operation. The "output" return
 1095 // value can be used to capture response data after the request's "Send" method
 1096 // is called.
 1097 //
 1098 // See AttachVpnGateway for usage and error information.
 1099 //
 1100 // Creating a request object using this method should be used when you want to inject
 1101 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1102 // access properties on the request object before or after sending the request. If
 1103 // you just want the service response, call the AttachVpnGateway method directly
 1104 // instead.
 1105 //
 1106 // Note: You must call the "Send" method on the returned request object in order
 1107 // to execute the request.
 1108 //
 1109 //    // Example sending a request using the AttachVpnGatewayRequest method.
 1110 //    req, resp := client.AttachVpnGatewayRequest(params)
 1111 //
 1112 //    err := req.Send()
 1113 //    if err == nil { // resp is now filled
 1114 //        fmt.Println(resp)
 1115 //    }
 1116 //
 1117 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVpnGateway
 1118 func (c *EC2) AttachVpnGatewayRequest(input *AttachVpnGatewayInput) (req *request.Request, output *AttachVpnGatewayOutput) {
 1119     op := &request.Operation{
 1120         Name:       opAttachVpnGateway,
 1121         HTTPMethod: "POST",
 1122         HTTPPath:   "/",
 1123     }
 1124 
 1125     if input == nil {
 1126         input = &AttachVpnGatewayInput{}
 1127     }
 1128 
 1129     output = &AttachVpnGatewayOutput{}
 1130     req = c.newRequest(op, input, output)
 1131     return
 1132 }
 1133 
 1134 // AttachVpnGateway API operation for Amazon Elastic Compute Cloud.
 1135 //
 1136 // Attaches a virtual private gateway to a VPC. For more information, see Adding
 1137 // a Hardware Virtual Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
 1138 // in the Amazon Virtual Private Cloud User Guide.
 1139 //
 1140 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 1141 // with awserr.Error's Code and Message methods to get detailed information about
 1142 // the error.
 1143 //
 1144 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 1145 // API operation AttachVpnGateway for usage and error information.
 1146 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVpnGateway
 1147 func (c *EC2) AttachVpnGateway(input *AttachVpnGatewayInput) (*AttachVpnGatewayOutput, error) {
 1148     req, out := c.AttachVpnGatewayRequest(input)
 1149     err := req.Send()
 1150     return out, err
 1151 }
 1152 
 1153 const opAuthorizeSecurityGroupEgress = "AuthorizeSecurityGroupEgress"
 1154 
 1155 // AuthorizeSecurityGroupEgressRequest generates a "aws/request.Request" representing the
 1156 // client's request for the AuthorizeSecurityGroupEgress operation. The "output" return
 1157 // value can be used to capture response data after the request's "Send" method
 1158 // is called.
 1159 //
 1160 // See AuthorizeSecurityGroupEgress for usage and error information.
 1161 //
 1162 // Creating a request object using this method should be used when you want to inject
 1163 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1164 // access properties on the request object before or after sending the request. If
 1165 // you just want the service response, call the AuthorizeSecurityGroupEgress method directly
 1166 // instead.
 1167 //
 1168 // Note: You must call the "Send" method on the returned request object in order
 1169 // to execute the request.
 1170 //
 1171 //    // Example sending a request using the AuthorizeSecurityGroupEgressRequest method.
 1172 //    req, resp := client.AuthorizeSecurityGroupEgressRequest(params)
 1173 //
 1174 //    err := req.Send()
 1175 //    if err == nil { // resp is now filled
 1176 //        fmt.Println(resp)
 1177 //    }
 1178 //
 1179 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeSecurityGroupEgress
 1180 func (c *EC2) AuthorizeSecurityGroupEgressRequest(input *AuthorizeSecurityGroupEgressInput) (req *request.Request, output *AuthorizeSecurityGroupEgressOutput) {
 1181     op := &request.Operation{
 1182         Name:       opAuthorizeSecurityGroupEgress,
 1183         HTTPMethod: "POST",
 1184         HTTPPath:   "/",
 1185     }
 1186 
 1187     if input == nil {
 1188         input = &AuthorizeSecurityGroupEgressInput{}
 1189     }
 1190 
 1191     output = &AuthorizeSecurityGroupEgressOutput{}
 1192     req = c.newRequest(op, input, output)
 1193     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 1194     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 1195     return
 1196 }
 1197 
 1198 // AuthorizeSecurityGroupEgress API operation for Amazon Elastic Compute Cloud.
 1199 //
 1200 // [EC2-VPC only] Adds one or more egress rules to a security group for use
 1201 // with a VPC. Specifically, this action permits instances to send traffic to
 1202 // one or more destination IPv4 or IPv6 CIDR address ranges, or to one or more
 1203 // destination security groups for the same VPC. This action doesn't apply to
 1204 // security groups for use in EC2-Classic. For more information, see Security
 1205 // Groups for Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_SecurityGroups.html)
 1206 // in the Amazon Virtual Private Cloud User Guide. For more information about
 1207 // security group limits, see Amazon VPC Limits (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Appendix_Limits.html).
 1208 //
 1209 // Each rule consists of the protocol (for example, TCP), plus either a CIDR
 1210 // range or a source group. For the TCP and UDP protocols, you must also specify
 1211 // the destination port or port range. For the ICMP protocol, you must also
 1212 // specify the ICMP type and code. You can use -1 for the type or code to mean
 1213 // all types or all codes.
 1214 //
 1215 // Rule changes are propagated to affected instances as quickly as possible.
 1216 // However, a small delay might occur.
 1217 //
 1218 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 1219 // with awserr.Error's Code and Message methods to get detailed information about
 1220 // the error.
 1221 //
 1222 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 1223 // API operation AuthorizeSecurityGroupEgress for usage and error information.
 1224 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeSecurityGroupEgress
 1225 func (c *EC2) AuthorizeSecurityGroupEgress(input *AuthorizeSecurityGroupEgressInput) (*AuthorizeSecurityGroupEgressOutput, error) {
 1226     req, out := c.AuthorizeSecurityGroupEgressRequest(input)
 1227     err := req.Send()
 1228     return out, err
 1229 }
 1230 
 1231 const opAuthorizeSecurityGroupIngress = "AuthorizeSecurityGroupIngress"
 1232 
 1233 // AuthorizeSecurityGroupIngressRequest generates a "aws/request.Request" representing the
 1234 // client's request for the AuthorizeSecurityGroupIngress operation. The "output" return
 1235 // value can be used to capture response data after the request's "Send" method
 1236 // is called.
 1237 //
 1238 // See AuthorizeSecurityGroupIngress for usage and error information.
 1239 //
 1240 // Creating a request object using this method should be used when you want to inject
 1241 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1242 // access properties on the request object before or after sending the request. If
 1243 // you just want the service response, call the AuthorizeSecurityGroupIngress method directly
 1244 // instead.
 1245 //
 1246 // Note: You must call the "Send" method on the returned request object in order
 1247 // to execute the request.
 1248 //
 1249 //    // Example sending a request using the AuthorizeSecurityGroupIngressRequest method.
 1250 //    req, resp := client.AuthorizeSecurityGroupIngressRequest(params)
 1251 //
 1252 //    err := req.Send()
 1253 //    if err == nil { // resp is now filled
 1254 //        fmt.Println(resp)
 1255 //    }
 1256 //
 1257 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeSecurityGroupIngress
 1258 func (c *EC2) AuthorizeSecurityGroupIngressRequest(input *AuthorizeSecurityGroupIngressInput) (req *request.Request, output *AuthorizeSecurityGroupIngressOutput) {
 1259     op := &request.Operation{
 1260         Name:       opAuthorizeSecurityGroupIngress,
 1261         HTTPMethod: "POST",
 1262         HTTPPath:   "/",
 1263     }
 1264 
 1265     if input == nil {
 1266         input = &AuthorizeSecurityGroupIngressInput{}
 1267     }
 1268 
 1269     output = &AuthorizeSecurityGroupIngressOutput{}
 1270     req = c.newRequest(op, input, output)
 1271     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 1272     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 1273     return
 1274 }
 1275 
 1276 // AuthorizeSecurityGroupIngress API operation for Amazon Elastic Compute Cloud.
 1277 //
 1278 // Adds one or more ingress rules to a security group.
 1279 //
 1280 // Rule changes are propagated to instances within the security group as quickly
 1281 // as possible. However, a small delay might occur.
 1282 //
 1283 // [EC2-Classic] This action gives one or more IPv4 CIDR address ranges permission
 1284 // to access a security group in your account, or gives one or more security
 1285 // groups (called the source groups) permission to access a security group for
 1286 // your account. A source group can be for your own AWS account, or another.
 1287 // You can have up to 100 rules per group.
 1288 //
 1289 // [EC2-VPC] This action gives one or more IPv4 or IPv6 CIDR address ranges
 1290 // permission to access a security group in your VPC, or gives one or more other
 1291 // security groups (called the source groups) permission to access a security
 1292 // group for your VPC. The security groups must all be for the same VPC or a
 1293 // peer VPC in a VPC peering connection. For more information about VPC security
 1294 // group limits, see Amazon VPC Limits (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Appendix_Limits.html).
 1295 //
 1296 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 1297 // with awserr.Error's Code and Message methods to get detailed information about
 1298 // the error.
 1299 //
 1300 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 1301 // API operation AuthorizeSecurityGroupIngress for usage and error information.
 1302 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeSecurityGroupIngress
 1303 func (c *EC2) AuthorizeSecurityGroupIngress(input *AuthorizeSecurityGroupIngressInput) (*AuthorizeSecurityGroupIngressOutput, error) {
 1304     req, out := c.AuthorizeSecurityGroupIngressRequest(input)
 1305     err := req.Send()
 1306     return out, err
 1307 }
 1308 
 1309 const opBundleInstance = "BundleInstance"
 1310 
 1311 // BundleInstanceRequest generates a "aws/request.Request" representing the
 1312 // client's request for the BundleInstance operation. The "output" return
 1313 // value can be used to capture response data after the request's "Send" method
 1314 // is called.
 1315 //
 1316 // See BundleInstance for usage and error information.
 1317 //
 1318 // Creating a request object using this method should be used when you want to inject
 1319 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1320 // access properties on the request object before or after sending the request. If
 1321 // you just want the service response, call the BundleInstance method directly
 1322 // instead.
 1323 //
 1324 // Note: You must call the "Send" method on the returned request object in order
 1325 // to execute the request.
 1326 //
 1327 //    // Example sending a request using the BundleInstanceRequest method.
 1328 //    req, resp := client.BundleInstanceRequest(params)
 1329 //
 1330 //    err := req.Send()
 1331 //    if err == nil { // resp is now filled
 1332 //        fmt.Println(resp)
 1333 //    }
 1334 //
 1335 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/BundleInstance
 1336 func (c *EC2) BundleInstanceRequest(input *BundleInstanceInput) (req *request.Request, output *BundleInstanceOutput) {
 1337     op := &request.Operation{
 1338         Name:       opBundleInstance,
 1339         HTTPMethod: "POST",
 1340         HTTPPath:   "/",
 1341     }
 1342 
 1343     if input == nil {
 1344         input = &BundleInstanceInput{}
 1345     }
 1346 
 1347     output = &BundleInstanceOutput{}
 1348     req = c.newRequest(op, input, output)
 1349     return
 1350 }
 1351 
 1352 // BundleInstance API operation for Amazon Elastic Compute Cloud.
 1353 //
 1354 // Bundles an Amazon instance store-backed Windows instance.
 1355 //
 1356 // During bundling, only the root device volume (C:\) is bundled. Data on other
 1357 // instance store volumes is not preserved.
 1358 //
 1359 // This action is not applicable for Linux/Unix instances or Windows instances
 1360 // that are backed by Amazon EBS.
 1361 //
 1362 // For more information, see Creating an Instance Store-Backed Windows AMI (http://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/Creating_InstanceStoreBacked_WinAMI.html).
 1363 //
 1364 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 1365 // with awserr.Error's Code and Message methods to get detailed information about
 1366 // the error.
 1367 //
 1368 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 1369 // API operation BundleInstance for usage and error information.
 1370 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/BundleInstance
 1371 func (c *EC2) BundleInstance(input *BundleInstanceInput) (*BundleInstanceOutput, error) {
 1372     req, out := c.BundleInstanceRequest(input)
 1373     err := req.Send()
 1374     return out, err
 1375 }
 1376 
 1377 const opCancelBundleTask = "CancelBundleTask"
 1378 
 1379 // CancelBundleTaskRequest generates a "aws/request.Request" representing the
 1380 // client's request for the CancelBundleTask operation. The "output" return
 1381 // value can be used to capture response data after the request's "Send" method
 1382 // is called.
 1383 //
 1384 // See CancelBundleTask for usage and error information.
 1385 //
 1386 // Creating a request object using this method should be used when you want to inject
 1387 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1388 // access properties on the request object before or after sending the request. If
 1389 // you just want the service response, call the CancelBundleTask method directly
 1390 // instead.
 1391 //
 1392 // Note: You must call the "Send" method on the returned request object in order
 1393 // to execute the request.
 1394 //
 1395 //    // Example sending a request using the CancelBundleTaskRequest method.
 1396 //    req, resp := client.CancelBundleTaskRequest(params)
 1397 //
 1398 //    err := req.Send()
 1399 //    if err == nil { // resp is now filled
 1400 //        fmt.Println(resp)
 1401 //    }
 1402 //
 1403 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelBundleTask
 1404 func (c *EC2) CancelBundleTaskRequest(input *CancelBundleTaskInput) (req *request.Request, output *CancelBundleTaskOutput) {
 1405     op := &request.Operation{
 1406         Name:       opCancelBundleTask,
 1407         HTTPMethod: "POST",
 1408         HTTPPath:   "/",
 1409     }
 1410 
 1411     if input == nil {
 1412         input = &CancelBundleTaskInput{}
 1413     }
 1414 
 1415     output = &CancelBundleTaskOutput{}
 1416     req = c.newRequest(op, input, output)
 1417     return
 1418 }
 1419 
 1420 // CancelBundleTask API operation for Amazon Elastic Compute Cloud.
 1421 //
 1422 // Cancels a bundling operation for an instance store-backed Windows instance.
 1423 //
 1424 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 1425 // with awserr.Error's Code and Message methods to get detailed information about
 1426 // the error.
 1427 //
 1428 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 1429 // API operation CancelBundleTask for usage and error information.
 1430 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelBundleTask
 1431 func (c *EC2) CancelBundleTask(input *CancelBundleTaskInput) (*CancelBundleTaskOutput, error) {
 1432     req, out := c.CancelBundleTaskRequest(input)
 1433     err := req.Send()
 1434     return out, err
 1435 }
 1436 
 1437 const opCancelConversionTask = "CancelConversionTask"
 1438 
 1439 // CancelConversionTaskRequest generates a "aws/request.Request" representing the
 1440 // client's request for the CancelConversionTask operation. The "output" return
 1441 // value can be used to capture response data after the request's "Send" method
 1442 // is called.
 1443 //
 1444 // See CancelConversionTask for usage and error information.
 1445 //
 1446 // Creating a request object using this method should be used when you want to inject
 1447 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1448 // access properties on the request object before or after sending the request. If
 1449 // you just want the service response, call the CancelConversionTask method directly
 1450 // instead.
 1451 //
 1452 // Note: You must call the "Send" method on the returned request object in order
 1453 // to execute the request.
 1454 //
 1455 //    // Example sending a request using the CancelConversionTaskRequest method.
 1456 //    req, resp := client.CancelConversionTaskRequest(params)
 1457 //
 1458 //    err := req.Send()
 1459 //    if err == nil { // resp is now filled
 1460 //        fmt.Println(resp)
 1461 //    }
 1462 //
 1463 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelConversionTask
 1464 func (c *EC2) CancelConversionTaskRequest(input *CancelConversionTaskInput) (req *request.Request, output *CancelConversionTaskOutput) {
 1465     op := &request.Operation{
 1466         Name:       opCancelConversionTask,
 1467         HTTPMethod: "POST",
 1468         HTTPPath:   "/",
 1469     }
 1470 
 1471     if input == nil {
 1472         input = &CancelConversionTaskInput{}
 1473     }
 1474 
 1475     output = &CancelConversionTaskOutput{}
 1476     req = c.newRequest(op, input, output)
 1477     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 1478     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 1479     return
 1480 }
 1481 
 1482 // CancelConversionTask API operation for Amazon Elastic Compute Cloud.
 1483 //
 1484 // Cancels an active conversion task. The task can be the import of an instance
 1485 // or volume. The action removes all artifacts of the conversion, including
 1486 // a partially uploaded volume or instance. If the conversion is complete or
 1487 // is in the process of transferring the final disk image, the command fails
 1488 // and returns an exception.
 1489 //
 1490 // For more information, see Importing a Virtual Machine Using the Amazon EC2
 1491 // CLI (http://docs.aws.amazon.com/AWSEC2/latest/CommandLineReference/ec2-cli-vmimport-export.html).
 1492 //
 1493 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 1494 // with awserr.Error's Code and Message methods to get detailed information about
 1495 // the error.
 1496 //
 1497 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 1498 // API operation CancelConversionTask for usage and error information.
 1499 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelConversionTask
 1500 func (c *EC2) CancelConversionTask(input *CancelConversionTaskInput) (*CancelConversionTaskOutput, error) {
 1501     req, out := c.CancelConversionTaskRequest(input)
 1502     err := req.Send()
 1503     return out, err
 1504 }
 1505 
 1506 const opCancelExportTask = "CancelExportTask"
 1507 
 1508 // CancelExportTaskRequest generates a "aws/request.Request" representing the
 1509 // client's request for the CancelExportTask operation. The "output" return
 1510 // value can be used to capture response data after the request's "Send" method
 1511 // is called.
 1512 //
 1513 // See CancelExportTask for usage and error information.
 1514 //
 1515 // Creating a request object using this method should be used when you want to inject
 1516 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1517 // access properties on the request object before or after sending the request. If
 1518 // you just want the service response, call the CancelExportTask method directly
 1519 // instead.
 1520 //
 1521 // Note: You must call the "Send" method on the returned request object in order
 1522 // to execute the request.
 1523 //
 1524 //    // Example sending a request using the CancelExportTaskRequest method.
 1525 //    req, resp := client.CancelExportTaskRequest(params)
 1526 //
 1527 //    err := req.Send()
 1528 //    if err == nil { // resp is now filled
 1529 //        fmt.Println(resp)
 1530 //    }
 1531 //
 1532 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelExportTask
 1533 func (c *EC2) CancelExportTaskRequest(input *CancelExportTaskInput) (req *request.Request, output *CancelExportTaskOutput) {
 1534     op := &request.Operation{
 1535         Name:       opCancelExportTask,
 1536         HTTPMethod: "POST",
 1537         HTTPPath:   "/",
 1538     }
 1539 
 1540     if input == nil {
 1541         input = &CancelExportTaskInput{}
 1542     }
 1543 
 1544     output = &CancelExportTaskOutput{}
 1545     req = c.newRequest(op, input, output)
 1546     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 1547     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 1548     return
 1549 }
 1550 
 1551 // CancelExportTask API operation for Amazon Elastic Compute Cloud.
 1552 //
 1553 // Cancels an active export task. The request removes all artifacts of the export,
 1554 // including any partially-created Amazon S3 objects. If the export task is
 1555 // complete or is in the process of transferring the final disk image, the command
 1556 // fails and returns an error.
 1557 //
 1558 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 1559 // with awserr.Error's Code and Message methods to get detailed information about
 1560 // the error.
 1561 //
 1562 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 1563 // API operation CancelExportTask for usage and error information.
 1564 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelExportTask
 1565 func (c *EC2) CancelExportTask(input *CancelExportTaskInput) (*CancelExportTaskOutput, error) {
 1566     req, out := c.CancelExportTaskRequest(input)
 1567     err := req.Send()
 1568     return out, err
 1569 }
 1570 
 1571 const opCancelImportTask = "CancelImportTask"
 1572 
 1573 // CancelImportTaskRequest generates a "aws/request.Request" representing the
 1574 // client's request for the CancelImportTask operation. The "output" return
 1575 // value can be used to capture response data after the request's "Send" method
 1576 // is called.
 1577 //
 1578 // See CancelImportTask for usage and error information.
 1579 //
 1580 // Creating a request object using this method should be used when you want to inject
 1581 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1582 // access properties on the request object before or after sending the request. If
 1583 // you just want the service response, call the CancelImportTask method directly
 1584 // instead.
 1585 //
 1586 // Note: You must call the "Send" method on the returned request object in order
 1587 // to execute the request.
 1588 //
 1589 //    // Example sending a request using the CancelImportTaskRequest method.
 1590 //    req, resp := client.CancelImportTaskRequest(params)
 1591 //
 1592 //    err := req.Send()
 1593 //    if err == nil { // resp is now filled
 1594 //        fmt.Println(resp)
 1595 //    }
 1596 //
 1597 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelImportTask
 1598 func (c *EC2) CancelImportTaskRequest(input *CancelImportTaskInput) (req *request.Request, output *CancelImportTaskOutput) {
 1599     op := &request.Operation{
 1600         Name:       opCancelImportTask,
 1601         HTTPMethod: "POST",
 1602         HTTPPath:   "/",
 1603     }
 1604 
 1605     if input == nil {
 1606         input = &CancelImportTaskInput{}
 1607     }
 1608 
 1609     output = &CancelImportTaskOutput{}
 1610     req = c.newRequest(op, input, output)
 1611     return
 1612 }
 1613 
 1614 // CancelImportTask API operation for Amazon Elastic Compute Cloud.
 1615 //
 1616 // Cancels an in-process import virtual machine or import snapshot task.
 1617 //
 1618 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 1619 // with awserr.Error's Code and Message methods to get detailed information about
 1620 // the error.
 1621 //
 1622 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 1623 // API operation CancelImportTask for usage and error information.
 1624 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelImportTask
 1625 func (c *EC2) CancelImportTask(input *CancelImportTaskInput) (*CancelImportTaskOutput, error) {
 1626     req, out := c.CancelImportTaskRequest(input)
 1627     err := req.Send()
 1628     return out, err
 1629 }
 1630 
 1631 const opCancelReservedInstancesListing = "CancelReservedInstancesListing"
 1632 
 1633 // CancelReservedInstancesListingRequest generates a "aws/request.Request" representing the
 1634 // client's request for the CancelReservedInstancesListing operation. The "output" return
 1635 // value can be used to capture response data after the request's "Send" method
 1636 // is called.
 1637 //
 1638 // See CancelReservedInstancesListing for usage and error information.
 1639 //
 1640 // Creating a request object using this method should be used when you want to inject
 1641 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1642 // access properties on the request object before or after sending the request. If
 1643 // you just want the service response, call the CancelReservedInstancesListing method directly
 1644 // instead.
 1645 //
 1646 // Note: You must call the "Send" method on the returned request object in order
 1647 // to execute the request.
 1648 //
 1649 //    // Example sending a request using the CancelReservedInstancesListingRequest method.
 1650 //    req, resp := client.CancelReservedInstancesListingRequest(params)
 1651 //
 1652 //    err := req.Send()
 1653 //    if err == nil { // resp is now filled
 1654 //        fmt.Println(resp)
 1655 //    }
 1656 //
 1657 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelReservedInstancesListing
 1658 func (c *EC2) CancelReservedInstancesListingRequest(input *CancelReservedInstancesListingInput) (req *request.Request, output *CancelReservedInstancesListingOutput) {
 1659     op := &request.Operation{
 1660         Name:       opCancelReservedInstancesListing,
 1661         HTTPMethod: "POST",
 1662         HTTPPath:   "/",
 1663     }
 1664 
 1665     if input == nil {
 1666         input = &CancelReservedInstancesListingInput{}
 1667     }
 1668 
 1669     output = &CancelReservedInstancesListingOutput{}
 1670     req = c.newRequest(op, input, output)
 1671     return
 1672 }
 1673 
 1674 // CancelReservedInstancesListing API operation for Amazon Elastic Compute Cloud.
 1675 //
 1676 // Cancels the specified Reserved Instance listing in the Reserved Instance
 1677 // Marketplace.
 1678 //
 1679 // For more information, see Reserved Instance Marketplace (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html)
 1680 // in the Amazon Elastic Compute Cloud User Guide.
 1681 //
 1682 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 1683 // with awserr.Error's Code and Message methods to get detailed information about
 1684 // the error.
 1685 //
 1686 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 1687 // API operation CancelReservedInstancesListing for usage and error information.
 1688 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelReservedInstancesListing
 1689 func (c *EC2) CancelReservedInstancesListing(input *CancelReservedInstancesListingInput) (*CancelReservedInstancesListingOutput, error) {
 1690     req, out := c.CancelReservedInstancesListingRequest(input)
 1691     err := req.Send()
 1692     return out, err
 1693 }
 1694 
 1695 const opCancelSpotFleetRequests = "CancelSpotFleetRequests"
 1696 
 1697 // CancelSpotFleetRequestsRequest generates a "aws/request.Request" representing the
 1698 // client's request for the CancelSpotFleetRequests operation. The "output" return
 1699 // value can be used to capture response data after the request's "Send" method
 1700 // is called.
 1701 //
 1702 // See CancelSpotFleetRequests for usage and error information.
 1703 //
 1704 // Creating a request object using this method should be used when you want to inject
 1705 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1706 // access properties on the request object before or after sending the request. If
 1707 // you just want the service response, call the CancelSpotFleetRequests method directly
 1708 // instead.
 1709 //
 1710 // Note: You must call the "Send" method on the returned request object in order
 1711 // to execute the request.
 1712 //
 1713 //    // Example sending a request using the CancelSpotFleetRequestsRequest method.
 1714 //    req, resp := client.CancelSpotFleetRequestsRequest(params)
 1715 //
 1716 //    err := req.Send()
 1717 //    if err == nil { // resp is now filled
 1718 //        fmt.Println(resp)
 1719 //    }
 1720 //
 1721 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelSpotFleetRequests
 1722 func (c *EC2) CancelSpotFleetRequestsRequest(input *CancelSpotFleetRequestsInput) (req *request.Request, output *CancelSpotFleetRequestsOutput) {
 1723     op := &request.Operation{
 1724         Name:       opCancelSpotFleetRequests,
 1725         HTTPMethod: "POST",
 1726         HTTPPath:   "/",
 1727     }
 1728 
 1729     if input == nil {
 1730         input = &CancelSpotFleetRequestsInput{}
 1731     }
 1732 
 1733     output = &CancelSpotFleetRequestsOutput{}
 1734     req = c.newRequest(op, input, output)
 1735     return
 1736 }
 1737 
 1738 // CancelSpotFleetRequests API operation for Amazon Elastic Compute Cloud.
 1739 //
 1740 // Cancels the specified Spot fleet requests.
 1741 //
 1742 // After you cancel a Spot fleet request, the Spot fleet launches no new Spot
 1743 // instances. You must specify whether the Spot fleet should also terminate
 1744 // its Spot instances. If you terminate the instances, the Spot fleet request
 1745 // enters the cancelled_terminating state. Otherwise, the Spot fleet request
 1746 // enters the cancelled_running state and the instances continue to run until
 1747 // they are interrupted or you terminate them manually.
 1748 //
 1749 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 1750 // with awserr.Error's Code and Message methods to get detailed information about
 1751 // the error.
 1752 //
 1753 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 1754 // API operation CancelSpotFleetRequests for usage and error information.
 1755 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelSpotFleetRequests
 1756 func (c *EC2) CancelSpotFleetRequests(input *CancelSpotFleetRequestsInput) (*CancelSpotFleetRequestsOutput, error) {
 1757     req, out := c.CancelSpotFleetRequestsRequest(input)
 1758     err := req.Send()
 1759     return out, err
 1760 }
 1761 
 1762 const opCancelSpotInstanceRequests = "CancelSpotInstanceRequests"
 1763 
 1764 // CancelSpotInstanceRequestsRequest generates a "aws/request.Request" representing the
 1765 // client's request for the CancelSpotInstanceRequests operation. The "output" return
 1766 // value can be used to capture response data after the request's "Send" method
 1767 // is called.
 1768 //
 1769 // See CancelSpotInstanceRequests for usage and error information.
 1770 //
 1771 // Creating a request object using this method should be used when you want to inject
 1772 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1773 // access properties on the request object before or after sending the request. If
 1774 // you just want the service response, call the CancelSpotInstanceRequests method directly
 1775 // instead.
 1776 //
 1777 // Note: You must call the "Send" method on the returned request object in order
 1778 // to execute the request.
 1779 //
 1780 //    // Example sending a request using the CancelSpotInstanceRequestsRequest method.
 1781 //    req, resp := client.CancelSpotInstanceRequestsRequest(params)
 1782 //
 1783 //    err := req.Send()
 1784 //    if err == nil { // resp is now filled
 1785 //        fmt.Println(resp)
 1786 //    }
 1787 //
 1788 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelSpotInstanceRequests
 1789 func (c *EC2) CancelSpotInstanceRequestsRequest(input *CancelSpotInstanceRequestsInput) (req *request.Request, output *CancelSpotInstanceRequestsOutput) {
 1790     op := &request.Operation{
 1791         Name:       opCancelSpotInstanceRequests,
 1792         HTTPMethod: "POST",
 1793         HTTPPath:   "/",
 1794     }
 1795 
 1796     if input == nil {
 1797         input = &CancelSpotInstanceRequestsInput{}
 1798     }
 1799 
 1800     output = &CancelSpotInstanceRequestsOutput{}
 1801     req = c.newRequest(op, input, output)
 1802     return
 1803 }
 1804 
 1805 // CancelSpotInstanceRequests API operation for Amazon Elastic Compute Cloud.
 1806 //
 1807 // Cancels one or more Spot instance requests. Spot instances are instances
 1808 // that Amazon EC2 starts on your behalf when the bid price that you specify
 1809 // exceeds the current Spot price. Amazon EC2 periodically sets the Spot price
 1810 // based on available Spot instance capacity and current Spot instance requests.
 1811 // For more information, see Spot Instance Requests (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html)
 1812 // in the Amazon Elastic Compute Cloud User Guide.
 1813 //
 1814 // Canceling a Spot instance request does not terminate running Spot instances
 1815 // associated with the request.
 1816 //
 1817 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 1818 // with awserr.Error's Code and Message methods to get detailed information about
 1819 // the error.
 1820 //
 1821 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 1822 // API operation CancelSpotInstanceRequests for usage and error information.
 1823 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelSpotInstanceRequests
 1824 func (c *EC2) CancelSpotInstanceRequests(input *CancelSpotInstanceRequestsInput) (*CancelSpotInstanceRequestsOutput, error) {
 1825     req, out := c.CancelSpotInstanceRequestsRequest(input)
 1826     err := req.Send()
 1827     return out, err
 1828 }
 1829 
 1830 const opConfirmProductInstance = "ConfirmProductInstance"
 1831 
 1832 // ConfirmProductInstanceRequest generates a "aws/request.Request" representing the
 1833 // client's request for the ConfirmProductInstance operation. The "output" return
 1834 // value can be used to capture response data after the request's "Send" method
 1835 // is called.
 1836 //
 1837 // See ConfirmProductInstance for usage and error information.
 1838 //
 1839 // Creating a request object using this method should be used when you want to inject
 1840 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1841 // access properties on the request object before or after sending the request. If
 1842 // you just want the service response, call the ConfirmProductInstance method directly
 1843 // instead.
 1844 //
 1845 // Note: You must call the "Send" method on the returned request object in order
 1846 // to execute the request.
 1847 //
 1848 //    // Example sending a request using the ConfirmProductInstanceRequest method.
 1849 //    req, resp := client.ConfirmProductInstanceRequest(params)
 1850 //
 1851 //    err := req.Send()
 1852 //    if err == nil { // resp is now filled
 1853 //        fmt.Println(resp)
 1854 //    }
 1855 //
 1856 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ConfirmProductInstance
 1857 func (c *EC2) ConfirmProductInstanceRequest(input *ConfirmProductInstanceInput) (req *request.Request, output *ConfirmProductInstanceOutput) {
 1858     op := &request.Operation{
 1859         Name:       opConfirmProductInstance,
 1860         HTTPMethod: "POST",
 1861         HTTPPath:   "/",
 1862     }
 1863 
 1864     if input == nil {
 1865         input = &ConfirmProductInstanceInput{}
 1866     }
 1867 
 1868     output = &ConfirmProductInstanceOutput{}
 1869     req = c.newRequest(op, input, output)
 1870     return
 1871 }
 1872 
 1873 // ConfirmProductInstance API operation for Amazon Elastic Compute Cloud.
 1874 //
 1875 // Determines whether a product code is associated with an instance. This action
 1876 // can only be used by the owner of the product code. It is useful when a product
 1877 // code owner needs to verify whether another user's instance is eligible for
 1878 // support.
 1879 //
 1880 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 1881 // with awserr.Error's Code and Message methods to get detailed information about
 1882 // the error.
 1883 //
 1884 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 1885 // API operation ConfirmProductInstance for usage and error information.
 1886 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ConfirmProductInstance
 1887 func (c *EC2) ConfirmProductInstance(input *ConfirmProductInstanceInput) (*ConfirmProductInstanceOutput, error) {
 1888     req, out := c.ConfirmProductInstanceRequest(input)
 1889     err := req.Send()
 1890     return out, err
 1891 }
 1892 
 1893 const opCopyImage = "CopyImage"
 1894 
 1895 // CopyImageRequest generates a "aws/request.Request" representing the
 1896 // client's request for the CopyImage operation. The "output" return
 1897 // value can be used to capture response data after the request's "Send" method
 1898 // is called.
 1899 //
 1900 // See CopyImage for usage and error information.
 1901 //
 1902 // Creating a request object using this method should be used when you want to inject
 1903 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1904 // access properties on the request object before or after sending the request. If
 1905 // you just want the service response, call the CopyImage method directly
 1906 // instead.
 1907 //
 1908 // Note: You must call the "Send" method on the returned request object in order
 1909 // to execute the request.
 1910 //
 1911 //    // Example sending a request using the CopyImageRequest method.
 1912 //    req, resp := client.CopyImageRequest(params)
 1913 //
 1914 //    err := req.Send()
 1915 //    if err == nil { // resp is now filled
 1916 //        fmt.Println(resp)
 1917 //    }
 1918 //
 1919 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopyImage
 1920 func (c *EC2) CopyImageRequest(input *CopyImageInput) (req *request.Request, output *CopyImageOutput) {
 1921     op := &request.Operation{
 1922         Name:       opCopyImage,
 1923         HTTPMethod: "POST",
 1924         HTTPPath:   "/",
 1925     }
 1926 
 1927     if input == nil {
 1928         input = &CopyImageInput{}
 1929     }
 1930 
 1931     output = &CopyImageOutput{}
 1932     req = c.newRequest(op, input, output)
 1933     return
 1934 }
 1935 
 1936 // CopyImage API operation for Amazon Elastic Compute Cloud.
 1937 //
 1938 // Initiates the copy of an AMI from the specified source region to the current
 1939 // region. You specify the destination region by using its endpoint when making
 1940 // the request.
 1941 //
 1942 // For more information, see Copying AMIs (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html)
 1943 // in the Amazon Elastic Compute Cloud User Guide.
 1944 //
 1945 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 1946 // with awserr.Error's Code and Message methods to get detailed information about
 1947 // the error.
 1948 //
 1949 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 1950 // API operation CopyImage for usage and error information.
 1951 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopyImage
 1952 func (c *EC2) CopyImage(input *CopyImageInput) (*CopyImageOutput, error) {
 1953     req, out := c.CopyImageRequest(input)
 1954     err := req.Send()
 1955     return out, err
 1956 }
 1957 
 1958 const opCopySnapshot = "CopySnapshot"
 1959 
 1960 // CopySnapshotRequest generates a "aws/request.Request" representing the
 1961 // client's request for the CopySnapshot operation. The "output" return
 1962 // value can be used to capture response data after the request's "Send" method
 1963 // is called.
 1964 //
 1965 // See CopySnapshot for usage and error information.
 1966 //
 1967 // Creating a request object using this method should be used when you want to inject
 1968 // custom logic into the request's lifecycle using a custom handler, or if you want to
 1969 // access properties on the request object before or after sending the request. If
 1970 // you just want the service response, call the CopySnapshot method directly
 1971 // instead.
 1972 //
 1973 // Note: You must call the "Send" method on the returned request object in order
 1974 // to execute the request.
 1975 //
 1976 //    // Example sending a request using the CopySnapshotRequest method.
 1977 //    req, resp := client.CopySnapshotRequest(params)
 1978 //
 1979 //    err := req.Send()
 1980 //    if err == nil { // resp is now filled
 1981 //        fmt.Println(resp)
 1982 //    }
 1983 //
 1984 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopySnapshot
 1985 func (c *EC2) CopySnapshotRequest(input *CopySnapshotInput) (req *request.Request, output *CopySnapshotOutput) {
 1986     op := &request.Operation{
 1987         Name:       opCopySnapshot,
 1988         HTTPMethod: "POST",
 1989         HTTPPath:   "/",
 1990     }
 1991 
 1992     if input == nil {
 1993         input = &CopySnapshotInput{}
 1994     }
 1995 
 1996     output = &CopySnapshotOutput{}
 1997     req = c.newRequest(op, input, output)
 1998     return
 1999 }
 2000 
 2001 // CopySnapshot API operation for Amazon Elastic Compute Cloud.
 2002 //
 2003 // Copies a point-in-time snapshot of an EBS volume and stores it in Amazon
 2004 // S3. You can copy the snapshot within the same region or from one region to
 2005 // another. You can use the snapshot to create EBS volumes or Amazon Machine
 2006 // Images (AMIs). The snapshot is copied to the regional endpoint that you send
 2007 // the HTTP request to.
 2008 //
 2009 // Copies of encrypted EBS snapshots remain encrypted. Copies of unencrypted
 2010 // snapshots remain unencrypted, unless the Encrypted flag is specified during
 2011 // the snapshot copy operation. By default, encrypted snapshot copies use the
 2012 // default AWS Key Management Service (AWS KMS) customer master key (CMK); however,
 2013 // you can specify a non-default CMK with the KmsKeyId parameter.
 2014 //
 2015 // To copy an encrypted snapshot that has been shared from another account,
 2016 // you must have permissions for the CMK used to encrypt the snapshot.
 2017 //
 2018 // Snapshots created by the CopySnapshot action have an arbitrary volume ID
 2019 // that should not be used for any purpose.
 2020 //
 2021 // For more information, see Copying an Amazon EBS Snapshot (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-copy-snapshot.html)
 2022 // in the Amazon Elastic Compute Cloud User Guide.
 2023 //
 2024 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 2025 // with awserr.Error's Code and Message methods to get detailed information about
 2026 // the error.
 2027 //
 2028 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 2029 // API operation CopySnapshot for usage and error information.
 2030 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopySnapshot
 2031 func (c *EC2) CopySnapshot(input *CopySnapshotInput) (*CopySnapshotOutput, error) {
 2032     req, out := c.CopySnapshotRequest(input)
 2033     err := req.Send()
 2034     return out, err
 2035 }
 2036 
 2037 const opCreateCustomerGateway = "CreateCustomerGateway"
 2038 
 2039 // CreateCustomerGatewayRequest generates a "aws/request.Request" representing the
 2040 // client's request for the CreateCustomerGateway operation. The "output" return
 2041 // value can be used to capture response data after the request's "Send" method
 2042 // is called.
 2043 //
 2044 // See CreateCustomerGateway for usage and error information.
 2045 //
 2046 // Creating a request object using this method should be used when you want to inject
 2047 // custom logic into the request's lifecycle using a custom handler, or if you want to
 2048 // access properties on the request object before or after sending the request. If
 2049 // you just want the service response, call the CreateCustomerGateway method directly
 2050 // instead.
 2051 //
 2052 // Note: You must call the "Send" method on the returned request object in order
 2053 // to execute the request.
 2054 //
 2055 //    // Example sending a request using the CreateCustomerGatewayRequest method.
 2056 //    req, resp := client.CreateCustomerGatewayRequest(params)
 2057 //
 2058 //    err := req.Send()
 2059 //    if err == nil { // resp is now filled
 2060 //        fmt.Println(resp)
 2061 //    }
 2062 //
 2063 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCustomerGateway
 2064 func (c *EC2) CreateCustomerGatewayRequest(input *CreateCustomerGatewayInput) (req *request.Request, output *CreateCustomerGatewayOutput) {
 2065     op := &request.Operation{
 2066         Name:       opCreateCustomerGateway,
 2067         HTTPMethod: "POST",
 2068         HTTPPath:   "/",
 2069     }
 2070 
 2071     if input == nil {
 2072         input = &CreateCustomerGatewayInput{}
 2073     }
 2074 
 2075     output = &CreateCustomerGatewayOutput{}
 2076     req = c.newRequest(op, input, output)
 2077     return
 2078 }
 2079 
 2080 // CreateCustomerGateway API operation for Amazon Elastic Compute Cloud.
 2081 //
 2082 // Provides information to AWS about your VPN customer gateway device. The customer
 2083 // gateway is the appliance at your end of the VPN connection. (The device on
 2084 // the AWS side of the VPN connection is the virtual private gateway.) You must
 2085 // provide the Internet-routable IP address of the customer gateway's external
 2086 // interface. The IP address must be static and may be behind a device performing
 2087 // network address translation (NAT).
 2088 //
 2089 // For devices that use Border Gateway Protocol (BGP), you can also provide
 2090 // the device's BGP Autonomous System Number (ASN). You can use an existing
 2091 // ASN assigned to your network. If you don't have an ASN already, you can use
 2092 // a private ASN (in the 64512 - 65534 range).
 2093 //
 2094 // Amazon EC2 supports all 2-byte ASN numbers in the range of 1 - 65534, with
 2095 // the exception of 7224, which is reserved in the us-east-1 region, and 9059,
 2096 // which is reserved in the eu-west-1 region.
 2097 //
 2098 // For more information about VPN customer gateways, see Adding a Hardware Virtual
 2099 // Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
 2100 // in the Amazon Virtual Private Cloud User Guide.
 2101 //
 2102 // You cannot create more than one customer gateway with the same VPN type,
 2103 // IP address, and BGP ASN parameter values. If you run an identical request
 2104 // more than one time, the first request creates the customer gateway, and subsequent
 2105 // requests return information about the existing customer gateway. The subsequent
 2106 // requests do not create new customer gateway resources.
 2107 //
 2108 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 2109 // with awserr.Error's Code and Message methods to get detailed information about
 2110 // the error.
 2111 //
 2112 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 2113 // API operation CreateCustomerGateway for usage and error information.
 2114 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCustomerGateway
 2115 func (c *EC2) CreateCustomerGateway(input *CreateCustomerGatewayInput) (*CreateCustomerGatewayOutput, error) {
 2116     req, out := c.CreateCustomerGatewayRequest(input)
 2117     err := req.Send()
 2118     return out, err
 2119 }
 2120 
 2121 const opCreateDhcpOptions = "CreateDhcpOptions"
 2122 
 2123 // CreateDhcpOptionsRequest generates a "aws/request.Request" representing the
 2124 // client's request for the CreateDhcpOptions operation. The "output" return
 2125 // value can be used to capture response data after the request's "Send" method
 2126 // is called.
 2127 //
 2128 // See CreateDhcpOptions for usage and error information.
 2129 //
 2130 // Creating a request object using this method should be used when you want to inject
 2131 // custom logic into the request's lifecycle using a custom handler, or if you want to
 2132 // access properties on the request object before or after sending the request. If
 2133 // you just want the service response, call the CreateDhcpOptions method directly
 2134 // instead.
 2135 //
 2136 // Note: You must call the "Send" method on the returned request object in order
 2137 // to execute the request.
 2138 //
 2139 //    // Example sending a request using the CreateDhcpOptionsRequest method.
 2140 //    req, resp := client.CreateDhcpOptionsRequest(params)
 2141 //
 2142 //    err := req.Send()
 2143 //    if err == nil { // resp is now filled
 2144 //        fmt.Println(resp)
 2145 //    }
 2146 //
 2147 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDhcpOptions
 2148 func (c *EC2) CreateDhcpOptionsRequest(input *CreateDhcpOptionsInput) (req *request.Request, output *CreateDhcpOptionsOutput) {
 2149     op := &request.Operation{
 2150         Name:       opCreateDhcpOptions,
 2151         HTTPMethod: "POST",
 2152         HTTPPath:   "/",
 2153     }
 2154 
 2155     if input == nil {
 2156         input = &CreateDhcpOptionsInput{}
 2157     }
 2158 
 2159     output = &CreateDhcpOptionsOutput{}
 2160     req = c.newRequest(op, input, output)
 2161     return
 2162 }
 2163 
 2164 // CreateDhcpOptions API operation for Amazon Elastic Compute Cloud.
 2165 //
 2166 // Creates a set of DHCP options for your VPC. After creating the set, you must
 2167 // associate it with the VPC, causing all existing and new instances that you
 2168 // launch in the VPC to use this set of DHCP options. The following are the
 2169 // individual DHCP options you can specify. For more information about the options,
 2170 // see RFC 2132 (http://www.ietf.org/rfc/rfc2132.txt).
 2171 //
 2172 //    * domain-name-servers - The IP addresses of up to four domain name servers,
 2173 //    or AmazonProvidedDNS. The default DHCP option set specifies AmazonProvidedDNS.
 2174 //    If specifying more than one domain name server, specify the IP addresses
 2175 //    in a single parameter, separated by commas. If you want your instance
 2176 //    to receive a custom DNS hostname as specified in domain-name, you must
 2177 //    set domain-name-servers to a custom DNS server.
 2178 //
 2179 //    * domain-name - If you're using AmazonProvidedDNS in "us-east-1", specify
 2180 //    "ec2.internal". If you're using AmazonProvidedDNS in another region, specify
 2181 //    "region.compute.internal" (for example, "ap-northeast-1.compute.internal").
 2182 //    Otherwise, specify a domain name (for example, "MyCompany.com"). This
 2183 //    value is used to complete unqualified DNS hostnames. Important: Some Linux
 2184 //    operating systems accept multiple domain names separated by spaces. However,
 2185 //    Windows and other Linux operating systems treat the value as a single
 2186 //    domain, which results in unexpected behavior. If your DHCP options set
 2187 //    is associated with a VPC that has instances with multiple operating systems,
 2188 //    specify only one domain name.
 2189 //
 2190 //    * ntp-servers - The IP addresses of up to four Network Time Protocol (NTP)
 2191 //    servers.
 2192 //
 2193 //    * netbios-name-servers - The IP addresses of up to four NetBIOS name servers.
 2194 //
 2195 //    * netbios-node-type - The NetBIOS node type (1, 2, 4, or 8). We recommend
 2196 //    that you specify 2 (broadcast and multicast are not currently supported).
 2197 //    For more information about these node types, see RFC 2132 (http://www.ietf.org/rfc/rfc2132.txt).
 2198 //
 2199 // Your VPC automatically starts out with a set of DHCP options that includes
 2200 // only a DNS server that we provide (AmazonProvidedDNS). If you create a set
 2201 // of options, and if your VPC has an Internet gateway, make sure to set the
 2202 // domain-name-servers option either to AmazonProvidedDNS or to a domain name
 2203 // server of your choice. For more information about DHCP options, see DHCP
 2204 // Options Sets (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_DHCP_Options.html)
 2205 // in the Amazon Virtual Private Cloud User Guide.
 2206 //
 2207 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 2208 // with awserr.Error's Code and Message methods to get detailed information about
 2209 // the error.
 2210 //
 2211 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 2212 // API operation CreateDhcpOptions for usage and error information.
 2213 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDhcpOptions
 2214 func (c *EC2) CreateDhcpOptions(input *CreateDhcpOptionsInput) (*CreateDhcpOptionsOutput, error) {
 2215     req, out := c.CreateDhcpOptionsRequest(input)
 2216     err := req.Send()
 2217     return out, err
 2218 }
 2219 
 2220 const opCreateEgressOnlyInternetGateway = "CreateEgressOnlyInternetGateway"
 2221 
 2222 // CreateEgressOnlyInternetGatewayRequest generates a "aws/request.Request" representing the
 2223 // client's request for the CreateEgressOnlyInternetGateway operation. The "output" return
 2224 // value can be used to capture response data after the request's "Send" method
 2225 // is called.
 2226 //
 2227 // See CreateEgressOnlyInternetGateway for usage and error information.
 2228 //
 2229 // Creating a request object using this method should be used when you want to inject
 2230 // custom logic into the request's lifecycle using a custom handler, or if you want to
 2231 // access properties on the request object before or after sending the request. If
 2232 // you just want the service response, call the CreateEgressOnlyInternetGateway method directly
 2233 // instead.
 2234 //
 2235 // Note: You must call the "Send" method on the returned request object in order
 2236 // to execute the request.
 2237 //
 2238 //    // Example sending a request using the CreateEgressOnlyInternetGatewayRequest method.
 2239 //    req, resp := client.CreateEgressOnlyInternetGatewayRequest(params)
 2240 //
 2241 //    err := req.Send()
 2242 //    if err == nil { // resp is now filled
 2243 //        fmt.Println(resp)
 2244 //    }
 2245 //
 2246 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateEgressOnlyInternetGateway
 2247 func (c *EC2) CreateEgressOnlyInternetGatewayRequest(input *CreateEgressOnlyInternetGatewayInput) (req *request.Request, output *CreateEgressOnlyInternetGatewayOutput) {
 2248     op := &request.Operation{
 2249         Name:       opCreateEgressOnlyInternetGateway,
 2250         HTTPMethod: "POST",
 2251         HTTPPath:   "/",
 2252     }
 2253 
 2254     if input == nil {
 2255         input = &CreateEgressOnlyInternetGatewayInput{}
 2256     }
 2257 
 2258     output = &CreateEgressOnlyInternetGatewayOutput{}
 2259     req = c.newRequest(op, input, output)
 2260     return
 2261 }
 2262 
 2263 // CreateEgressOnlyInternetGateway API operation for Amazon Elastic Compute Cloud.
 2264 //
 2265 // [IPv6 only] Creates an egress-only Internet gateway for your VPC. An egress-only
 2266 // Internet gateway is used to enable outbound communication over IPv6 from
 2267 // instances in your VPC to the Internet, and prevents hosts outside of your
 2268 // VPC from initiating an IPv6 connection with your instance.
 2269 //
 2270 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 2271 // with awserr.Error's Code and Message methods to get detailed information about
 2272 // the error.
 2273 //
 2274 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 2275 // API operation CreateEgressOnlyInternetGateway for usage and error information.
 2276 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateEgressOnlyInternetGateway
 2277 func (c *EC2) CreateEgressOnlyInternetGateway(input *CreateEgressOnlyInternetGatewayInput) (*CreateEgressOnlyInternetGatewayOutput, error) {
 2278     req, out := c.CreateEgressOnlyInternetGatewayRequest(input)
 2279     err := req.Send()
 2280     return out, err
 2281 }
 2282 
 2283 const opCreateFlowLogs = "CreateFlowLogs"
 2284 
 2285 // CreateFlowLogsRequest generates a "aws/request.Request" representing the
 2286 // client's request for the CreateFlowLogs operation. The "output" return
 2287 // value can be used to capture response data after the request's "Send" method
 2288 // is called.
 2289 //
 2290 // See CreateFlowLogs for usage and error information.
 2291 //
 2292 // Creating a request object using this method should be used when you want to inject
 2293 // custom logic into the request's lifecycle using a custom handler, or if you want to
 2294 // access properties on the request object before or after sending the request. If
 2295 // you just want the service response, call the CreateFlowLogs method directly
 2296 // instead.
 2297 //
 2298 // Note: You must call the "Send" method on the returned request object in order
 2299 // to execute the request.
 2300 //
 2301 //    // Example sending a request using the CreateFlowLogsRequest method.
 2302 //    req, resp := client.CreateFlowLogsRequest(params)
 2303 //
 2304 //    err := req.Send()
 2305 //    if err == nil { // resp is now filled
 2306 //        fmt.Println(resp)
 2307 //    }
 2308 //
 2309 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateFlowLogs
 2310 func (c *EC2) CreateFlowLogsRequest(input *CreateFlowLogsInput) (req *request.Request, output *CreateFlowLogsOutput) {
 2311     op := &request.Operation{
 2312         Name:       opCreateFlowLogs,
 2313         HTTPMethod: "POST",
 2314         HTTPPath:   "/",
 2315     }
 2316 
 2317     if input == nil {
 2318         input = &CreateFlowLogsInput{}
 2319     }
 2320 
 2321     output = &CreateFlowLogsOutput{}
 2322     req = c.newRequest(op, input, output)
 2323     return
 2324 }
 2325 
 2326 // CreateFlowLogs API operation for Amazon Elastic Compute Cloud.
 2327 //
 2328 // Creates one or more flow logs to capture IP traffic for a specific network
 2329 // interface, subnet, or VPC. Flow logs are delivered to a specified log group
 2330 // in Amazon CloudWatch Logs. If you specify a VPC or subnet in the request,
 2331 // a log stream is created in CloudWatch Logs for each network interface in
 2332 // the subnet or VPC. Log streams can include information about accepted and
 2333 // rejected traffic to a network interface. You can view the data in your log
 2334 // streams using Amazon CloudWatch Logs.
 2335 //
 2336 // In your request, you must also specify an IAM role that has permission to
 2337 // publish logs to CloudWatch Logs.
 2338 //
 2339 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 2340 // with awserr.Error's Code and Message methods to get detailed information about
 2341 // the error.
 2342 //
 2343 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 2344 // API operation CreateFlowLogs for usage and error information.
 2345 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateFlowLogs
 2346 func (c *EC2) CreateFlowLogs(input *CreateFlowLogsInput) (*CreateFlowLogsOutput, error) {
 2347     req, out := c.CreateFlowLogsRequest(input)
 2348     err := req.Send()
 2349     return out, err
 2350 }
 2351 
 2352 const opCreateImage = "CreateImage"
 2353 
 2354 // CreateImageRequest generates a "aws/request.Request" representing the
 2355 // client's request for the CreateImage operation. The "output" return
 2356 // value can be used to capture response data after the request's "Send" method
 2357 // is called.
 2358 //
 2359 // See CreateImage for usage and error information.
 2360 //
 2361 // Creating a request object using this method should be used when you want to inject
 2362 // custom logic into the request's lifecycle using a custom handler, or if you want to
 2363 // access properties on the request object before or after sending the request. If
 2364 // you just want the service response, call the CreateImage method directly
 2365 // instead.
 2366 //
 2367 // Note: You must call the "Send" method on the returned request object in order
 2368 // to execute the request.
 2369 //
 2370 //    // Example sending a request using the CreateImageRequest method.
 2371 //    req, resp := client.CreateImageRequest(params)
 2372 //
 2373 //    err := req.Send()
 2374 //    if err == nil { // resp is now filled
 2375 //        fmt.Println(resp)
 2376 //    }
 2377 //
 2378 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateImage
 2379 func (c *EC2) CreateImageRequest(input *CreateImageInput) (req *request.Request, output *CreateImageOutput) {
 2380     op := &request.Operation{
 2381         Name:       opCreateImage,
 2382         HTTPMethod: "POST",
 2383         HTTPPath:   "/",
 2384     }
 2385 
 2386     if input == nil {
 2387         input = &CreateImageInput{}
 2388     }
 2389 
 2390     output = &CreateImageOutput{}
 2391     req = c.newRequest(op, input, output)
 2392     return
 2393 }
 2394 
 2395 // CreateImage API operation for Amazon Elastic Compute Cloud.
 2396 //
 2397 // Creates an Amazon EBS-backed AMI from an Amazon EBS-backed instance that
 2398 // is either running or stopped.
 2399 //
 2400 // If you customized your instance with instance store volumes or EBS volumes
 2401 // in addition to the root device volume, the new AMI contains block device
 2402 // mapping information for those volumes. When you launch an instance from this
 2403 // new AMI, the instance automatically launches with those additional volumes.
 2404 //
 2405 // For more information, see Creating Amazon EBS-Backed Linux AMIs (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html)
 2406 // in the Amazon Elastic Compute Cloud User Guide.
 2407 //
 2408 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 2409 // with awserr.Error's Code and Message methods to get detailed information about
 2410 // the error.
 2411 //
 2412 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 2413 // API operation CreateImage for usage and error information.
 2414 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateImage
 2415 func (c *EC2) CreateImage(input *CreateImageInput) (*CreateImageOutput, error) {
 2416     req, out := c.CreateImageRequest(input)
 2417     err := req.Send()
 2418     return out, err
 2419 }
 2420 
 2421 const opCreateInstanceExportTask = "CreateInstanceExportTask"
 2422 
 2423 // CreateInstanceExportTaskRequest generates a "aws/request.Request" representing the
 2424 // client's request for the CreateInstanceExportTask operation. The "output" return
 2425 // value can be used to capture response data after the request's "Send" method
 2426 // is called.
 2427 //
 2428 // See CreateInstanceExportTask for usage and error information.
 2429 //
 2430 // Creating a request object using this method should be used when you want to inject
 2431 // custom logic into the request's lifecycle using a custom handler, or if you want to
 2432 // access properties on the request object before or after sending the request. If
 2433 // you just want the service response, call the CreateInstanceExportTask method directly
 2434 // instead.
 2435 //
 2436 // Note: You must call the "Send" method on the returned request object in order
 2437 // to execute the request.
 2438 //
 2439 //    // Example sending a request using the CreateInstanceExportTaskRequest method.
 2440 //    req, resp := client.CreateInstanceExportTaskRequest(params)
 2441 //
 2442 //    err := req.Send()
 2443 //    if err == nil { // resp is now filled
 2444 //        fmt.Println(resp)
 2445 //    }
 2446 //
 2447 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInstanceExportTask
 2448 func (c *EC2) CreateInstanceExportTaskRequest(input *CreateInstanceExportTaskInput) (req *request.Request, output *CreateInstanceExportTaskOutput) {
 2449     op := &request.Operation{
 2450         Name:       opCreateInstanceExportTask,
 2451         HTTPMethod: "POST",
 2452         HTTPPath:   "/",
 2453     }
 2454 
 2455     if input == nil {
 2456         input = &CreateInstanceExportTaskInput{}
 2457     }
 2458 
 2459     output = &CreateInstanceExportTaskOutput{}
 2460     req = c.newRequest(op, input, output)
 2461     return
 2462 }
 2463 
 2464 // CreateInstanceExportTask API operation for Amazon Elastic Compute Cloud.
 2465 //
 2466 // Exports a running or stopped instance to an S3 bucket.
 2467 //
 2468 // For information about the supported operating systems, image formats, and
 2469 // known limitations for the types of instances you can export, see Exporting
 2470 // an Instance as a VM Using VM Import/Export (http://docs.aws.amazon.com/vm-import/latest/userguide/vmexport.html)
 2471 // in the VM Import/Export User Guide.
 2472 //
 2473 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 2474 // with awserr.Error's Code and Message methods to get detailed information about
 2475 // the error.
 2476 //
 2477 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 2478 // API operation CreateInstanceExportTask for usage and error information.
 2479 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInstanceExportTask
 2480 func (c *EC2) CreateInstanceExportTask(input *CreateInstanceExportTaskInput) (*CreateInstanceExportTaskOutput, error) {
 2481     req, out := c.CreateInstanceExportTaskRequest(input)
 2482     err := req.Send()
 2483     return out, err
 2484 }
 2485 
 2486 const opCreateInternetGateway = "CreateInternetGateway"
 2487 
 2488 // CreateInternetGatewayRequest generates a "aws/request.Request" representing the
 2489 // client's request for the CreateInternetGateway operation. The "output" return
 2490 // value can be used to capture response data after the request's "Send" method
 2491 // is called.
 2492 //
 2493 // See CreateInternetGateway for usage and error information.
 2494 //
 2495 // Creating a request object using this method should be used when you want to inject
 2496 // custom logic into the request's lifecycle using a custom handler, or if you want to
 2497 // access properties on the request object before or after sending the request. If
 2498 // you just want the service response, call the CreateInternetGateway method directly
 2499 // instead.
 2500 //
 2501 // Note: You must call the "Send" method on the returned request object in order
 2502 // to execute the request.
 2503 //
 2504 //    // Example sending a request using the CreateInternetGatewayRequest method.
 2505 //    req, resp := client.CreateInternetGatewayRequest(params)
 2506 //
 2507 //    err := req.Send()
 2508 //    if err == nil { // resp is now filled
 2509 //        fmt.Println(resp)
 2510 //    }
 2511 //
 2512 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInternetGateway
 2513 func (c *EC2) CreateInternetGatewayRequest(input *CreateInternetGatewayInput) (req *request.Request, output *CreateInternetGatewayOutput) {
 2514     op := &request.Operation{
 2515         Name:       opCreateInternetGateway,
 2516         HTTPMethod: "POST",
 2517         HTTPPath:   "/",
 2518     }
 2519 
 2520     if input == nil {
 2521         input = &CreateInternetGatewayInput{}
 2522     }
 2523 
 2524     output = &CreateInternetGatewayOutput{}
 2525     req = c.newRequest(op, input, output)
 2526     return
 2527 }
 2528 
 2529 // CreateInternetGateway API operation for Amazon Elastic Compute Cloud.
 2530 //
 2531 // Creates an Internet gateway for use with a VPC. After creating the Internet
 2532 // gateway, you attach it to a VPC using AttachInternetGateway.
 2533 //
 2534 // For more information about your VPC and Internet gateway, see the Amazon
 2535 // Virtual Private Cloud User Guide (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/).
 2536 //
 2537 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 2538 // with awserr.Error's Code and Message methods to get detailed information about
 2539 // the error.
 2540 //
 2541 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 2542 // API operation CreateInternetGateway for usage and error information.
 2543 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInternetGateway
 2544 func (c *EC2) CreateInternetGateway(input *CreateInternetGatewayInput) (*CreateInternetGatewayOutput, error) {
 2545     req, out := c.CreateInternetGatewayRequest(input)
 2546     err := req.Send()
 2547     return out, err
 2548 }
 2549 
 2550 const opCreateKeyPair = "CreateKeyPair"
 2551 
 2552 // CreateKeyPairRequest generates a "aws/request.Request" representing the
 2553 // client's request for the CreateKeyPair operation. The "output" return
 2554 // value can be used to capture response data after the request's "Send" method
 2555 // is called.
 2556 //
 2557 // See CreateKeyPair for usage and error information.
 2558 //
 2559 // Creating a request object using this method should be used when you want to inject
 2560 // custom logic into the request's lifecycle using a custom handler, or if you want to
 2561 // access properties on the request object before or after sending the request. If
 2562 // you just want the service response, call the CreateKeyPair method directly
 2563 // instead.
 2564 //
 2565 // Note: You must call the "Send" method on the returned request object in order
 2566 // to execute the request.
 2567 //
 2568 //    // Example sending a request using the CreateKeyPairRequest method.
 2569 //    req, resp := client.CreateKeyPairRequest(params)
 2570 //
 2571 //    err := req.Send()
 2572 //    if err == nil { // resp is now filled
 2573 //        fmt.Println(resp)
 2574 //    }
 2575 //
 2576 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateKeyPair
 2577 func (c *EC2) CreateKeyPairRequest(input *CreateKeyPairInput) (req *request.Request, output *CreateKeyPairOutput) {
 2578     op := &request.Operation{
 2579         Name:       opCreateKeyPair,
 2580         HTTPMethod: "POST",
 2581         HTTPPath:   "/",
 2582     }
 2583 
 2584     if input == nil {
 2585         input = &CreateKeyPairInput{}
 2586     }
 2587 
 2588     output = &CreateKeyPairOutput{}
 2589     req = c.newRequest(op, input, output)
 2590     return
 2591 }
 2592 
 2593 // CreateKeyPair API operation for Amazon Elastic Compute Cloud.
 2594 //
 2595 // Creates a 2048-bit RSA key pair with the specified name. Amazon EC2 stores
 2596 // the public key and displays the private key for you to save to a file. The
 2597 // private key is returned as an unencrypted PEM encoded PKCS#8 private key.
 2598 // If a key with the specified name already exists, Amazon EC2 returns an error.
 2599 //
 2600 // You can have up to five thousand key pairs per region.
 2601 //
 2602 // The key pair returned to you is available only in the region in which you
 2603 // create it. To create a key pair that is available in all regions, use ImportKeyPair.
 2604 //
 2605 // For more information about key pairs, see Key Pairs (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)
 2606 // in the Amazon Elastic Compute Cloud User Guide.
 2607 //
 2608 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 2609 // with awserr.Error's Code and Message methods to get detailed information about
 2610 // the error.
 2611 //
 2612 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 2613 // API operation CreateKeyPair for usage and error information.
 2614 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateKeyPair
 2615 func (c *EC2) CreateKeyPair(input *CreateKeyPairInput) (*CreateKeyPairOutput, error) {
 2616     req, out := c.CreateKeyPairRequest(input)
 2617     err := req.Send()
 2618     return out, err
 2619 }
 2620 
 2621 const opCreateNatGateway = "CreateNatGateway"
 2622 
 2623 // CreateNatGatewayRequest generates a "aws/request.Request" representing the
 2624 // client's request for the CreateNatGateway operation. The "output" return
 2625 // value can be used to capture response data after the request's "Send" method
 2626 // is called.
 2627 //
 2628 // See CreateNatGateway for usage and error information.
 2629 //
 2630 // Creating a request object using this method should be used when you want to inject
 2631 // custom logic into the request's lifecycle using a custom handler, or if you want to
 2632 // access properties on the request object before or after sending the request. If
 2633 // you just want the service response, call the CreateNatGateway method directly
 2634 // instead.
 2635 //
 2636 // Note: You must call the "Send" method on the returned request object in order
 2637 // to execute the request.
 2638 //
 2639 //    // Example sending a request using the CreateNatGatewayRequest method.
 2640 //    req, resp := client.CreateNatGatewayRequest(params)
 2641 //
 2642 //    err := req.Send()
 2643 //    if err == nil { // resp is now filled
 2644 //        fmt.Println(resp)
 2645 //    }
 2646 //
 2647 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNatGateway
 2648 func (c *EC2) CreateNatGatewayRequest(input *CreateNatGatewayInput) (req *request.Request, output *CreateNatGatewayOutput) {
 2649     op := &request.Operation{
 2650         Name:       opCreateNatGateway,
 2651         HTTPMethod: "POST",
 2652         HTTPPath:   "/",
 2653     }
 2654 
 2655     if input == nil {
 2656         input = &CreateNatGatewayInput{}
 2657     }
 2658 
 2659     output = &CreateNatGatewayOutput{}
 2660     req = c.newRequest(op, input, output)
 2661     return
 2662 }
 2663 
 2664 // CreateNatGateway API operation for Amazon Elastic Compute Cloud.
 2665 //
 2666 // Creates a NAT gateway in the specified subnet. A NAT gateway can be used
 2667 // to enable instances in a private subnet to connect to the Internet. This
 2668 // action creates a network interface in the specified subnet with a private
 2669 // IP address from the IP address range of the subnet. For more information,
 2670 // see NAT Gateways (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/vpc-nat-gateway.html)
 2671 // in the Amazon Virtual Private Cloud User Guide.
 2672 //
 2673 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 2674 // with awserr.Error's Code and Message methods to get detailed information about
 2675 // the error.
 2676 //
 2677 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 2678 // API operation CreateNatGateway for usage and error information.
 2679 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNatGateway
 2680 func (c *EC2) CreateNatGateway(input *CreateNatGatewayInput) (*CreateNatGatewayOutput, error) {
 2681     req, out := c.CreateNatGatewayRequest(input)
 2682     err := req.Send()
 2683     return out, err
 2684 }
 2685 
 2686 const opCreateNetworkAcl = "CreateNetworkAcl"
 2687 
 2688 // CreateNetworkAclRequest generates a "aws/request.Request" representing the
 2689 // client's request for the CreateNetworkAcl operation. The "output" return
 2690 // value can be used to capture response data after the request's "Send" method
 2691 // is called.
 2692 //
 2693 // See CreateNetworkAcl for usage and error information.
 2694 //
 2695 // Creating a request object using this method should be used when you want to inject
 2696 // custom logic into the request's lifecycle using a custom handler, or if you want to
 2697 // access properties on the request object before or after sending the request. If
 2698 // you just want the service response, call the CreateNetworkAcl method directly
 2699 // instead.
 2700 //
 2701 // Note: You must call the "Send" method on the returned request object in order
 2702 // to execute the request.
 2703 //
 2704 //    // Example sending a request using the CreateNetworkAclRequest method.
 2705 //    req, resp := client.CreateNetworkAclRequest(params)
 2706 //
 2707 //    err := req.Send()
 2708 //    if err == nil { // resp is now filled
 2709 //        fmt.Println(resp)
 2710 //    }
 2711 //
 2712 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkAcl
 2713 func (c *EC2) CreateNetworkAclRequest(input *CreateNetworkAclInput) (req *request.Request, output *CreateNetworkAclOutput) {
 2714     op := &request.Operation{
 2715         Name:       opCreateNetworkAcl,
 2716         HTTPMethod: "POST",
 2717         HTTPPath:   "/",
 2718     }
 2719 
 2720     if input == nil {
 2721         input = &CreateNetworkAclInput{}
 2722     }
 2723 
 2724     output = &CreateNetworkAclOutput{}
 2725     req = c.newRequest(op, input, output)
 2726     return
 2727 }
 2728 
 2729 // CreateNetworkAcl API operation for Amazon Elastic Compute Cloud.
 2730 //
 2731 // Creates a network ACL in a VPC. Network ACLs provide an optional layer of
 2732 // security (in addition to security groups) for the instances in your VPC.
 2733 //
 2734 // For more information about network ACLs, see Network ACLs (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_ACLs.html)
 2735 // in the Amazon Virtual Private Cloud User Guide.
 2736 //
 2737 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 2738 // with awserr.Error's Code and Message methods to get detailed information about
 2739 // the error.
 2740 //
 2741 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 2742 // API operation CreateNetworkAcl for usage and error information.
 2743 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkAcl
 2744 func (c *EC2) CreateNetworkAcl(input *CreateNetworkAclInput) (*CreateNetworkAclOutput, error) {
 2745     req, out := c.CreateNetworkAclRequest(input)
 2746     err := req.Send()
 2747     return out, err
 2748 }
 2749 
 2750 const opCreateNetworkAclEntry = "CreateNetworkAclEntry"
 2751 
 2752 // CreateNetworkAclEntryRequest generates a "aws/request.Request" representing the
 2753 // client's request for the CreateNetworkAclEntry operation. The "output" return
 2754 // value can be used to capture response data after the request's "Send" method
 2755 // is called.
 2756 //
 2757 // See CreateNetworkAclEntry for usage and error information.
 2758 //
 2759 // Creating a request object using this method should be used when you want to inject
 2760 // custom logic into the request's lifecycle using a custom handler, or if you want to
 2761 // access properties on the request object before or after sending the request. If
 2762 // you just want the service response, call the CreateNetworkAclEntry method directly
 2763 // instead.
 2764 //
 2765 // Note: You must call the "Send" method on the returned request object in order
 2766 // to execute the request.
 2767 //
 2768 //    // Example sending a request using the CreateNetworkAclEntryRequest method.
 2769 //    req, resp := client.CreateNetworkAclEntryRequest(params)
 2770 //
 2771 //    err := req.Send()
 2772 //    if err == nil { // resp is now filled
 2773 //        fmt.Println(resp)
 2774 //    }
 2775 //
 2776 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkAclEntry
 2777 func (c *EC2) CreateNetworkAclEntryRequest(input *CreateNetworkAclEntryInput) (req *request.Request, output *CreateNetworkAclEntryOutput) {
 2778     op := &request.Operation{
 2779         Name:       opCreateNetworkAclEntry,
 2780         HTTPMethod: "POST",
 2781         HTTPPath:   "/",
 2782     }
 2783 
 2784     if input == nil {
 2785         input = &CreateNetworkAclEntryInput{}
 2786     }
 2787 
 2788     output = &CreateNetworkAclEntryOutput{}
 2789     req = c.newRequest(op, input, output)
 2790     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 2791     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 2792     return
 2793 }
 2794 
 2795 // CreateNetworkAclEntry API operation for Amazon Elastic Compute Cloud.
 2796 //
 2797 // Creates an entry (a rule) in a network ACL with the specified rule number.
 2798 // Each network ACL has a set of numbered ingress rules and a separate set of
 2799 // numbered egress rules. When determining whether a packet should be allowed
 2800 // in or out of a subnet associated with the ACL, we process the entries in
 2801 // the ACL according to the rule numbers, in ascending order. Each network ACL
 2802 // has a set of ingress rules and a separate set of egress rules.
 2803 //
 2804 // We recommend that you leave room between the rule numbers (for example, 100,
 2805 // 110, 120, ...), and not number them one right after the other (for example,
 2806 // 101, 102, 103, ...). This makes it easier to add a rule between existing
 2807 // ones without having to renumber the rules.
 2808 //
 2809 // After you add an entry, you can't modify it; you must either replace it,
 2810 // or create an entry and delete the old one.
 2811 //
 2812 // For more information about network ACLs, see Network ACLs (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_ACLs.html)
 2813 // in the Amazon Virtual Private Cloud User Guide.
 2814 //
 2815 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 2816 // with awserr.Error's Code and Message methods to get detailed information about
 2817 // the error.
 2818 //
 2819 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 2820 // API operation CreateNetworkAclEntry for usage and error information.
 2821 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkAclEntry
 2822 func (c *EC2) CreateNetworkAclEntry(input *CreateNetworkAclEntryInput) (*CreateNetworkAclEntryOutput, error) {
 2823     req, out := c.CreateNetworkAclEntryRequest(input)
 2824     err := req.Send()
 2825     return out, err
 2826 }
 2827 
 2828 const opCreateNetworkInterface = "CreateNetworkInterface"
 2829 
 2830 // CreateNetworkInterfaceRequest generates a "aws/request.Request" representing the
 2831 // client's request for the CreateNetworkInterface operation. The "output" return
 2832 // value can be used to capture response data after the request's "Send" method
 2833 // is called.
 2834 //
 2835 // See CreateNetworkInterface for usage and error information.
 2836 //
 2837 // Creating a request object using this method should be used when you want to inject
 2838 // custom logic into the request's lifecycle using a custom handler, or if you want to
 2839 // access properties on the request object before or after sending the request. If
 2840 // you just want the service response, call the CreateNetworkInterface method directly
 2841 // instead.
 2842 //
 2843 // Note: You must call the "Send" method on the returned request object in order
 2844 // to execute the request.
 2845 //
 2846 //    // Example sending a request using the CreateNetworkInterfaceRequest method.
 2847 //    req, resp := client.CreateNetworkInterfaceRequest(params)
 2848 //
 2849 //    err := req.Send()
 2850 //    if err == nil { // resp is now filled
 2851 //        fmt.Println(resp)
 2852 //    }
 2853 //
 2854 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInterface
 2855 func (c *EC2) CreateNetworkInterfaceRequest(input *CreateNetworkInterfaceInput) (req *request.Request, output *CreateNetworkInterfaceOutput) {
 2856     op := &request.Operation{
 2857         Name:       opCreateNetworkInterface,
 2858         HTTPMethod: "POST",
 2859         HTTPPath:   "/",
 2860     }
 2861 
 2862     if input == nil {
 2863         input = &CreateNetworkInterfaceInput{}
 2864     }
 2865 
 2866     output = &CreateNetworkInterfaceOutput{}
 2867     req = c.newRequest(op, input, output)
 2868     return
 2869 }
 2870 
 2871 // CreateNetworkInterface API operation for Amazon Elastic Compute Cloud.
 2872 //
 2873 // Creates a network interface in the specified subnet.
 2874 //
 2875 // For more information about network interfaces, see Elastic Network Interfaces
 2876 // (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) in the
 2877 // Amazon Virtual Private Cloud User Guide.
 2878 //
 2879 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 2880 // with awserr.Error's Code and Message methods to get detailed information about
 2881 // the error.
 2882 //
 2883 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 2884 // API operation CreateNetworkInterface for usage and error information.
 2885 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInterface
 2886 func (c *EC2) CreateNetworkInterface(input *CreateNetworkInterfaceInput) (*CreateNetworkInterfaceOutput, error) {
 2887     req, out := c.CreateNetworkInterfaceRequest(input)
 2888     err := req.Send()
 2889     return out, err
 2890 }
 2891 
 2892 const opCreatePlacementGroup = "CreatePlacementGroup"
 2893 
 2894 // CreatePlacementGroupRequest generates a "aws/request.Request" representing the
 2895 // client's request for the CreatePlacementGroup operation. The "output" return
 2896 // value can be used to capture response data after the request's "Send" method
 2897 // is called.
 2898 //
 2899 // See CreatePlacementGroup for usage and error information.
 2900 //
 2901 // Creating a request object using this method should be used when you want to inject
 2902 // custom logic into the request's lifecycle using a custom handler, or if you want to
 2903 // access properties on the request object before or after sending the request. If
 2904 // you just want the service response, call the CreatePlacementGroup method directly
 2905 // instead.
 2906 //
 2907 // Note: You must call the "Send" method on the returned request object in order
 2908 // to execute the request.
 2909 //
 2910 //    // Example sending a request using the CreatePlacementGroupRequest method.
 2911 //    req, resp := client.CreatePlacementGroupRequest(params)
 2912 //
 2913 //    err := req.Send()
 2914 //    if err == nil { // resp is now filled
 2915 //        fmt.Println(resp)
 2916 //    }
 2917 //
 2918 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreatePlacementGroup
 2919 func (c *EC2) CreatePlacementGroupRequest(input *CreatePlacementGroupInput) (req *request.Request, output *CreatePlacementGroupOutput) {
 2920     op := &request.Operation{
 2921         Name:       opCreatePlacementGroup,
 2922         HTTPMethod: "POST",
 2923         HTTPPath:   "/",
 2924     }
 2925 
 2926     if input == nil {
 2927         input = &CreatePlacementGroupInput{}
 2928     }
 2929 
 2930     output = &CreatePlacementGroupOutput{}
 2931     req = c.newRequest(op, input, output)
 2932     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 2933     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 2934     return
 2935 }
 2936 
 2937 // CreatePlacementGroup API operation for Amazon Elastic Compute Cloud.
 2938 //
 2939 // Creates a placement group that you launch cluster instances into. You must
 2940 // give the group a name that's unique within the scope of your account.
 2941 //
 2942 // For more information about placement groups and cluster instances, see Cluster
 2943 // Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using_cluster_computing.html)
 2944 // in the Amazon Elastic Compute Cloud User Guide.
 2945 //
 2946 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 2947 // with awserr.Error's Code and Message methods to get detailed information about
 2948 // the error.
 2949 //
 2950 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 2951 // API operation CreatePlacementGroup for usage and error information.
 2952 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreatePlacementGroup
 2953 func (c *EC2) CreatePlacementGroup(input *CreatePlacementGroupInput) (*CreatePlacementGroupOutput, error) {
 2954     req, out := c.CreatePlacementGroupRequest(input)
 2955     err := req.Send()
 2956     return out, err
 2957 }
 2958 
 2959 const opCreateReservedInstancesListing = "CreateReservedInstancesListing"
 2960 
 2961 // CreateReservedInstancesListingRequest generates a "aws/request.Request" representing the
 2962 // client's request for the CreateReservedInstancesListing operation. The "output" return
 2963 // value can be used to capture response data after the request's "Send" method
 2964 // is called.
 2965 //
 2966 // See CreateReservedInstancesListing for usage and error information.
 2967 //
 2968 // Creating a request object using this method should be used when you want to inject
 2969 // custom logic into the request's lifecycle using a custom handler, or if you want to
 2970 // access properties on the request object before or after sending the request. If
 2971 // you just want the service response, call the CreateReservedInstancesListing method directly
 2972 // instead.
 2973 //
 2974 // Note: You must call the "Send" method on the returned request object in order
 2975 // to execute the request.
 2976 //
 2977 //    // Example sending a request using the CreateReservedInstancesListingRequest method.
 2978 //    req, resp := client.CreateReservedInstancesListingRequest(params)
 2979 //
 2980 //    err := req.Send()
 2981 //    if err == nil { // resp is now filled
 2982 //        fmt.Println(resp)
 2983 //    }
 2984 //
 2985 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateReservedInstancesListing
 2986 func (c *EC2) CreateReservedInstancesListingRequest(input *CreateReservedInstancesListingInput) (req *request.Request, output *CreateReservedInstancesListingOutput) {
 2987     op := &request.Operation{
 2988         Name:       opCreateReservedInstancesListing,
 2989         HTTPMethod: "POST",
 2990         HTTPPath:   "/",
 2991     }
 2992 
 2993     if input == nil {
 2994         input = &CreateReservedInstancesListingInput{}
 2995     }
 2996 
 2997     output = &CreateReservedInstancesListingOutput{}
 2998     req = c.newRequest(op, input, output)
 2999     return
 3000 }
 3001 
 3002 // CreateReservedInstancesListing API operation for Amazon Elastic Compute Cloud.
 3003 //
 3004 // Creates a listing for Amazon EC2 Standard Reserved Instances to be sold in
 3005 // the Reserved Instance Marketplace. You can submit one Standard Reserved Instance
 3006 // listing at a time. To get a list of your Standard Reserved Instances, you
 3007 // can use the DescribeReservedInstances operation.
 3008 //
 3009 // Only Standard Reserved Instances with a capacity reservation can be sold
 3010 // in the Reserved Instance Marketplace. Convertible Reserved Instances and
 3011 // Standard Reserved Instances with a regional benefit cannot be sold.
 3012 //
 3013 // The Reserved Instance Marketplace matches sellers who want to resell Standard
 3014 // Reserved Instance capacity that they no longer need with buyers who want
 3015 // to purchase additional capacity. Reserved Instances bought and sold through
 3016 // the Reserved Instance Marketplace work like any other Reserved Instances.
 3017 //
 3018 // To sell your Standard Reserved Instances, you must first register as a seller
 3019 // in the Reserved Instance Marketplace. After completing the registration process,
 3020 // you can create a Reserved Instance Marketplace listing of some or all of
 3021 // your Standard Reserved Instances, and specify the upfront price to receive
 3022 // for them. Your Standard Reserved Instance listings then become available
 3023 // for purchase. To view the details of your Standard Reserved Instance listing,
 3024 // you can use the DescribeReservedInstancesListings operation.
 3025 //
 3026 // For more information, see Reserved Instance Marketplace (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html)
 3027 // in the Amazon Elastic Compute Cloud User Guide.
 3028 //
 3029 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 3030 // with awserr.Error's Code and Message methods to get detailed information about
 3031 // the error.
 3032 //
 3033 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 3034 // API operation CreateReservedInstancesListing for usage and error information.
 3035 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateReservedInstancesListing
 3036 func (c *EC2) CreateReservedInstancesListing(input *CreateReservedInstancesListingInput) (*CreateReservedInstancesListingOutput, error) {
 3037     req, out := c.CreateReservedInstancesListingRequest(input)
 3038     err := req.Send()
 3039     return out, err
 3040 }
 3041 
 3042 const opCreateRoute = "CreateRoute"
 3043 
 3044 // CreateRouteRequest generates a "aws/request.Request" representing the
 3045 // client's request for the CreateRoute operation. The "output" return
 3046 // value can be used to capture response data after the request's "Send" method
 3047 // is called.
 3048 //
 3049 // See CreateRoute for usage and error information.
 3050 //
 3051 // Creating a request object using this method should be used when you want to inject
 3052 // custom logic into the request's lifecycle using a custom handler, or if you want to
 3053 // access properties on the request object before or after sending the request. If
 3054 // you just want the service response, call the CreateRoute method directly
 3055 // instead.
 3056 //
 3057 // Note: You must call the "Send" method on the returned request object in order
 3058 // to execute the request.
 3059 //
 3060 //    // Example sending a request using the CreateRouteRequest method.
 3061 //    req, resp := client.CreateRouteRequest(params)
 3062 //
 3063 //    err := req.Send()
 3064 //    if err == nil { // resp is now filled
 3065 //        fmt.Println(resp)
 3066 //    }
 3067 //
 3068 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRoute
 3069 func (c *EC2) CreateRouteRequest(input *CreateRouteInput) (req *request.Request, output *CreateRouteOutput) {
 3070     op := &request.Operation{
 3071         Name:       opCreateRoute,
 3072         HTTPMethod: "POST",
 3073         HTTPPath:   "/",
 3074     }
 3075 
 3076     if input == nil {
 3077         input = &CreateRouteInput{}
 3078     }
 3079 
 3080     output = &CreateRouteOutput{}
 3081     req = c.newRequest(op, input, output)
 3082     return
 3083 }
 3084 
 3085 // CreateRoute API operation for Amazon Elastic Compute Cloud.
 3086 //
 3087 // Creates a route in a route table within a VPC.
 3088 //
 3089 // You must specify one of the following targets: Internet gateway or virtual
 3090 // private gateway, NAT instance, NAT gateway, VPC peering connection, network
 3091 // interface, or egress-only Internet gateway.
 3092 //
 3093 // When determining how to route traffic, we use the route with the most specific
 3094 // match. For example, traffic is destined for the IPv4 address 192.0.2.3, and
 3095 // the route table includes the following two IPv4 routes:
 3096 //
 3097 //    * 192.0.2.0/24 (goes to some target A)
 3098 //
 3099 //    * 192.0.2.0/28 (goes to some target B)
 3100 //
 3101 // Both routes apply to the traffic destined for 192.0.2.3. However, the second
 3102 // route in the list covers a smaller number of IP addresses and is therefore
 3103 // more specific, so we use that route to determine where to target the traffic.
 3104 //
 3105 // For more information about route tables, see Route Tables (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Route_Tables.html)
 3106 // in the Amazon Virtual Private Cloud User Guide.
 3107 //
 3108 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 3109 // with awserr.Error's Code and Message methods to get detailed information about
 3110 // the error.
 3111 //
 3112 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 3113 // API operation CreateRoute for usage and error information.
 3114 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRoute
 3115 func (c *EC2) CreateRoute(input *CreateRouteInput) (*CreateRouteOutput, error) {
 3116     req, out := c.CreateRouteRequest(input)
 3117     err := req.Send()
 3118     return out, err
 3119 }
 3120 
 3121 const opCreateRouteTable = "CreateRouteTable"
 3122 
 3123 // CreateRouteTableRequest generates a "aws/request.Request" representing the
 3124 // client's request for the CreateRouteTable operation. The "output" return
 3125 // value can be used to capture response data after the request's "Send" method
 3126 // is called.
 3127 //
 3128 // See CreateRouteTable for usage and error information.
 3129 //
 3130 // Creating a request object using this method should be used when you want to inject
 3131 // custom logic into the request's lifecycle using a custom handler, or if you want to
 3132 // access properties on the request object before or after sending the request. If
 3133 // you just want the service response, call the CreateRouteTable method directly
 3134 // instead.
 3135 //
 3136 // Note: You must call the "Send" method on the returned request object in order
 3137 // to execute the request.
 3138 //
 3139 //    // Example sending a request using the CreateRouteTableRequest method.
 3140 //    req, resp := client.CreateRouteTableRequest(params)
 3141 //
 3142 //    err := req.Send()
 3143 //    if err == nil { // resp is now filled
 3144 //        fmt.Println(resp)
 3145 //    }
 3146 //
 3147 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRouteTable
 3148 func (c *EC2) CreateRouteTableRequest(input *CreateRouteTableInput) (req *request.Request, output *CreateRouteTableOutput) {
 3149     op := &request.Operation{
 3150         Name:       opCreateRouteTable,
 3151         HTTPMethod: "POST",
 3152         HTTPPath:   "/",
 3153     }
 3154 
 3155     if input == nil {
 3156         input = &CreateRouteTableInput{}
 3157     }
 3158 
 3159     output = &CreateRouteTableOutput{}
 3160     req = c.newRequest(op, input, output)
 3161     return
 3162 }
 3163 
 3164 // CreateRouteTable API operation for Amazon Elastic Compute Cloud.
 3165 //
 3166 // Creates a route table for the specified VPC. After you create a route table,
 3167 // you can add routes and associate the table with a subnet.
 3168 //
 3169 // For more information about route tables, see Route Tables (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Route_Tables.html)
 3170 // in the Amazon Virtual Private Cloud User Guide.
 3171 //
 3172 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 3173 // with awserr.Error's Code and Message methods to get detailed information about
 3174 // the error.
 3175 //
 3176 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 3177 // API operation CreateRouteTable for usage and error information.
 3178 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRouteTable
 3179 func (c *EC2) CreateRouteTable(input *CreateRouteTableInput) (*CreateRouteTableOutput, error) {
 3180     req, out := c.CreateRouteTableRequest(input)
 3181     err := req.Send()
 3182     return out, err
 3183 }
 3184 
 3185 const opCreateSecurityGroup = "CreateSecurityGroup"
 3186 
 3187 // CreateSecurityGroupRequest generates a "aws/request.Request" representing the
 3188 // client's request for the CreateSecurityGroup operation. The "output" return
 3189 // value can be used to capture response data after the request's "Send" method
 3190 // is called.
 3191 //
 3192 // See CreateSecurityGroup for usage and error information.
 3193 //
 3194 // Creating a request object using this method should be used when you want to inject
 3195 // custom logic into the request's lifecycle using a custom handler, or if you want to
 3196 // access properties on the request object before or after sending the request. If
 3197 // you just want the service response, call the CreateSecurityGroup method directly
 3198 // instead.
 3199 //
 3200 // Note: You must call the "Send" method on the returned request object in order
 3201 // to execute the request.
 3202 //
 3203 //    // Example sending a request using the CreateSecurityGroupRequest method.
 3204 //    req, resp := client.CreateSecurityGroupRequest(params)
 3205 //
 3206 //    err := req.Send()
 3207 //    if err == nil { // resp is now filled
 3208 //        fmt.Println(resp)
 3209 //    }
 3210 //
 3211 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSecurityGroup
 3212 func (c *EC2) CreateSecurityGroupRequest(input *CreateSecurityGroupInput) (req *request.Request, output *CreateSecurityGroupOutput) {
 3213     op := &request.Operation{
 3214         Name:       opCreateSecurityGroup,
 3215         HTTPMethod: "POST",
 3216         HTTPPath:   "/",
 3217     }
 3218 
 3219     if input == nil {
 3220         input = &CreateSecurityGroupInput{}
 3221     }
 3222 
 3223     output = &CreateSecurityGroupOutput{}
 3224     req = c.newRequest(op, input, output)
 3225     return
 3226 }
 3227 
 3228 // CreateSecurityGroup API operation for Amazon Elastic Compute Cloud.
 3229 //
 3230 // Creates a security group.
 3231 //
 3232 // A security group is for use with instances either in the EC2-Classic platform
 3233 // or in a specific VPC. For more information, see Amazon EC2 Security Groups
 3234 // (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html)
 3235 // in the Amazon Elastic Compute Cloud User Guide and Security Groups for Your
 3236 // VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_SecurityGroups.html)
 3237 // in the Amazon Virtual Private Cloud User Guide.
 3238 //
 3239 // EC2-Classic: You can have up to 500 security groups.
 3240 //
 3241 // EC2-VPC: You can create up to 500 security groups per VPC.
 3242 //
 3243 // When you create a security group, you specify a friendly name of your choice.
 3244 // You can have a security group for use in EC2-Classic with the same name as
 3245 // a security group for use in a VPC. However, you can't have two security groups
 3246 // for use in EC2-Classic with the same name or two security groups for use
 3247 // in a VPC with the same name.
 3248 //
 3249 // You have a default security group for use in EC2-Classic and a default security
 3250 // group for use in your VPC. If you don't specify a security group when you
 3251 // launch an instance, the instance is launched into the appropriate default
 3252 // security group. A default security group includes a default rule that grants
 3253 // instances unrestricted network access to each other.
 3254 //
 3255 // You can add or remove rules from your security groups using AuthorizeSecurityGroupIngress,
 3256 // AuthorizeSecurityGroupEgress, RevokeSecurityGroupIngress, and RevokeSecurityGroupEgress.
 3257 //
 3258 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 3259 // with awserr.Error's Code and Message methods to get detailed information about
 3260 // the error.
 3261 //
 3262 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 3263 // API operation CreateSecurityGroup for usage and error information.
 3264 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSecurityGroup
 3265 func (c *EC2) CreateSecurityGroup(input *CreateSecurityGroupInput) (*CreateSecurityGroupOutput, error) {
 3266     req, out := c.CreateSecurityGroupRequest(input)
 3267     err := req.Send()
 3268     return out, err
 3269 }
 3270 
 3271 const opCreateSnapshot = "CreateSnapshot"
 3272 
 3273 // CreateSnapshotRequest generates a "aws/request.Request" representing the
 3274 // client's request for the CreateSnapshot operation. The "output" return
 3275 // value can be used to capture response data after the request's "Send" method
 3276 // is called.
 3277 //
 3278 // See CreateSnapshot for usage and error information.
 3279 //
 3280 // Creating a request object using this method should be used when you want to inject
 3281 // custom logic into the request's lifecycle using a custom handler, or if you want to
 3282 // access properties on the request object before or after sending the request. If
 3283 // you just want the service response, call the CreateSnapshot method directly
 3284 // instead.
 3285 //
 3286 // Note: You must call the "Send" method on the returned request object in order
 3287 // to execute the request.
 3288 //
 3289 //    // Example sending a request using the CreateSnapshotRequest method.
 3290 //    req, resp := client.CreateSnapshotRequest(params)
 3291 //
 3292 //    err := req.Send()
 3293 //    if err == nil { // resp is now filled
 3294 //        fmt.Println(resp)
 3295 //    }
 3296 //
 3297 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSnapshot
 3298 func (c *EC2) CreateSnapshotRequest(input *CreateSnapshotInput) (req *request.Request, output *Snapshot) {
 3299     op := &request.Operation{
 3300         Name:       opCreateSnapshot,
 3301         HTTPMethod: "POST",
 3302         HTTPPath:   "/",
 3303     }
 3304 
 3305     if input == nil {
 3306         input = &CreateSnapshotInput{}
 3307     }
 3308 
 3309     output = &Snapshot{}
 3310     req = c.newRequest(op, input, output)
 3311     return
 3312 }
 3313 
 3314 // CreateSnapshot API operation for Amazon Elastic Compute Cloud.
 3315 //
 3316 // Creates a snapshot of an EBS volume and stores it in Amazon S3. You can use
 3317 // snapshots for backups, to make copies of EBS volumes, and to save data before
 3318 // shutting down an instance.
 3319 //
 3320 // When a snapshot is created, any AWS Marketplace product codes that are associated
 3321 // with the source volume are propagated to the snapshot.
 3322 //
 3323 // You can take a snapshot of an attached volume that is in use. However, snapshots
 3324 // only capture data that has been written to your EBS volume at the time the
 3325 // snapshot command is issued; this may exclude any data that has been cached
 3326 // by any applications or the operating system. If you can pause any file systems
 3327 // on the volume long enough to take a snapshot, your snapshot should be complete.
 3328 // However, if you cannot pause all file writes to the volume, you should unmount
 3329 // the volume from within the instance, issue the snapshot command, and then
 3330 // remount the volume to ensure a consistent and complete snapshot. You may
 3331 // remount and use your volume while the snapshot status is pending.
 3332 //
 3333 // To create a snapshot for EBS volumes that serve as root devices, you should
 3334 // stop the instance before taking the snapshot.
 3335 //
 3336 // Snapshots that are taken from encrypted volumes are automatically encrypted.
 3337 // Volumes that are created from encrypted snapshots are also automatically
 3338 // encrypted. Your encrypted volumes and any associated snapshots always remain
 3339 // protected.
 3340 //
 3341 // For more information, see Amazon Elastic Block Store (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html)
 3342 // and Amazon EBS Encryption (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html)
 3343 // in the Amazon Elastic Compute Cloud User Guide.
 3344 //
 3345 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 3346 // with awserr.Error's Code and Message methods to get detailed information about
 3347 // the error.
 3348 //
 3349 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 3350 // API operation CreateSnapshot for usage and error information.
 3351 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSnapshot
 3352 func (c *EC2) CreateSnapshot(input *CreateSnapshotInput) (*Snapshot, error) {
 3353     req, out := c.CreateSnapshotRequest(input)
 3354     err := req.Send()
 3355     return out, err
 3356 }
 3357 
 3358 const opCreateSpotDatafeedSubscription = "CreateSpotDatafeedSubscription"
 3359 
 3360 // CreateSpotDatafeedSubscriptionRequest generates a "aws/request.Request" representing the
 3361 // client's request for the CreateSpotDatafeedSubscription operation. The "output" return
 3362 // value can be used to capture response data after the request's "Send" method
 3363 // is called.
 3364 //
 3365 // See CreateSpotDatafeedSubscription for usage and error information.
 3366 //
 3367 // Creating a request object using this method should be used when you want to inject
 3368 // custom logic into the request's lifecycle using a custom handler, or if you want to
 3369 // access properties on the request object before or after sending the request. If
 3370 // you just want the service response, call the CreateSpotDatafeedSubscription method directly
 3371 // instead.
 3372 //
 3373 // Note: You must call the "Send" method on the returned request object in order
 3374 // to execute the request.
 3375 //
 3376 //    // Example sending a request using the CreateSpotDatafeedSubscriptionRequest method.
 3377 //    req, resp := client.CreateSpotDatafeedSubscriptionRequest(params)
 3378 //
 3379 //    err := req.Send()
 3380 //    if err == nil { // resp is now filled
 3381 //        fmt.Println(resp)
 3382 //    }
 3383 //
 3384 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSpotDatafeedSubscription
 3385 func (c *EC2) CreateSpotDatafeedSubscriptionRequest(input *CreateSpotDatafeedSubscriptionInput) (req *request.Request, output *CreateSpotDatafeedSubscriptionOutput) {
 3386     op := &request.Operation{
 3387         Name:       opCreateSpotDatafeedSubscription,
 3388         HTTPMethod: "POST",
 3389         HTTPPath:   "/",
 3390     }
 3391 
 3392     if input == nil {
 3393         input = &CreateSpotDatafeedSubscriptionInput{}
 3394     }
 3395 
 3396     output = &CreateSpotDatafeedSubscriptionOutput{}
 3397     req = c.newRequest(op, input, output)
 3398     return
 3399 }
 3400 
 3401 // CreateSpotDatafeedSubscription API operation for Amazon Elastic Compute Cloud.
 3402 //
 3403 // Creates a data feed for Spot instances, enabling you to view Spot instance
 3404 // usage logs. You can create one data feed per AWS account. For more information,
 3405 // see Spot Instance Data Feed (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-data-feeds.html)
 3406 // in the Amazon Elastic Compute Cloud User Guide.
 3407 //
 3408 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 3409 // with awserr.Error's Code and Message methods to get detailed information about
 3410 // the error.
 3411 //
 3412 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 3413 // API operation CreateSpotDatafeedSubscription for usage and error information.
 3414 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSpotDatafeedSubscription
 3415 func (c *EC2) CreateSpotDatafeedSubscription(input *CreateSpotDatafeedSubscriptionInput) (*CreateSpotDatafeedSubscriptionOutput, error) {
 3416     req, out := c.CreateSpotDatafeedSubscriptionRequest(input)
 3417     err := req.Send()
 3418     return out, err
 3419 }
 3420 
 3421 const opCreateSubnet = "CreateSubnet"
 3422 
 3423 // CreateSubnetRequest generates a "aws/request.Request" representing the
 3424 // client's request for the CreateSubnet operation. The "output" return
 3425 // value can be used to capture response data after the request's "Send" method
 3426 // is called.
 3427 //
 3428 // See CreateSubnet for usage and error information.
 3429 //
 3430 // Creating a request object using this method should be used when you want to inject
 3431 // custom logic into the request's lifecycle using a custom handler, or if you want to
 3432 // access properties on the request object before or after sending the request. If
 3433 // you just want the service response, call the CreateSubnet method directly
 3434 // instead.
 3435 //
 3436 // Note: You must call the "Send" method on the returned request object in order
 3437 // to execute the request.
 3438 //
 3439 //    // Example sending a request using the CreateSubnetRequest method.
 3440 //    req, resp := client.CreateSubnetRequest(params)
 3441 //
 3442 //    err := req.Send()
 3443 //    if err == nil { // resp is now filled
 3444 //        fmt.Println(resp)
 3445 //    }
 3446 //
 3447 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSubnet
 3448 func (c *EC2) CreateSubnetRequest(input *CreateSubnetInput) (req *request.Request, output *CreateSubnetOutput) {
 3449     op := &request.Operation{
 3450         Name:       opCreateSubnet,
 3451         HTTPMethod: "POST",
 3452         HTTPPath:   "/",
 3453     }
 3454 
 3455     if input == nil {
 3456         input = &CreateSubnetInput{}
 3457     }
 3458 
 3459     output = &CreateSubnetOutput{}
 3460     req = c.newRequest(op, input, output)
 3461     return
 3462 }
 3463 
 3464 // CreateSubnet API operation for Amazon Elastic Compute Cloud.
 3465 //
 3466 // Creates a subnet in an existing VPC.
 3467 //
 3468 // When you create each subnet, you provide the VPC ID and the CIDR block you
 3469 // want for the subnet. After you create a subnet, you can't change its CIDR
 3470 // block. The subnet's IPv4 CIDR block can be the same as the VPC's IPv4 CIDR
 3471 // block (assuming you want only a single subnet in the VPC), or a subset of
 3472 // the VPC's IPv4 CIDR block. If you create more than one subnet in a VPC, the
 3473 // subnets' CIDR blocks must not overlap. The smallest IPv4 subnet (and VPC)
 3474 // you can create uses a /28 netmask (16 IPv4 addresses), and the largest uses
 3475 // a /16 netmask (65,536 IPv4 addresses).
 3476 //
 3477 // If you've associated an IPv6 CIDR block with your VPC, you can create a subnet
 3478 // with an IPv6 CIDR block that uses a /64 prefix length.
 3479 //
 3480 // AWS reserves both the first four and the last IP address in each subnet's
 3481 // CIDR block. They're not available for use.
 3482 //
 3483 // If you add more than one subnet to a VPC, they're set up in a star topology
 3484 // with a logical router in the middle.
 3485 //
 3486 // If you launch an instance in a VPC using an Amazon EBS-backed AMI, the IP
 3487 // address doesn't change if you stop and restart the instance (unlike a similar
 3488 // instance launched outside a VPC, which gets a new IP address when restarted).
 3489 // It's therefore possible to have a subnet with no running instances (they're
 3490 // all stopped), but no remaining IP addresses available.
 3491 //
 3492 // For more information about subnets, see Your VPC and Subnets (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Subnets.html)
 3493 // in the Amazon Virtual Private Cloud User Guide.
 3494 //
 3495 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 3496 // with awserr.Error's Code and Message methods to get detailed information about
 3497 // the error.
 3498 //
 3499 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 3500 // API operation CreateSubnet for usage and error information.
 3501 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSubnet
 3502 func (c *EC2) CreateSubnet(input *CreateSubnetInput) (*CreateSubnetOutput, error) {
 3503     req, out := c.CreateSubnetRequest(input)
 3504     err := req.Send()
 3505     return out, err
 3506 }
 3507 
 3508 const opCreateTags = "CreateTags"
 3509 
 3510 // CreateTagsRequest generates a "aws/request.Request" representing the
 3511 // client's request for the CreateTags operation. The "output" return
 3512 // value can be used to capture response data after the request's "Send" method
 3513 // is called.
 3514 //
 3515 // See CreateTags for usage and error information.
 3516 //
 3517 // Creating a request object using this method should be used when you want to inject
 3518 // custom logic into the request's lifecycle using a custom handler, or if you want to
 3519 // access properties on the request object before or after sending the request. If
 3520 // you just want the service response, call the CreateTags method directly
 3521 // instead.
 3522 //
 3523 // Note: You must call the "Send" method on the returned request object in order
 3524 // to execute the request.
 3525 //
 3526 //    // Example sending a request using the CreateTagsRequest method.
 3527 //    req, resp := client.CreateTagsRequest(params)
 3528 //
 3529 //    err := req.Send()
 3530 //    if err == nil { // resp is now filled
 3531 //        fmt.Println(resp)
 3532 //    }
 3533 //
 3534 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTags
 3535 func (c *EC2) CreateTagsRequest(input *CreateTagsInput) (req *request.Request, output *CreateTagsOutput) {
 3536     op := &request.Operation{
 3537         Name:       opCreateTags,
 3538         HTTPMethod: "POST",
 3539         HTTPPath:   "/",
 3540     }
 3541 
 3542     if input == nil {
 3543         input = &CreateTagsInput{}
 3544     }
 3545 
 3546     output = &CreateTagsOutput{}
 3547     req = c.newRequest(op, input, output)
 3548     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 3549     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 3550     return
 3551 }
 3552 
 3553 // CreateTags API operation for Amazon Elastic Compute Cloud.
 3554 //
 3555 // Adds or overwrites one or more tags for the specified Amazon EC2 resource
 3556 // or resources. Each resource can have a maximum of 50 tags. Each tag consists
 3557 // of a key and optional value. Tag keys must be unique per resource.
 3558 //
 3559 // For more information about tags, see Tagging Your Resources (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html)
 3560 // in the Amazon Elastic Compute Cloud User Guide. For more information about
 3561 // creating IAM policies that control users' access to resources based on tags,
 3562 // see Supported Resource-Level Permissions for Amazon EC2 API Actions (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-supported-iam-actions-resources.html)
 3563 // in the Amazon Elastic Compute Cloud User Guide.
 3564 //
 3565 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 3566 // with awserr.Error's Code and Message methods to get detailed information about
 3567 // the error.
 3568 //
 3569 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 3570 // API operation CreateTags for usage and error information.
 3571 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTags
 3572 func (c *EC2) CreateTags(input *CreateTagsInput) (*CreateTagsOutput, error) {
 3573     req, out := c.CreateTagsRequest(input)
 3574     err := req.Send()
 3575     return out, err
 3576 }
 3577 
 3578 const opCreateVolume = "CreateVolume"
 3579 
 3580 // CreateVolumeRequest generates a "aws/request.Request" representing the
 3581 // client's request for the CreateVolume operation. The "output" return
 3582 // value can be used to capture response data after the request's "Send" method
 3583 // is called.
 3584 //
 3585 // See CreateVolume for usage and error information.
 3586 //
 3587 // Creating a request object using this method should be used when you want to inject
 3588 // custom logic into the request's lifecycle using a custom handler, or if you want to
 3589 // access properties on the request object before or after sending the request. If
 3590 // you just want the service response, call the CreateVolume method directly
 3591 // instead.
 3592 //
 3593 // Note: You must call the "Send" method on the returned request object in order
 3594 // to execute the request.
 3595 //
 3596 //    // Example sending a request using the CreateVolumeRequest method.
 3597 //    req, resp := client.CreateVolumeRequest(params)
 3598 //
 3599 //    err := req.Send()
 3600 //    if err == nil { // resp is now filled
 3601 //        fmt.Println(resp)
 3602 //    }
 3603 //
 3604 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVolume
 3605 func (c *EC2) CreateVolumeRequest(input *CreateVolumeInput) (req *request.Request, output *Volume) {
 3606     op := &request.Operation{
 3607         Name:       opCreateVolume,
 3608         HTTPMethod: "POST",
 3609         HTTPPath:   "/",
 3610     }
 3611 
 3612     if input == nil {
 3613         input = &CreateVolumeInput{}
 3614     }
 3615 
 3616     output = &Volume{}
 3617     req = c.newRequest(op, input, output)
 3618     return
 3619 }
 3620 
 3621 // CreateVolume API operation for Amazon Elastic Compute Cloud.
 3622 //
 3623 // Creates an EBS volume that can be attached to an instance in the same Availability
 3624 // Zone. The volume is created in the regional endpoint that you send the HTTP
 3625 // request to. For more information see Regions and Endpoints (http://docs.aws.amazon.com/general/latest/gr/rande.html).
 3626 //
 3627 // You can create a new empty volume or restore a volume from an EBS snapshot.
 3628 // Any AWS Marketplace product codes from the snapshot are propagated to the
 3629 // volume.
 3630 //
 3631 // You can create encrypted volumes with the Encrypted parameter. Encrypted
 3632 // volumes may only be attached to instances that support Amazon EBS encryption.
 3633 // Volumes that are created from encrypted snapshots are also automatically
 3634 // encrypted. For more information, see Amazon EBS Encryption (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html)
 3635 // in the Amazon Elastic Compute Cloud User Guide.
 3636 //
 3637 // For more information, see Creating or Restoring an Amazon EBS Volume (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-creating-volume.html)
 3638 // in the Amazon Elastic Compute Cloud User Guide.
 3639 //
 3640 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 3641 // with awserr.Error's Code and Message methods to get detailed information about
 3642 // the error.
 3643 //
 3644 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 3645 // API operation CreateVolume for usage and error information.
 3646 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVolume
 3647 func (c *EC2) CreateVolume(input *CreateVolumeInput) (*Volume, error) {
 3648     req, out := c.CreateVolumeRequest(input)
 3649     err := req.Send()
 3650     return out, err
 3651 }
 3652 
 3653 const opCreateVpc = "CreateVpc"
 3654 
 3655 // CreateVpcRequest generates a "aws/request.Request" representing the
 3656 // client's request for the CreateVpc operation. The "output" return
 3657 // value can be used to capture response data after the request's "Send" method
 3658 // is called.
 3659 //
 3660 // See CreateVpc for usage and error information.
 3661 //
 3662 // Creating a request object using this method should be used when you want to inject
 3663 // custom logic into the request's lifecycle using a custom handler, or if you want to
 3664 // access properties on the request object before or after sending the request. If
 3665 // you just want the service response, call the CreateVpc method directly
 3666 // instead.
 3667 //
 3668 // Note: You must call the "Send" method on the returned request object in order
 3669 // to execute the request.
 3670 //
 3671 //    // Example sending a request using the CreateVpcRequest method.
 3672 //    req, resp := client.CreateVpcRequest(params)
 3673 //
 3674 //    err := req.Send()
 3675 //    if err == nil { // resp is now filled
 3676 //        fmt.Println(resp)
 3677 //    }
 3678 //
 3679 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpc
 3680 func (c *EC2) CreateVpcRequest(input *CreateVpcInput) (req *request.Request, output *CreateVpcOutput) {
 3681     op := &request.Operation{
 3682         Name:       opCreateVpc,
 3683         HTTPMethod: "POST",
 3684         HTTPPath:   "/",
 3685     }
 3686 
 3687     if input == nil {
 3688         input = &CreateVpcInput{}
 3689     }
 3690 
 3691     output = &CreateVpcOutput{}
 3692     req = c.newRequest(op, input, output)
 3693     return
 3694 }
 3695 
 3696 // CreateVpc API operation for Amazon Elastic Compute Cloud.
 3697 //
 3698 // Creates a VPC with the specified IPv4 CIDR block. The smallest VPC you can
 3699 // create uses a /28 netmask (16 IPv4 addresses), and the largest uses a /16
 3700 // netmask (65,536 IPv4 addresses). To help you decide how big to make your
 3701 // VPC, see Your VPC and Subnets (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Subnets.html)
 3702 // in the Amazon Virtual Private Cloud User Guide.
 3703 //
 3704 // You can optionally request an Amazon-provided IPv6 CIDR block for the VPC.
 3705 // The IPv6 CIDR block uses a /56 prefix length, and is allocated from Amazon's
 3706 // pool of IPv6 addresses. You cannot choose the IPv6 range for your VPC.
 3707 //
 3708 // By default, each instance you launch in the VPC has the default DHCP options,
 3709 // which includes only a default DNS server that we provide (AmazonProvidedDNS).
 3710 // For more information about DHCP options, see DHCP Options Sets (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_DHCP_Options.html)
 3711 // in the Amazon Virtual Private Cloud User Guide.
 3712 //
 3713 // You can specify the instance tenancy value for the VPC when you create it.
 3714 // You can't change this value for the VPC after you create it. For more information,
 3715 // see Dedicated Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-instance.html)
 3716 // in the Amazon Elastic Compute Cloud User Guide.
 3717 //
 3718 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 3719 // with awserr.Error's Code and Message methods to get detailed information about
 3720 // the error.
 3721 //
 3722 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 3723 // API operation CreateVpc for usage and error information.
 3724 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpc
 3725 func (c *EC2) CreateVpc(input *CreateVpcInput) (*CreateVpcOutput, error) {
 3726     req, out := c.CreateVpcRequest(input)
 3727     err := req.Send()
 3728     return out, err
 3729 }
 3730 
 3731 const opCreateVpcEndpoint = "CreateVpcEndpoint"
 3732 
 3733 // CreateVpcEndpointRequest generates a "aws/request.Request" representing the
 3734 // client's request for the CreateVpcEndpoint operation. The "output" return
 3735 // value can be used to capture response data after the request's "Send" method
 3736 // is called.
 3737 //
 3738 // See CreateVpcEndpoint for usage and error information.
 3739 //
 3740 // Creating a request object using this method should be used when you want to inject
 3741 // custom logic into the request's lifecycle using a custom handler, or if you want to
 3742 // access properties on the request object before or after sending the request. If
 3743 // you just want the service response, call the CreateVpcEndpoint method directly
 3744 // instead.
 3745 //
 3746 // Note: You must call the "Send" method on the returned request object in order
 3747 // to execute the request.
 3748 //
 3749 //    // Example sending a request using the CreateVpcEndpointRequest method.
 3750 //    req, resp := client.CreateVpcEndpointRequest(params)
 3751 //
 3752 //    err := req.Send()
 3753 //    if err == nil { // resp is now filled
 3754 //        fmt.Println(resp)
 3755 //    }
 3756 //
 3757 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEndpoint
 3758 func (c *EC2) CreateVpcEndpointRequest(input *CreateVpcEndpointInput) (req *request.Request, output *CreateVpcEndpointOutput) {
 3759     op := &request.Operation{
 3760         Name:       opCreateVpcEndpoint,
 3761         HTTPMethod: "POST",
 3762         HTTPPath:   "/",
 3763     }
 3764 
 3765     if input == nil {
 3766         input = &CreateVpcEndpointInput{}
 3767     }
 3768 
 3769     output = &CreateVpcEndpointOutput{}
 3770     req = c.newRequest(op, input, output)
 3771     return
 3772 }
 3773 
 3774 // CreateVpcEndpoint API operation for Amazon Elastic Compute Cloud.
 3775 //
 3776 // Creates a VPC endpoint for a specified AWS service. An endpoint enables you
 3777 // to create a private connection between your VPC and another AWS service in
 3778 // your account. You can specify an endpoint policy to attach to the endpoint
 3779 // that will control access to the service from your VPC. You can also specify
 3780 // the VPC route tables that use the endpoint.
 3781 //
 3782 // Use DescribeVpcEndpointServices to get a list of supported AWS services.
 3783 //
 3784 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 3785 // with awserr.Error's Code and Message methods to get detailed information about
 3786 // the error.
 3787 //
 3788 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 3789 // API operation CreateVpcEndpoint for usage and error information.
 3790 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEndpoint
 3791 func (c *EC2) CreateVpcEndpoint(input *CreateVpcEndpointInput) (*CreateVpcEndpointOutput, error) {
 3792     req, out := c.CreateVpcEndpointRequest(input)
 3793     err := req.Send()
 3794     return out, err
 3795 }
 3796 
 3797 const opCreateVpcPeeringConnection = "CreateVpcPeeringConnection"
 3798 
 3799 // CreateVpcPeeringConnectionRequest generates a "aws/request.Request" representing the
 3800 // client's request for the CreateVpcPeeringConnection operation. The "output" return
 3801 // value can be used to capture response data after the request's "Send" method
 3802 // is called.
 3803 //
 3804 // See CreateVpcPeeringConnection for usage and error information.
 3805 //
 3806 // Creating a request object using this method should be used when you want to inject
 3807 // custom logic into the request's lifecycle using a custom handler, or if you want to
 3808 // access properties on the request object before or after sending the request. If
 3809 // you just want the service response, call the CreateVpcPeeringConnection method directly
 3810 // instead.
 3811 //
 3812 // Note: You must call the "Send" method on the returned request object in order
 3813 // to execute the request.
 3814 //
 3815 //    // Example sending a request using the CreateVpcPeeringConnectionRequest method.
 3816 //    req, resp := client.CreateVpcPeeringConnectionRequest(params)
 3817 //
 3818 //    err := req.Send()
 3819 //    if err == nil { // resp is now filled
 3820 //        fmt.Println(resp)
 3821 //    }
 3822 //
 3823 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcPeeringConnection
 3824 func (c *EC2) CreateVpcPeeringConnectionRequest(input *CreateVpcPeeringConnectionInput) (req *request.Request, output *CreateVpcPeeringConnectionOutput) {
 3825     op := &request.Operation{
 3826         Name:       opCreateVpcPeeringConnection,
 3827         HTTPMethod: "POST",
 3828         HTTPPath:   "/",
 3829     }
 3830 
 3831     if input == nil {
 3832         input = &CreateVpcPeeringConnectionInput{}
 3833     }
 3834 
 3835     output = &CreateVpcPeeringConnectionOutput{}
 3836     req = c.newRequest(op, input, output)
 3837     return
 3838 }
 3839 
 3840 // CreateVpcPeeringConnection API operation for Amazon Elastic Compute Cloud.
 3841 //
 3842 // Requests a VPC peering connection between two VPCs: a requester VPC that
 3843 // you own and a peer VPC with which to create the connection. The peer VPC
 3844 // can belong to another AWS account. The requester VPC and peer VPC cannot
 3845 // have overlapping CIDR blocks.
 3846 //
 3847 // The owner of the peer VPC must accept the peering request to activate the
 3848 // peering connection. The VPC peering connection request expires after 7 days,
 3849 // after which it cannot be accepted or rejected.
 3850 //
 3851 // A CreateVpcPeeringConnection request between VPCs with overlapping CIDR blocks
 3852 // results in the VPC peering connection having a status of failed.
 3853 //
 3854 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 3855 // with awserr.Error's Code and Message methods to get detailed information about
 3856 // the error.
 3857 //
 3858 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 3859 // API operation CreateVpcPeeringConnection for usage and error information.
 3860 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcPeeringConnection
 3861 func (c *EC2) CreateVpcPeeringConnection(input *CreateVpcPeeringConnectionInput) (*CreateVpcPeeringConnectionOutput, error) {
 3862     req, out := c.CreateVpcPeeringConnectionRequest(input)
 3863     err := req.Send()
 3864     return out, err
 3865 }
 3866 
 3867 const opCreateVpnConnection = "CreateVpnConnection"
 3868 
 3869 // CreateVpnConnectionRequest generates a "aws/request.Request" representing the
 3870 // client's request for the CreateVpnConnection operation. The "output" return
 3871 // value can be used to capture response data after the request's "Send" method
 3872 // is called.
 3873 //
 3874 // See CreateVpnConnection for usage and error information.
 3875 //
 3876 // Creating a request object using this method should be used when you want to inject
 3877 // custom logic into the request's lifecycle using a custom handler, or if you want to
 3878 // access properties on the request object before or after sending the request. If
 3879 // you just want the service response, call the CreateVpnConnection method directly
 3880 // instead.
 3881 //
 3882 // Note: You must call the "Send" method on the returned request object in order
 3883 // to execute the request.
 3884 //
 3885 //    // Example sending a request using the CreateVpnConnectionRequest method.
 3886 //    req, resp := client.CreateVpnConnectionRequest(params)
 3887 //
 3888 //    err := req.Send()
 3889 //    if err == nil { // resp is now filled
 3890 //        fmt.Println(resp)
 3891 //    }
 3892 //
 3893 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnConnection
 3894 func (c *EC2) CreateVpnConnectionRequest(input *CreateVpnConnectionInput) (req *request.Request, output *CreateVpnConnectionOutput) {
 3895     op := &request.Operation{
 3896         Name:       opCreateVpnConnection,
 3897         HTTPMethod: "POST",
 3898         HTTPPath:   "/",
 3899     }
 3900 
 3901     if input == nil {
 3902         input = &CreateVpnConnectionInput{}
 3903     }
 3904 
 3905     output = &CreateVpnConnectionOutput{}
 3906     req = c.newRequest(op, input, output)
 3907     return
 3908 }
 3909 
 3910 // CreateVpnConnection API operation for Amazon Elastic Compute Cloud.
 3911 //
 3912 // Creates a VPN connection between an existing virtual private gateway and
 3913 // a VPN customer gateway. The only supported connection type is ipsec.1.
 3914 //
 3915 // The response includes information that you need to give to your network administrator
 3916 // to configure your customer gateway.
 3917 //
 3918 // We strongly recommend that you use HTTPS when calling this operation because
 3919 // the response contains sensitive cryptographic information for configuring
 3920 // your customer gateway.
 3921 //
 3922 // If you decide to shut down your VPN connection for any reason and later create
 3923 // a new VPN connection, you must reconfigure your customer gateway with the
 3924 // new information returned from this call.
 3925 //
 3926 // This is an idempotent operation. If you perform the operation more than once,
 3927 // Amazon EC2 doesn't return an error.
 3928 //
 3929 // For more information about VPN connections, see Adding a Hardware Virtual
 3930 // Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
 3931 // in the Amazon Virtual Private Cloud User Guide.
 3932 //
 3933 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 3934 // with awserr.Error's Code and Message methods to get detailed information about
 3935 // the error.
 3936 //
 3937 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 3938 // API operation CreateVpnConnection for usage and error information.
 3939 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnConnection
 3940 func (c *EC2) CreateVpnConnection(input *CreateVpnConnectionInput) (*CreateVpnConnectionOutput, error) {
 3941     req, out := c.CreateVpnConnectionRequest(input)
 3942     err := req.Send()
 3943     return out, err
 3944 }
 3945 
 3946 const opCreateVpnConnectionRoute = "CreateVpnConnectionRoute"
 3947 
 3948 // CreateVpnConnectionRouteRequest generates a "aws/request.Request" representing the
 3949 // client's request for the CreateVpnConnectionRoute operation. The "output" return
 3950 // value can be used to capture response data after the request's "Send" method
 3951 // is called.
 3952 //
 3953 // See CreateVpnConnectionRoute for usage and error information.
 3954 //
 3955 // Creating a request object using this method should be used when you want to inject
 3956 // custom logic into the request's lifecycle using a custom handler, or if you want to
 3957 // access properties on the request object before or after sending the request. If
 3958 // you just want the service response, call the CreateVpnConnectionRoute method directly
 3959 // instead.
 3960 //
 3961 // Note: You must call the "Send" method on the returned request object in order
 3962 // to execute the request.
 3963 //
 3964 //    // Example sending a request using the CreateVpnConnectionRouteRequest method.
 3965 //    req, resp := client.CreateVpnConnectionRouteRequest(params)
 3966 //
 3967 //    err := req.Send()
 3968 //    if err == nil { // resp is now filled
 3969 //        fmt.Println(resp)
 3970 //    }
 3971 //
 3972 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnConnectionRoute
 3973 func (c *EC2) CreateVpnConnectionRouteRequest(input *CreateVpnConnectionRouteInput) (req *request.Request, output *CreateVpnConnectionRouteOutput) {
 3974     op := &request.Operation{
 3975         Name:       opCreateVpnConnectionRoute,
 3976         HTTPMethod: "POST",
 3977         HTTPPath:   "/",
 3978     }
 3979 
 3980     if input == nil {
 3981         input = &CreateVpnConnectionRouteInput{}
 3982     }
 3983 
 3984     output = &CreateVpnConnectionRouteOutput{}
 3985     req = c.newRequest(op, input, output)
 3986     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 3987     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 3988     return
 3989 }
 3990 
 3991 // CreateVpnConnectionRoute API operation for Amazon Elastic Compute Cloud.
 3992 //
 3993 // Creates a static route associated with a VPN connection between an existing
 3994 // virtual private gateway and a VPN customer gateway. The static route allows
 3995 // traffic to be routed from the virtual private gateway to the VPN customer
 3996 // gateway.
 3997 //
 3998 // For more information about VPN connections, see Adding a Hardware Virtual
 3999 // Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
 4000 // in the Amazon Virtual Private Cloud User Guide.
 4001 //
 4002 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4003 // with awserr.Error's Code and Message methods to get detailed information about
 4004 // the error.
 4005 //
 4006 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4007 // API operation CreateVpnConnectionRoute for usage and error information.
 4008 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnConnectionRoute
 4009 func (c *EC2) CreateVpnConnectionRoute(input *CreateVpnConnectionRouteInput) (*CreateVpnConnectionRouteOutput, error) {
 4010     req, out := c.CreateVpnConnectionRouteRequest(input)
 4011     err := req.Send()
 4012     return out, err
 4013 }
 4014 
 4015 const opCreateVpnGateway = "CreateVpnGateway"
 4016 
 4017 // CreateVpnGatewayRequest generates a "aws/request.Request" representing the
 4018 // client's request for the CreateVpnGateway operation. The "output" return
 4019 // value can be used to capture response data after the request's "Send" method
 4020 // is called.
 4021 //
 4022 // See CreateVpnGateway for usage and error information.
 4023 //
 4024 // Creating a request object using this method should be used when you want to inject
 4025 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4026 // access properties on the request object before or after sending the request. If
 4027 // you just want the service response, call the CreateVpnGateway method directly
 4028 // instead.
 4029 //
 4030 // Note: You must call the "Send" method on the returned request object in order
 4031 // to execute the request.
 4032 //
 4033 //    // Example sending a request using the CreateVpnGatewayRequest method.
 4034 //    req, resp := client.CreateVpnGatewayRequest(params)
 4035 //
 4036 //    err := req.Send()
 4037 //    if err == nil { // resp is now filled
 4038 //        fmt.Println(resp)
 4039 //    }
 4040 //
 4041 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnGateway
 4042 func (c *EC2) CreateVpnGatewayRequest(input *CreateVpnGatewayInput) (req *request.Request, output *CreateVpnGatewayOutput) {
 4043     op := &request.Operation{
 4044         Name:       opCreateVpnGateway,
 4045         HTTPMethod: "POST",
 4046         HTTPPath:   "/",
 4047     }
 4048 
 4049     if input == nil {
 4050         input = &CreateVpnGatewayInput{}
 4051     }
 4052 
 4053     output = &CreateVpnGatewayOutput{}
 4054     req = c.newRequest(op, input, output)
 4055     return
 4056 }
 4057 
 4058 // CreateVpnGateway API operation for Amazon Elastic Compute Cloud.
 4059 //
 4060 // Creates a virtual private gateway. A virtual private gateway is the endpoint
 4061 // on the VPC side of your VPN connection. You can create a virtual private
 4062 // gateway before creating the VPC itself.
 4063 //
 4064 // For more information about virtual private gateways, see Adding a Hardware
 4065 // Virtual Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
 4066 // in the Amazon Virtual Private Cloud User Guide.
 4067 //
 4068 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4069 // with awserr.Error's Code and Message methods to get detailed information about
 4070 // the error.
 4071 //
 4072 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4073 // API operation CreateVpnGateway for usage and error information.
 4074 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnGateway
 4075 func (c *EC2) CreateVpnGateway(input *CreateVpnGatewayInput) (*CreateVpnGatewayOutput, error) {
 4076     req, out := c.CreateVpnGatewayRequest(input)
 4077     err := req.Send()
 4078     return out, err
 4079 }
 4080 
 4081 const opDeleteCustomerGateway = "DeleteCustomerGateway"
 4082 
 4083 // DeleteCustomerGatewayRequest generates a "aws/request.Request" representing the
 4084 // client's request for the DeleteCustomerGateway operation. The "output" return
 4085 // value can be used to capture response data after the request's "Send" method
 4086 // is called.
 4087 //
 4088 // See DeleteCustomerGateway for usage and error information.
 4089 //
 4090 // Creating a request object using this method should be used when you want to inject
 4091 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4092 // access properties on the request object before or after sending the request. If
 4093 // you just want the service response, call the DeleteCustomerGateway method directly
 4094 // instead.
 4095 //
 4096 // Note: You must call the "Send" method on the returned request object in order
 4097 // to execute the request.
 4098 //
 4099 //    // Example sending a request using the DeleteCustomerGatewayRequest method.
 4100 //    req, resp := client.DeleteCustomerGatewayRequest(params)
 4101 //
 4102 //    err := req.Send()
 4103 //    if err == nil { // resp is now filled
 4104 //        fmt.Println(resp)
 4105 //    }
 4106 //
 4107 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCustomerGateway
 4108 func (c *EC2) DeleteCustomerGatewayRequest(input *DeleteCustomerGatewayInput) (req *request.Request, output *DeleteCustomerGatewayOutput) {
 4109     op := &request.Operation{
 4110         Name:       opDeleteCustomerGateway,
 4111         HTTPMethod: "POST",
 4112         HTTPPath:   "/",
 4113     }
 4114 
 4115     if input == nil {
 4116         input = &DeleteCustomerGatewayInput{}
 4117     }
 4118 
 4119     output = &DeleteCustomerGatewayOutput{}
 4120     req = c.newRequest(op, input, output)
 4121     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 4122     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 4123     return
 4124 }
 4125 
 4126 // DeleteCustomerGateway API operation for Amazon Elastic Compute Cloud.
 4127 //
 4128 // Deletes the specified customer gateway. You must delete the VPN connection
 4129 // before you can delete the customer gateway.
 4130 //
 4131 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4132 // with awserr.Error's Code and Message methods to get detailed information about
 4133 // the error.
 4134 //
 4135 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4136 // API operation DeleteCustomerGateway for usage and error information.
 4137 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCustomerGateway
 4138 func (c *EC2) DeleteCustomerGateway(input *DeleteCustomerGatewayInput) (*DeleteCustomerGatewayOutput, error) {
 4139     req, out := c.DeleteCustomerGatewayRequest(input)
 4140     err := req.Send()
 4141     return out, err
 4142 }
 4143 
 4144 const opDeleteDhcpOptions = "DeleteDhcpOptions"
 4145 
 4146 // DeleteDhcpOptionsRequest generates a "aws/request.Request" representing the
 4147 // client's request for the DeleteDhcpOptions operation. The "output" return
 4148 // value can be used to capture response data after the request's "Send" method
 4149 // is called.
 4150 //
 4151 // See DeleteDhcpOptions for usage and error information.
 4152 //
 4153 // Creating a request object using this method should be used when you want to inject
 4154 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4155 // access properties on the request object before or after sending the request. If
 4156 // you just want the service response, call the DeleteDhcpOptions method directly
 4157 // instead.
 4158 //
 4159 // Note: You must call the "Send" method on the returned request object in order
 4160 // to execute the request.
 4161 //
 4162 //    // Example sending a request using the DeleteDhcpOptionsRequest method.
 4163 //    req, resp := client.DeleteDhcpOptionsRequest(params)
 4164 //
 4165 //    err := req.Send()
 4166 //    if err == nil { // resp is now filled
 4167 //        fmt.Println(resp)
 4168 //    }
 4169 //
 4170 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteDhcpOptions
 4171 func (c *EC2) DeleteDhcpOptionsRequest(input *DeleteDhcpOptionsInput) (req *request.Request, output *DeleteDhcpOptionsOutput) {
 4172     op := &request.Operation{
 4173         Name:       opDeleteDhcpOptions,
 4174         HTTPMethod: "POST",
 4175         HTTPPath:   "/",
 4176     }
 4177 
 4178     if input == nil {
 4179         input = &DeleteDhcpOptionsInput{}
 4180     }
 4181 
 4182     output = &DeleteDhcpOptionsOutput{}
 4183     req = c.newRequest(op, input, output)
 4184     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 4185     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 4186     return
 4187 }
 4188 
 4189 // DeleteDhcpOptions API operation for Amazon Elastic Compute Cloud.
 4190 //
 4191 // Deletes the specified set of DHCP options. You must disassociate the set
 4192 // of DHCP options before you can delete it. You can disassociate the set of
 4193 // DHCP options by associating either a new set of options or the default set
 4194 // of options with the VPC.
 4195 //
 4196 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4197 // with awserr.Error's Code and Message methods to get detailed information about
 4198 // the error.
 4199 //
 4200 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4201 // API operation DeleteDhcpOptions for usage and error information.
 4202 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteDhcpOptions
 4203 func (c *EC2) DeleteDhcpOptions(input *DeleteDhcpOptionsInput) (*DeleteDhcpOptionsOutput, error) {
 4204     req, out := c.DeleteDhcpOptionsRequest(input)
 4205     err := req.Send()
 4206     return out, err
 4207 }
 4208 
 4209 const opDeleteEgressOnlyInternetGateway = "DeleteEgressOnlyInternetGateway"
 4210 
 4211 // DeleteEgressOnlyInternetGatewayRequest generates a "aws/request.Request" representing the
 4212 // client's request for the DeleteEgressOnlyInternetGateway operation. The "output" return
 4213 // value can be used to capture response data after the request's "Send" method
 4214 // is called.
 4215 //
 4216 // See DeleteEgressOnlyInternetGateway for usage and error information.
 4217 //
 4218 // Creating a request object using this method should be used when you want to inject
 4219 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4220 // access properties on the request object before or after sending the request. If
 4221 // you just want the service response, call the DeleteEgressOnlyInternetGateway method directly
 4222 // instead.
 4223 //
 4224 // Note: You must call the "Send" method on the returned request object in order
 4225 // to execute the request.
 4226 //
 4227 //    // Example sending a request using the DeleteEgressOnlyInternetGatewayRequest method.
 4228 //    req, resp := client.DeleteEgressOnlyInternetGatewayRequest(params)
 4229 //
 4230 //    err := req.Send()
 4231 //    if err == nil { // resp is now filled
 4232 //        fmt.Println(resp)
 4233 //    }
 4234 //
 4235 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteEgressOnlyInternetGateway
 4236 func (c *EC2) DeleteEgressOnlyInternetGatewayRequest(input *DeleteEgressOnlyInternetGatewayInput) (req *request.Request, output *DeleteEgressOnlyInternetGatewayOutput) {
 4237     op := &request.Operation{
 4238         Name:       opDeleteEgressOnlyInternetGateway,
 4239         HTTPMethod: "POST",
 4240         HTTPPath:   "/",
 4241     }
 4242 
 4243     if input == nil {
 4244         input = &DeleteEgressOnlyInternetGatewayInput{}
 4245     }
 4246 
 4247     output = &DeleteEgressOnlyInternetGatewayOutput{}
 4248     req = c.newRequest(op, input, output)
 4249     return
 4250 }
 4251 
 4252 // DeleteEgressOnlyInternetGateway API operation for Amazon Elastic Compute Cloud.
 4253 //
 4254 // Deletes an egress-only Internet gateway.
 4255 //
 4256 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4257 // with awserr.Error's Code and Message methods to get detailed information about
 4258 // the error.
 4259 //
 4260 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4261 // API operation DeleteEgressOnlyInternetGateway for usage and error information.
 4262 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteEgressOnlyInternetGateway
 4263 func (c *EC2) DeleteEgressOnlyInternetGateway(input *DeleteEgressOnlyInternetGatewayInput) (*DeleteEgressOnlyInternetGatewayOutput, error) {
 4264     req, out := c.DeleteEgressOnlyInternetGatewayRequest(input)
 4265     err := req.Send()
 4266     return out, err
 4267 }
 4268 
 4269 const opDeleteFlowLogs = "DeleteFlowLogs"
 4270 
 4271 // DeleteFlowLogsRequest generates a "aws/request.Request" representing the
 4272 // client's request for the DeleteFlowLogs operation. The "output" return
 4273 // value can be used to capture response data after the request's "Send" method
 4274 // is called.
 4275 //
 4276 // See DeleteFlowLogs for usage and error information.
 4277 //
 4278 // Creating a request object using this method should be used when you want to inject
 4279 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4280 // access properties on the request object before or after sending the request. If
 4281 // you just want the service response, call the DeleteFlowLogs method directly
 4282 // instead.
 4283 //
 4284 // Note: You must call the "Send" method on the returned request object in order
 4285 // to execute the request.
 4286 //
 4287 //    // Example sending a request using the DeleteFlowLogsRequest method.
 4288 //    req, resp := client.DeleteFlowLogsRequest(params)
 4289 //
 4290 //    err := req.Send()
 4291 //    if err == nil { // resp is now filled
 4292 //        fmt.Println(resp)
 4293 //    }
 4294 //
 4295 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteFlowLogs
 4296 func (c *EC2) DeleteFlowLogsRequest(input *DeleteFlowLogsInput) (req *request.Request, output *DeleteFlowLogsOutput) {
 4297     op := &request.Operation{
 4298         Name:       opDeleteFlowLogs,
 4299         HTTPMethod: "POST",
 4300         HTTPPath:   "/",
 4301     }
 4302 
 4303     if input == nil {
 4304         input = &DeleteFlowLogsInput{}
 4305     }
 4306 
 4307     output = &DeleteFlowLogsOutput{}
 4308     req = c.newRequest(op, input, output)
 4309     return
 4310 }
 4311 
 4312 // DeleteFlowLogs API operation for Amazon Elastic Compute Cloud.
 4313 //
 4314 // Deletes one or more flow logs.
 4315 //
 4316 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4317 // with awserr.Error's Code and Message methods to get detailed information about
 4318 // the error.
 4319 //
 4320 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4321 // API operation DeleteFlowLogs for usage and error information.
 4322 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteFlowLogs
 4323 func (c *EC2) DeleteFlowLogs(input *DeleteFlowLogsInput) (*DeleteFlowLogsOutput, error) {
 4324     req, out := c.DeleteFlowLogsRequest(input)
 4325     err := req.Send()
 4326     return out, err
 4327 }
 4328 
 4329 const opDeleteInternetGateway = "DeleteInternetGateway"
 4330 
 4331 // DeleteInternetGatewayRequest generates a "aws/request.Request" representing the
 4332 // client's request for the DeleteInternetGateway operation. The "output" return
 4333 // value can be used to capture response data after the request's "Send" method
 4334 // is called.
 4335 //
 4336 // See DeleteInternetGateway for usage and error information.
 4337 //
 4338 // Creating a request object using this method should be used when you want to inject
 4339 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4340 // access properties on the request object before or after sending the request. If
 4341 // you just want the service response, call the DeleteInternetGateway method directly
 4342 // instead.
 4343 //
 4344 // Note: You must call the "Send" method on the returned request object in order
 4345 // to execute the request.
 4346 //
 4347 //    // Example sending a request using the DeleteInternetGatewayRequest method.
 4348 //    req, resp := client.DeleteInternetGatewayRequest(params)
 4349 //
 4350 //    err := req.Send()
 4351 //    if err == nil { // resp is now filled
 4352 //        fmt.Println(resp)
 4353 //    }
 4354 //
 4355 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteInternetGateway
 4356 func (c *EC2) DeleteInternetGatewayRequest(input *DeleteInternetGatewayInput) (req *request.Request, output *DeleteInternetGatewayOutput) {
 4357     op := &request.Operation{
 4358         Name:       opDeleteInternetGateway,
 4359         HTTPMethod: "POST",
 4360         HTTPPath:   "/",
 4361     }
 4362 
 4363     if input == nil {
 4364         input = &DeleteInternetGatewayInput{}
 4365     }
 4366 
 4367     output = &DeleteInternetGatewayOutput{}
 4368     req = c.newRequest(op, input, output)
 4369     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 4370     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 4371     return
 4372 }
 4373 
 4374 // DeleteInternetGateway API operation for Amazon Elastic Compute Cloud.
 4375 //
 4376 // Deletes the specified Internet gateway. You must detach the Internet gateway
 4377 // from the VPC before you can delete it.
 4378 //
 4379 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4380 // with awserr.Error's Code and Message methods to get detailed information about
 4381 // the error.
 4382 //
 4383 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4384 // API operation DeleteInternetGateway for usage and error information.
 4385 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteInternetGateway
 4386 func (c *EC2) DeleteInternetGateway(input *DeleteInternetGatewayInput) (*DeleteInternetGatewayOutput, error) {
 4387     req, out := c.DeleteInternetGatewayRequest(input)
 4388     err := req.Send()
 4389     return out, err
 4390 }
 4391 
 4392 const opDeleteKeyPair = "DeleteKeyPair"
 4393 
 4394 // DeleteKeyPairRequest generates a "aws/request.Request" representing the
 4395 // client's request for the DeleteKeyPair operation. The "output" return
 4396 // value can be used to capture response data after the request's "Send" method
 4397 // is called.
 4398 //
 4399 // See DeleteKeyPair for usage and error information.
 4400 //
 4401 // Creating a request object using this method should be used when you want to inject
 4402 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4403 // access properties on the request object before or after sending the request. If
 4404 // you just want the service response, call the DeleteKeyPair method directly
 4405 // instead.
 4406 //
 4407 // Note: You must call the "Send" method on the returned request object in order
 4408 // to execute the request.
 4409 //
 4410 //    // Example sending a request using the DeleteKeyPairRequest method.
 4411 //    req, resp := client.DeleteKeyPairRequest(params)
 4412 //
 4413 //    err := req.Send()
 4414 //    if err == nil { // resp is now filled
 4415 //        fmt.Println(resp)
 4416 //    }
 4417 //
 4418 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteKeyPair
 4419 func (c *EC2) DeleteKeyPairRequest(input *DeleteKeyPairInput) (req *request.Request, output *DeleteKeyPairOutput) {
 4420     op := &request.Operation{
 4421         Name:       opDeleteKeyPair,
 4422         HTTPMethod: "POST",
 4423         HTTPPath:   "/",
 4424     }
 4425 
 4426     if input == nil {
 4427         input = &DeleteKeyPairInput{}
 4428     }
 4429 
 4430     output = &DeleteKeyPairOutput{}
 4431     req = c.newRequest(op, input, output)
 4432     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 4433     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 4434     return
 4435 }
 4436 
 4437 // DeleteKeyPair API operation for Amazon Elastic Compute Cloud.
 4438 //
 4439 // Deletes the specified key pair, by removing the public key from Amazon EC2.
 4440 //
 4441 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4442 // with awserr.Error's Code and Message methods to get detailed information about
 4443 // the error.
 4444 //
 4445 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4446 // API operation DeleteKeyPair for usage and error information.
 4447 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteKeyPair
 4448 func (c *EC2) DeleteKeyPair(input *DeleteKeyPairInput) (*DeleteKeyPairOutput, error) {
 4449     req, out := c.DeleteKeyPairRequest(input)
 4450     err := req.Send()
 4451     return out, err
 4452 }
 4453 
 4454 const opDeleteNatGateway = "DeleteNatGateway"
 4455 
 4456 // DeleteNatGatewayRequest generates a "aws/request.Request" representing the
 4457 // client's request for the DeleteNatGateway operation. The "output" return
 4458 // value can be used to capture response data after the request's "Send" method
 4459 // is called.
 4460 //
 4461 // See DeleteNatGateway for usage and error information.
 4462 //
 4463 // Creating a request object using this method should be used when you want to inject
 4464 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4465 // access properties on the request object before or after sending the request. If
 4466 // you just want the service response, call the DeleteNatGateway method directly
 4467 // instead.
 4468 //
 4469 // Note: You must call the "Send" method on the returned request object in order
 4470 // to execute the request.
 4471 //
 4472 //    // Example sending a request using the DeleteNatGatewayRequest method.
 4473 //    req, resp := client.DeleteNatGatewayRequest(params)
 4474 //
 4475 //    err := req.Send()
 4476 //    if err == nil { // resp is now filled
 4477 //        fmt.Println(resp)
 4478 //    }
 4479 //
 4480 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNatGateway
 4481 func (c *EC2) DeleteNatGatewayRequest(input *DeleteNatGatewayInput) (req *request.Request, output *DeleteNatGatewayOutput) {
 4482     op := &request.Operation{
 4483         Name:       opDeleteNatGateway,
 4484         HTTPMethod: "POST",
 4485         HTTPPath:   "/",
 4486     }
 4487 
 4488     if input == nil {
 4489         input = &DeleteNatGatewayInput{}
 4490     }
 4491 
 4492     output = &DeleteNatGatewayOutput{}
 4493     req = c.newRequest(op, input, output)
 4494     return
 4495 }
 4496 
 4497 // DeleteNatGateway API operation for Amazon Elastic Compute Cloud.
 4498 //
 4499 // Deletes the specified NAT gateway. Deleting a NAT gateway disassociates its
 4500 // Elastic IP address, but does not release the address from your account. Deleting
 4501 // a NAT gateway does not delete any NAT gateway routes in your route tables.
 4502 //
 4503 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4504 // with awserr.Error's Code and Message methods to get detailed information about
 4505 // the error.
 4506 //
 4507 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4508 // API operation DeleteNatGateway for usage and error information.
 4509 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNatGateway
 4510 func (c *EC2) DeleteNatGateway(input *DeleteNatGatewayInput) (*DeleteNatGatewayOutput, error) {
 4511     req, out := c.DeleteNatGatewayRequest(input)
 4512     err := req.Send()
 4513     return out, err
 4514 }
 4515 
 4516 const opDeleteNetworkAcl = "DeleteNetworkAcl"
 4517 
 4518 // DeleteNetworkAclRequest generates a "aws/request.Request" representing the
 4519 // client's request for the DeleteNetworkAcl operation. The "output" return
 4520 // value can be used to capture response data after the request's "Send" method
 4521 // is called.
 4522 //
 4523 // See DeleteNetworkAcl for usage and error information.
 4524 //
 4525 // Creating a request object using this method should be used when you want to inject
 4526 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4527 // access properties on the request object before or after sending the request. If
 4528 // you just want the service response, call the DeleteNetworkAcl method directly
 4529 // instead.
 4530 //
 4531 // Note: You must call the "Send" method on the returned request object in order
 4532 // to execute the request.
 4533 //
 4534 //    // Example sending a request using the DeleteNetworkAclRequest method.
 4535 //    req, resp := client.DeleteNetworkAclRequest(params)
 4536 //
 4537 //    err := req.Send()
 4538 //    if err == nil { // resp is now filled
 4539 //        fmt.Println(resp)
 4540 //    }
 4541 //
 4542 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkAcl
 4543 func (c *EC2) DeleteNetworkAclRequest(input *DeleteNetworkAclInput) (req *request.Request, output *DeleteNetworkAclOutput) {
 4544     op := &request.Operation{
 4545         Name:       opDeleteNetworkAcl,
 4546         HTTPMethod: "POST",
 4547         HTTPPath:   "/",
 4548     }
 4549 
 4550     if input == nil {
 4551         input = &DeleteNetworkAclInput{}
 4552     }
 4553 
 4554     output = &DeleteNetworkAclOutput{}
 4555     req = c.newRequest(op, input, output)
 4556     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 4557     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 4558     return
 4559 }
 4560 
 4561 // DeleteNetworkAcl API operation for Amazon Elastic Compute Cloud.
 4562 //
 4563 // Deletes the specified network ACL. You can't delete the ACL if it's associated
 4564 // with any subnets. You can't delete the default network ACL.
 4565 //
 4566 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4567 // with awserr.Error's Code and Message methods to get detailed information about
 4568 // the error.
 4569 //
 4570 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4571 // API operation DeleteNetworkAcl for usage and error information.
 4572 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkAcl
 4573 func (c *EC2) DeleteNetworkAcl(input *DeleteNetworkAclInput) (*DeleteNetworkAclOutput, error) {
 4574     req, out := c.DeleteNetworkAclRequest(input)
 4575     err := req.Send()
 4576     return out, err
 4577 }
 4578 
 4579 const opDeleteNetworkAclEntry = "DeleteNetworkAclEntry"
 4580 
 4581 // DeleteNetworkAclEntryRequest generates a "aws/request.Request" representing the
 4582 // client's request for the DeleteNetworkAclEntry operation. The "output" return
 4583 // value can be used to capture response data after the request's "Send" method
 4584 // is called.
 4585 //
 4586 // See DeleteNetworkAclEntry for usage and error information.
 4587 //
 4588 // Creating a request object using this method should be used when you want to inject
 4589 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4590 // access properties on the request object before or after sending the request. If
 4591 // you just want the service response, call the DeleteNetworkAclEntry method directly
 4592 // instead.
 4593 //
 4594 // Note: You must call the "Send" method on the returned request object in order
 4595 // to execute the request.
 4596 //
 4597 //    // Example sending a request using the DeleteNetworkAclEntryRequest method.
 4598 //    req, resp := client.DeleteNetworkAclEntryRequest(params)
 4599 //
 4600 //    err := req.Send()
 4601 //    if err == nil { // resp is now filled
 4602 //        fmt.Println(resp)
 4603 //    }
 4604 //
 4605 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkAclEntry
 4606 func (c *EC2) DeleteNetworkAclEntryRequest(input *DeleteNetworkAclEntryInput) (req *request.Request, output *DeleteNetworkAclEntryOutput) {
 4607     op := &request.Operation{
 4608         Name:       opDeleteNetworkAclEntry,
 4609         HTTPMethod: "POST",
 4610         HTTPPath:   "/",
 4611     }
 4612 
 4613     if input == nil {
 4614         input = &DeleteNetworkAclEntryInput{}
 4615     }
 4616 
 4617     output = &DeleteNetworkAclEntryOutput{}
 4618     req = c.newRequest(op, input, output)
 4619     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 4620     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 4621     return
 4622 }
 4623 
 4624 // DeleteNetworkAclEntry API operation for Amazon Elastic Compute Cloud.
 4625 //
 4626 // Deletes the specified ingress or egress entry (rule) from the specified network
 4627 // ACL.
 4628 //
 4629 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4630 // with awserr.Error's Code and Message methods to get detailed information about
 4631 // the error.
 4632 //
 4633 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4634 // API operation DeleteNetworkAclEntry for usage and error information.
 4635 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkAclEntry
 4636 func (c *EC2) DeleteNetworkAclEntry(input *DeleteNetworkAclEntryInput) (*DeleteNetworkAclEntryOutput, error) {
 4637     req, out := c.DeleteNetworkAclEntryRequest(input)
 4638     err := req.Send()
 4639     return out, err
 4640 }
 4641 
 4642 const opDeleteNetworkInterface = "DeleteNetworkInterface"
 4643 
 4644 // DeleteNetworkInterfaceRequest generates a "aws/request.Request" representing the
 4645 // client's request for the DeleteNetworkInterface operation. The "output" return
 4646 // value can be used to capture response data after the request's "Send" method
 4647 // is called.
 4648 //
 4649 // See DeleteNetworkInterface for usage and error information.
 4650 //
 4651 // Creating a request object using this method should be used when you want to inject
 4652 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4653 // access properties on the request object before or after sending the request. If
 4654 // you just want the service response, call the DeleteNetworkInterface method directly
 4655 // instead.
 4656 //
 4657 // Note: You must call the "Send" method on the returned request object in order
 4658 // to execute the request.
 4659 //
 4660 //    // Example sending a request using the DeleteNetworkInterfaceRequest method.
 4661 //    req, resp := client.DeleteNetworkInterfaceRequest(params)
 4662 //
 4663 //    err := req.Send()
 4664 //    if err == nil { // resp is now filled
 4665 //        fmt.Println(resp)
 4666 //    }
 4667 //
 4668 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInterface
 4669 func (c *EC2) DeleteNetworkInterfaceRequest(input *DeleteNetworkInterfaceInput) (req *request.Request, output *DeleteNetworkInterfaceOutput) {
 4670     op := &request.Operation{
 4671         Name:       opDeleteNetworkInterface,
 4672         HTTPMethod: "POST",
 4673         HTTPPath:   "/",
 4674     }
 4675 
 4676     if input == nil {
 4677         input = &DeleteNetworkInterfaceInput{}
 4678     }
 4679 
 4680     output = &DeleteNetworkInterfaceOutput{}
 4681     req = c.newRequest(op, input, output)
 4682     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 4683     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 4684     return
 4685 }
 4686 
 4687 // DeleteNetworkInterface API operation for Amazon Elastic Compute Cloud.
 4688 //
 4689 // Deletes the specified network interface. You must detach the network interface
 4690 // before you can delete it.
 4691 //
 4692 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4693 // with awserr.Error's Code and Message methods to get detailed information about
 4694 // the error.
 4695 //
 4696 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4697 // API operation DeleteNetworkInterface for usage and error information.
 4698 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInterface
 4699 func (c *EC2) DeleteNetworkInterface(input *DeleteNetworkInterfaceInput) (*DeleteNetworkInterfaceOutput, error) {
 4700     req, out := c.DeleteNetworkInterfaceRequest(input)
 4701     err := req.Send()
 4702     return out, err
 4703 }
 4704 
 4705 const opDeletePlacementGroup = "DeletePlacementGroup"
 4706 
 4707 // DeletePlacementGroupRequest generates a "aws/request.Request" representing the
 4708 // client's request for the DeletePlacementGroup operation. The "output" return
 4709 // value can be used to capture response data after the request's "Send" method
 4710 // is called.
 4711 //
 4712 // See DeletePlacementGroup for usage and error information.
 4713 //
 4714 // Creating a request object using this method should be used when you want to inject
 4715 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4716 // access properties on the request object before or after sending the request. If
 4717 // you just want the service response, call the DeletePlacementGroup method directly
 4718 // instead.
 4719 //
 4720 // Note: You must call the "Send" method on the returned request object in order
 4721 // to execute the request.
 4722 //
 4723 //    // Example sending a request using the DeletePlacementGroupRequest method.
 4724 //    req, resp := client.DeletePlacementGroupRequest(params)
 4725 //
 4726 //    err := req.Send()
 4727 //    if err == nil { // resp is now filled
 4728 //        fmt.Println(resp)
 4729 //    }
 4730 //
 4731 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeletePlacementGroup
 4732 func (c *EC2) DeletePlacementGroupRequest(input *DeletePlacementGroupInput) (req *request.Request, output *DeletePlacementGroupOutput) {
 4733     op := &request.Operation{
 4734         Name:       opDeletePlacementGroup,
 4735         HTTPMethod: "POST",
 4736         HTTPPath:   "/",
 4737     }
 4738 
 4739     if input == nil {
 4740         input = &DeletePlacementGroupInput{}
 4741     }
 4742 
 4743     output = &DeletePlacementGroupOutput{}
 4744     req = c.newRequest(op, input, output)
 4745     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 4746     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 4747     return
 4748 }
 4749 
 4750 // DeletePlacementGroup API operation for Amazon Elastic Compute Cloud.
 4751 //
 4752 // Deletes the specified placement group. You must terminate all instances in
 4753 // the placement group before you can delete the placement group. For more information
 4754 // about placement groups and cluster instances, see Cluster Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using_cluster_computing.html)
 4755 // in the Amazon Elastic Compute Cloud User Guide.
 4756 //
 4757 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4758 // with awserr.Error's Code and Message methods to get detailed information about
 4759 // the error.
 4760 //
 4761 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4762 // API operation DeletePlacementGroup for usage and error information.
 4763 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeletePlacementGroup
 4764 func (c *EC2) DeletePlacementGroup(input *DeletePlacementGroupInput) (*DeletePlacementGroupOutput, error) {
 4765     req, out := c.DeletePlacementGroupRequest(input)
 4766     err := req.Send()
 4767     return out, err
 4768 }
 4769 
 4770 const opDeleteRoute = "DeleteRoute"
 4771 
 4772 // DeleteRouteRequest generates a "aws/request.Request" representing the
 4773 // client's request for the DeleteRoute operation. The "output" return
 4774 // value can be used to capture response data after the request's "Send" method
 4775 // is called.
 4776 //
 4777 // See DeleteRoute for usage and error information.
 4778 //
 4779 // Creating a request object using this method should be used when you want to inject
 4780 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4781 // access properties on the request object before or after sending the request. If
 4782 // you just want the service response, call the DeleteRoute method directly
 4783 // instead.
 4784 //
 4785 // Note: You must call the "Send" method on the returned request object in order
 4786 // to execute the request.
 4787 //
 4788 //    // Example sending a request using the DeleteRouteRequest method.
 4789 //    req, resp := client.DeleteRouteRequest(params)
 4790 //
 4791 //    err := req.Send()
 4792 //    if err == nil { // resp is now filled
 4793 //        fmt.Println(resp)
 4794 //    }
 4795 //
 4796 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRoute
 4797 func (c *EC2) DeleteRouteRequest(input *DeleteRouteInput) (req *request.Request, output *DeleteRouteOutput) {
 4798     op := &request.Operation{
 4799         Name:       opDeleteRoute,
 4800         HTTPMethod: "POST",
 4801         HTTPPath:   "/",
 4802     }
 4803 
 4804     if input == nil {
 4805         input = &DeleteRouteInput{}
 4806     }
 4807 
 4808     output = &DeleteRouteOutput{}
 4809     req = c.newRequest(op, input, output)
 4810     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 4811     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 4812     return
 4813 }
 4814 
 4815 // DeleteRoute API operation for Amazon Elastic Compute Cloud.
 4816 //
 4817 // Deletes the specified route from the specified route table.
 4818 //
 4819 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4820 // with awserr.Error's Code and Message methods to get detailed information about
 4821 // the error.
 4822 //
 4823 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4824 // API operation DeleteRoute for usage and error information.
 4825 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRoute
 4826 func (c *EC2) DeleteRoute(input *DeleteRouteInput) (*DeleteRouteOutput, error) {
 4827     req, out := c.DeleteRouteRequest(input)
 4828     err := req.Send()
 4829     return out, err
 4830 }
 4831 
 4832 const opDeleteRouteTable = "DeleteRouteTable"
 4833 
 4834 // DeleteRouteTableRequest generates a "aws/request.Request" representing the
 4835 // client's request for the DeleteRouteTable operation. The "output" return
 4836 // value can be used to capture response data after the request's "Send" method
 4837 // is called.
 4838 //
 4839 // See DeleteRouteTable for usage and error information.
 4840 //
 4841 // Creating a request object using this method should be used when you want to inject
 4842 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4843 // access properties on the request object before or after sending the request. If
 4844 // you just want the service response, call the DeleteRouteTable method directly
 4845 // instead.
 4846 //
 4847 // Note: You must call the "Send" method on the returned request object in order
 4848 // to execute the request.
 4849 //
 4850 //    // Example sending a request using the DeleteRouteTableRequest method.
 4851 //    req, resp := client.DeleteRouteTableRequest(params)
 4852 //
 4853 //    err := req.Send()
 4854 //    if err == nil { // resp is now filled
 4855 //        fmt.Println(resp)
 4856 //    }
 4857 //
 4858 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRouteTable
 4859 func (c *EC2) DeleteRouteTableRequest(input *DeleteRouteTableInput) (req *request.Request, output *DeleteRouteTableOutput) {
 4860     op := &request.Operation{
 4861         Name:       opDeleteRouteTable,
 4862         HTTPMethod: "POST",
 4863         HTTPPath:   "/",
 4864     }
 4865 
 4866     if input == nil {
 4867         input = &DeleteRouteTableInput{}
 4868     }
 4869 
 4870     output = &DeleteRouteTableOutput{}
 4871     req = c.newRequest(op, input, output)
 4872     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 4873     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 4874     return
 4875 }
 4876 
 4877 // DeleteRouteTable API operation for Amazon Elastic Compute Cloud.
 4878 //
 4879 // Deletes the specified route table. You must disassociate the route table
 4880 // from any subnets before you can delete it. You can't delete the main route
 4881 // table.
 4882 //
 4883 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4884 // with awserr.Error's Code and Message methods to get detailed information about
 4885 // the error.
 4886 //
 4887 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4888 // API operation DeleteRouteTable for usage and error information.
 4889 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRouteTable
 4890 func (c *EC2) DeleteRouteTable(input *DeleteRouteTableInput) (*DeleteRouteTableOutput, error) {
 4891     req, out := c.DeleteRouteTableRequest(input)
 4892     err := req.Send()
 4893     return out, err
 4894 }
 4895 
 4896 const opDeleteSecurityGroup = "DeleteSecurityGroup"
 4897 
 4898 // DeleteSecurityGroupRequest generates a "aws/request.Request" representing the
 4899 // client's request for the DeleteSecurityGroup operation. The "output" return
 4900 // value can be used to capture response data after the request's "Send" method
 4901 // is called.
 4902 //
 4903 // See DeleteSecurityGroup for usage and error information.
 4904 //
 4905 // Creating a request object using this method should be used when you want to inject
 4906 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4907 // access properties on the request object before or after sending the request. If
 4908 // you just want the service response, call the DeleteSecurityGroup method directly
 4909 // instead.
 4910 //
 4911 // Note: You must call the "Send" method on the returned request object in order
 4912 // to execute the request.
 4913 //
 4914 //    // Example sending a request using the DeleteSecurityGroupRequest method.
 4915 //    req, resp := client.DeleteSecurityGroupRequest(params)
 4916 //
 4917 //    err := req.Send()
 4918 //    if err == nil { // resp is now filled
 4919 //        fmt.Println(resp)
 4920 //    }
 4921 //
 4922 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSecurityGroup
 4923 func (c *EC2) DeleteSecurityGroupRequest(input *DeleteSecurityGroupInput) (req *request.Request, output *DeleteSecurityGroupOutput) {
 4924     op := &request.Operation{
 4925         Name:       opDeleteSecurityGroup,
 4926         HTTPMethod: "POST",
 4927         HTTPPath:   "/",
 4928     }
 4929 
 4930     if input == nil {
 4931         input = &DeleteSecurityGroupInput{}
 4932     }
 4933 
 4934     output = &DeleteSecurityGroupOutput{}
 4935     req = c.newRequest(op, input, output)
 4936     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 4937     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 4938     return
 4939 }
 4940 
 4941 // DeleteSecurityGroup API operation for Amazon Elastic Compute Cloud.
 4942 //
 4943 // Deletes a security group.
 4944 //
 4945 // If you attempt to delete a security group that is associated with an instance,
 4946 // or is referenced by another security group, the operation fails with InvalidGroup.InUse
 4947 // in EC2-Classic or DependencyViolation in EC2-VPC.
 4948 //
 4949 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 4950 // with awserr.Error's Code and Message methods to get detailed information about
 4951 // the error.
 4952 //
 4953 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 4954 // API operation DeleteSecurityGroup for usage and error information.
 4955 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSecurityGroup
 4956 func (c *EC2) DeleteSecurityGroup(input *DeleteSecurityGroupInput) (*DeleteSecurityGroupOutput, error) {
 4957     req, out := c.DeleteSecurityGroupRequest(input)
 4958     err := req.Send()
 4959     return out, err
 4960 }
 4961 
 4962 const opDeleteSnapshot = "DeleteSnapshot"
 4963 
 4964 // DeleteSnapshotRequest generates a "aws/request.Request" representing the
 4965 // client's request for the DeleteSnapshot operation. The "output" return
 4966 // value can be used to capture response data after the request's "Send" method
 4967 // is called.
 4968 //
 4969 // See DeleteSnapshot for usage and error information.
 4970 //
 4971 // Creating a request object using this method should be used when you want to inject
 4972 // custom logic into the request's lifecycle using a custom handler, or if you want to
 4973 // access properties on the request object before or after sending the request. If
 4974 // you just want the service response, call the DeleteSnapshot method directly
 4975 // instead.
 4976 //
 4977 // Note: You must call the "Send" method on the returned request object in order
 4978 // to execute the request.
 4979 //
 4980 //    // Example sending a request using the DeleteSnapshotRequest method.
 4981 //    req, resp := client.DeleteSnapshotRequest(params)
 4982 //
 4983 //    err := req.Send()
 4984 //    if err == nil { // resp is now filled
 4985 //        fmt.Println(resp)
 4986 //    }
 4987 //
 4988 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSnapshot
 4989 func (c *EC2) DeleteSnapshotRequest(input *DeleteSnapshotInput) (req *request.Request, output *DeleteSnapshotOutput) {
 4990     op := &request.Operation{
 4991         Name:       opDeleteSnapshot,
 4992         HTTPMethod: "POST",
 4993         HTTPPath:   "/",
 4994     }
 4995 
 4996     if input == nil {
 4997         input = &DeleteSnapshotInput{}
 4998     }
 4999 
 5000     output = &DeleteSnapshotOutput{}
 5001     req = c.newRequest(op, input, output)
 5002     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 5003     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 5004     return
 5005 }
 5006 
 5007 // DeleteSnapshot API operation for Amazon Elastic Compute Cloud.
 5008 //
 5009 // Deletes the specified snapshot.
 5010 //
 5011 // When you make periodic snapshots of a volume, the snapshots are incremental,
 5012 // and only the blocks on the device that have changed since your last snapshot
 5013 // are saved in the new snapshot. When you delete a snapshot, only the data
 5014 // not needed for any other snapshot is removed. So regardless of which prior
 5015 // snapshots have been deleted, all active snapshots will have access to all
 5016 // the information needed to restore the volume.
 5017 //
 5018 // You cannot delete a snapshot of the root device of an EBS volume used by
 5019 // a registered AMI. You must first de-register the AMI before you can delete
 5020 // the snapshot.
 5021 //
 5022 // For more information, see Deleting an Amazon EBS Snapshot (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-deleting-snapshot.html)
 5023 // in the Amazon Elastic Compute Cloud User Guide.
 5024 //
 5025 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5026 // with awserr.Error's Code and Message methods to get detailed information about
 5027 // the error.
 5028 //
 5029 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5030 // API operation DeleteSnapshot for usage and error information.
 5031 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSnapshot
 5032 func (c *EC2) DeleteSnapshot(input *DeleteSnapshotInput) (*DeleteSnapshotOutput, error) {
 5033     req, out := c.DeleteSnapshotRequest(input)
 5034     err := req.Send()
 5035     return out, err
 5036 }
 5037 
 5038 const opDeleteSpotDatafeedSubscription = "DeleteSpotDatafeedSubscription"
 5039 
 5040 // DeleteSpotDatafeedSubscriptionRequest generates a "aws/request.Request" representing the
 5041 // client's request for the DeleteSpotDatafeedSubscription operation. The "output" return
 5042 // value can be used to capture response data after the request's "Send" method
 5043 // is called.
 5044 //
 5045 // See DeleteSpotDatafeedSubscription for usage and error information.
 5046 //
 5047 // Creating a request object using this method should be used when you want to inject
 5048 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5049 // access properties on the request object before or after sending the request. If
 5050 // you just want the service response, call the DeleteSpotDatafeedSubscription method directly
 5051 // instead.
 5052 //
 5053 // Note: You must call the "Send" method on the returned request object in order
 5054 // to execute the request.
 5055 //
 5056 //    // Example sending a request using the DeleteSpotDatafeedSubscriptionRequest method.
 5057 //    req, resp := client.DeleteSpotDatafeedSubscriptionRequest(params)
 5058 //
 5059 //    err := req.Send()
 5060 //    if err == nil { // resp is now filled
 5061 //        fmt.Println(resp)
 5062 //    }
 5063 //
 5064 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSpotDatafeedSubscription
 5065 func (c *EC2) DeleteSpotDatafeedSubscriptionRequest(input *DeleteSpotDatafeedSubscriptionInput) (req *request.Request, output *DeleteSpotDatafeedSubscriptionOutput) {
 5066     op := &request.Operation{
 5067         Name:       opDeleteSpotDatafeedSubscription,
 5068         HTTPMethod: "POST",
 5069         HTTPPath:   "/",
 5070     }
 5071 
 5072     if input == nil {
 5073         input = &DeleteSpotDatafeedSubscriptionInput{}
 5074     }
 5075 
 5076     output = &DeleteSpotDatafeedSubscriptionOutput{}
 5077     req = c.newRequest(op, input, output)
 5078     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 5079     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 5080     return
 5081 }
 5082 
 5083 // DeleteSpotDatafeedSubscription API operation for Amazon Elastic Compute Cloud.
 5084 //
 5085 // Deletes the data feed for Spot instances.
 5086 //
 5087 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5088 // with awserr.Error's Code and Message methods to get detailed information about
 5089 // the error.
 5090 //
 5091 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5092 // API operation DeleteSpotDatafeedSubscription for usage and error information.
 5093 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSpotDatafeedSubscription
 5094 func (c *EC2) DeleteSpotDatafeedSubscription(input *DeleteSpotDatafeedSubscriptionInput) (*DeleteSpotDatafeedSubscriptionOutput, error) {
 5095     req, out := c.DeleteSpotDatafeedSubscriptionRequest(input)
 5096     err := req.Send()
 5097     return out, err
 5098 }
 5099 
 5100 const opDeleteSubnet = "DeleteSubnet"
 5101 
 5102 // DeleteSubnetRequest generates a "aws/request.Request" representing the
 5103 // client's request for the DeleteSubnet operation. The "output" return
 5104 // value can be used to capture response data after the request's "Send" method
 5105 // is called.
 5106 //
 5107 // See DeleteSubnet for usage and error information.
 5108 //
 5109 // Creating a request object using this method should be used when you want to inject
 5110 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5111 // access properties on the request object before or after sending the request. If
 5112 // you just want the service response, call the DeleteSubnet method directly
 5113 // instead.
 5114 //
 5115 // Note: You must call the "Send" method on the returned request object in order
 5116 // to execute the request.
 5117 //
 5118 //    // Example sending a request using the DeleteSubnetRequest method.
 5119 //    req, resp := client.DeleteSubnetRequest(params)
 5120 //
 5121 //    err := req.Send()
 5122 //    if err == nil { // resp is now filled
 5123 //        fmt.Println(resp)
 5124 //    }
 5125 //
 5126 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSubnet
 5127 func (c *EC2) DeleteSubnetRequest(input *DeleteSubnetInput) (req *request.Request, output *DeleteSubnetOutput) {
 5128     op := &request.Operation{
 5129         Name:       opDeleteSubnet,
 5130         HTTPMethod: "POST",
 5131         HTTPPath:   "/",
 5132     }
 5133 
 5134     if input == nil {
 5135         input = &DeleteSubnetInput{}
 5136     }
 5137 
 5138     output = &DeleteSubnetOutput{}
 5139     req = c.newRequest(op, input, output)
 5140     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 5141     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 5142     return
 5143 }
 5144 
 5145 // DeleteSubnet API operation for Amazon Elastic Compute Cloud.
 5146 //
 5147 // Deletes the specified subnet. You must terminate all running instances in
 5148 // the subnet before you can delete the subnet.
 5149 //
 5150 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5151 // with awserr.Error's Code and Message methods to get detailed information about
 5152 // the error.
 5153 //
 5154 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5155 // API operation DeleteSubnet for usage and error information.
 5156 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSubnet
 5157 func (c *EC2) DeleteSubnet(input *DeleteSubnetInput) (*DeleteSubnetOutput, error) {
 5158     req, out := c.DeleteSubnetRequest(input)
 5159     err := req.Send()
 5160     return out, err
 5161 }
 5162 
 5163 const opDeleteTags = "DeleteTags"
 5164 
 5165 // DeleteTagsRequest generates a "aws/request.Request" representing the
 5166 // client's request for the DeleteTags operation. The "output" return
 5167 // value can be used to capture response data after the request's "Send" method
 5168 // is called.
 5169 //
 5170 // See DeleteTags for usage and error information.
 5171 //
 5172 // Creating a request object using this method should be used when you want to inject
 5173 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5174 // access properties on the request object before or after sending the request. If
 5175 // you just want the service response, call the DeleteTags method directly
 5176 // instead.
 5177 //
 5178 // Note: You must call the "Send" method on the returned request object in order
 5179 // to execute the request.
 5180 //
 5181 //    // Example sending a request using the DeleteTagsRequest method.
 5182 //    req, resp := client.DeleteTagsRequest(params)
 5183 //
 5184 //    err := req.Send()
 5185 //    if err == nil { // resp is now filled
 5186 //        fmt.Println(resp)
 5187 //    }
 5188 //
 5189 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTags
 5190 func (c *EC2) DeleteTagsRequest(input *DeleteTagsInput) (req *request.Request, output *DeleteTagsOutput) {
 5191     op := &request.Operation{
 5192         Name:       opDeleteTags,
 5193         HTTPMethod: "POST",
 5194         HTTPPath:   "/",
 5195     }
 5196 
 5197     if input == nil {
 5198         input = &DeleteTagsInput{}
 5199     }
 5200 
 5201     output = &DeleteTagsOutput{}
 5202     req = c.newRequest(op, input, output)
 5203     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 5204     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 5205     return
 5206 }
 5207 
 5208 // DeleteTags API operation for Amazon Elastic Compute Cloud.
 5209 //
 5210 // Deletes the specified set of tags from the specified set of resources. This
 5211 // call is designed to follow a DescribeTags request.
 5212 //
 5213 // For more information about tags, see Tagging Your Resources (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html)
 5214 // in the Amazon Elastic Compute Cloud User Guide.
 5215 //
 5216 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5217 // with awserr.Error's Code and Message methods to get detailed information about
 5218 // the error.
 5219 //
 5220 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5221 // API operation DeleteTags for usage and error information.
 5222 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTags
 5223 func (c *EC2) DeleteTags(input *DeleteTagsInput) (*DeleteTagsOutput, error) {
 5224     req, out := c.DeleteTagsRequest(input)
 5225     err := req.Send()
 5226     return out, err
 5227 }
 5228 
 5229 const opDeleteVolume = "DeleteVolume"
 5230 
 5231 // DeleteVolumeRequest generates a "aws/request.Request" representing the
 5232 // client's request for the DeleteVolume operation. The "output" return
 5233 // value can be used to capture response data after the request's "Send" method
 5234 // is called.
 5235 //
 5236 // See DeleteVolume for usage and error information.
 5237 //
 5238 // Creating a request object using this method should be used when you want to inject
 5239 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5240 // access properties on the request object before or after sending the request. If
 5241 // you just want the service response, call the DeleteVolume method directly
 5242 // instead.
 5243 //
 5244 // Note: You must call the "Send" method on the returned request object in order
 5245 // to execute the request.
 5246 //
 5247 //    // Example sending a request using the DeleteVolumeRequest method.
 5248 //    req, resp := client.DeleteVolumeRequest(params)
 5249 //
 5250 //    err := req.Send()
 5251 //    if err == nil { // resp is now filled
 5252 //        fmt.Println(resp)
 5253 //    }
 5254 //
 5255 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVolume
 5256 func (c *EC2) DeleteVolumeRequest(input *DeleteVolumeInput) (req *request.Request, output *DeleteVolumeOutput) {
 5257     op := &request.Operation{
 5258         Name:       opDeleteVolume,
 5259         HTTPMethod: "POST",
 5260         HTTPPath:   "/",
 5261     }
 5262 
 5263     if input == nil {
 5264         input = &DeleteVolumeInput{}
 5265     }
 5266 
 5267     output = &DeleteVolumeOutput{}
 5268     req = c.newRequest(op, input, output)
 5269     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 5270     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 5271     return
 5272 }
 5273 
 5274 // DeleteVolume API operation for Amazon Elastic Compute Cloud.
 5275 //
 5276 // Deletes the specified EBS volume. The volume must be in the available state
 5277 // (not attached to an instance).
 5278 //
 5279 // The volume may remain in the deleting state for several minutes.
 5280 //
 5281 // For more information, see Deleting an Amazon EBS Volume (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-deleting-volume.html)
 5282 // in the Amazon Elastic Compute Cloud User Guide.
 5283 //
 5284 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5285 // with awserr.Error's Code and Message methods to get detailed information about
 5286 // the error.
 5287 //
 5288 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5289 // API operation DeleteVolume for usage and error information.
 5290 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVolume
 5291 func (c *EC2) DeleteVolume(input *DeleteVolumeInput) (*DeleteVolumeOutput, error) {
 5292     req, out := c.DeleteVolumeRequest(input)
 5293     err := req.Send()
 5294     return out, err
 5295 }
 5296 
 5297 const opDeleteVpc = "DeleteVpc"
 5298 
 5299 // DeleteVpcRequest generates a "aws/request.Request" representing the
 5300 // client's request for the DeleteVpc operation. The "output" return
 5301 // value can be used to capture response data after the request's "Send" method
 5302 // is called.
 5303 //
 5304 // See DeleteVpc for usage and error information.
 5305 //
 5306 // Creating a request object using this method should be used when you want to inject
 5307 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5308 // access properties on the request object before or after sending the request. If
 5309 // you just want the service response, call the DeleteVpc method directly
 5310 // instead.
 5311 //
 5312 // Note: You must call the "Send" method on the returned request object in order
 5313 // to execute the request.
 5314 //
 5315 //    // Example sending a request using the DeleteVpcRequest method.
 5316 //    req, resp := client.DeleteVpcRequest(params)
 5317 //
 5318 //    err := req.Send()
 5319 //    if err == nil { // resp is now filled
 5320 //        fmt.Println(resp)
 5321 //    }
 5322 //
 5323 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpc
 5324 func (c *EC2) DeleteVpcRequest(input *DeleteVpcInput) (req *request.Request, output *DeleteVpcOutput) {
 5325     op := &request.Operation{
 5326         Name:       opDeleteVpc,
 5327         HTTPMethod: "POST",
 5328         HTTPPath:   "/",
 5329     }
 5330 
 5331     if input == nil {
 5332         input = &DeleteVpcInput{}
 5333     }
 5334 
 5335     output = &DeleteVpcOutput{}
 5336     req = c.newRequest(op, input, output)
 5337     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 5338     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 5339     return
 5340 }
 5341 
 5342 // DeleteVpc API operation for Amazon Elastic Compute Cloud.
 5343 //
 5344 // Deletes the specified VPC. You must detach or delete all gateways and resources
 5345 // that are associated with the VPC before you can delete it. For example, you
 5346 // must terminate all instances running in the VPC, delete all security groups
 5347 // associated with the VPC (except the default one), delete all route tables
 5348 // associated with the VPC (except the default one), and so on.
 5349 //
 5350 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5351 // with awserr.Error's Code and Message methods to get detailed information about
 5352 // the error.
 5353 //
 5354 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5355 // API operation DeleteVpc for usage and error information.
 5356 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpc
 5357 func (c *EC2) DeleteVpc(input *DeleteVpcInput) (*DeleteVpcOutput, error) {
 5358     req, out := c.DeleteVpcRequest(input)
 5359     err := req.Send()
 5360     return out, err
 5361 }
 5362 
 5363 const opDeleteVpcEndpoints = "DeleteVpcEndpoints"
 5364 
 5365 // DeleteVpcEndpointsRequest generates a "aws/request.Request" representing the
 5366 // client's request for the DeleteVpcEndpoints operation. The "output" return
 5367 // value can be used to capture response data after the request's "Send" method
 5368 // is called.
 5369 //
 5370 // See DeleteVpcEndpoints for usage and error information.
 5371 //
 5372 // Creating a request object using this method should be used when you want to inject
 5373 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5374 // access properties on the request object before or after sending the request. If
 5375 // you just want the service response, call the DeleteVpcEndpoints method directly
 5376 // instead.
 5377 //
 5378 // Note: You must call the "Send" method on the returned request object in order
 5379 // to execute the request.
 5380 //
 5381 //    // Example sending a request using the DeleteVpcEndpointsRequest method.
 5382 //    req, resp := client.DeleteVpcEndpointsRequest(params)
 5383 //
 5384 //    err := req.Send()
 5385 //    if err == nil { // resp is now filled
 5386 //        fmt.Println(resp)
 5387 //    }
 5388 //
 5389 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEndpoints
 5390 func (c *EC2) DeleteVpcEndpointsRequest(input *DeleteVpcEndpointsInput) (req *request.Request, output *DeleteVpcEndpointsOutput) {
 5391     op := &request.Operation{
 5392         Name:       opDeleteVpcEndpoints,
 5393         HTTPMethod: "POST",
 5394         HTTPPath:   "/",
 5395     }
 5396 
 5397     if input == nil {
 5398         input = &DeleteVpcEndpointsInput{}
 5399     }
 5400 
 5401     output = &DeleteVpcEndpointsOutput{}
 5402     req = c.newRequest(op, input, output)
 5403     return
 5404 }
 5405 
 5406 // DeleteVpcEndpoints API operation for Amazon Elastic Compute Cloud.
 5407 //
 5408 // Deletes one or more specified VPC endpoints. Deleting the endpoint also deletes
 5409 // the endpoint routes in the route tables that were associated with the endpoint.
 5410 //
 5411 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5412 // with awserr.Error's Code and Message methods to get detailed information about
 5413 // the error.
 5414 //
 5415 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5416 // API operation DeleteVpcEndpoints for usage and error information.
 5417 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEndpoints
 5418 func (c *EC2) DeleteVpcEndpoints(input *DeleteVpcEndpointsInput) (*DeleteVpcEndpointsOutput, error) {
 5419     req, out := c.DeleteVpcEndpointsRequest(input)
 5420     err := req.Send()
 5421     return out, err
 5422 }
 5423 
 5424 const opDeleteVpcPeeringConnection = "DeleteVpcPeeringConnection"
 5425 
 5426 // DeleteVpcPeeringConnectionRequest generates a "aws/request.Request" representing the
 5427 // client's request for the DeleteVpcPeeringConnection operation. The "output" return
 5428 // value can be used to capture response data after the request's "Send" method
 5429 // is called.
 5430 //
 5431 // See DeleteVpcPeeringConnection for usage and error information.
 5432 //
 5433 // Creating a request object using this method should be used when you want to inject
 5434 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5435 // access properties on the request object before or after sending the request. If
 5436 // you just want the service response, call the DeleteVpcPeeringConnection method directly
 5437 // instead.
 5438 //
 5439 // Note: You must call the "Send" method on the returned request object in order
 5440 // to execute the request.
 5441 //
 5442 //    // Example sending a request using the DeleteVpcPeeringConnectionRequest method.
 5443 //    req, resp := client.DeleteVpcPeeringConnectionRequest(params)
 5444 //
 5445 //    err := req.Send()
 5446 //    if err == nil { // resp is now filled
 5447 //        fmt.Println(resp)
 5448 //    }
 5449 //
 5450 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcPeeringConnection
 5451 func (c *EC2) DeleteVpcPeeringConnectionRequest(input *DeleteVpcPeeringConnectionInput) (req *request.Request, output *DeleteVpcPeeringConnectionOutput) {
 5452     op := &request.Operation{
 5453         Name:       opDeleteVpcPeeringConnection,
 5454         HTTPMethod: "POST",
 5455         HTTPPath:   "/",
 5456     }
 5457 
 5458     if input == nil {
 5459         input = &DeleteVpcPeeringConnectionInput{}
 5460     }
 5461 
 5462     output = &DeleteVpcPeeringConnectionOutput{}
 5463     req = c.newRequest(op, input, output)
 5464     return
 5465 }
 5466 
 5467 // DeleteVpcPeeringConnection API operation for Amazon Elastic Compute Cloud.
 5468 //
 5469 // Deletes a VPC peering connection. Either the owner of the requester VPC or
 5470 // the owner of the peer VPC can delete the VPC peering connection if it's in
 5471 // the active state. The owner of the requester VPC can delete a VPC peering
 5472 // connection in the pending-acceptance state.
 5473 //
 5474 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5475 // with awserr.Error's Code and Message methods to get detailed information about
 5476 // the error.
 5477 //
 5478 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5479 // API operation DeleteVpcPeeringConnection for usage and error information.
 5480 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcPeeringConnection
 5481 func (c *EC2) DeleteVpcPeeringConnection(input *DeleteVpcPeeringConnectionInput) (*DeleteVpcPeeringConnectionOutput, error) {
 5482     req, out := c.DeleteVpcPeeringConnectionRequest(input)
 5483     err := req.Send()
 5484     return out, err
 5485 }
 5486 
 5487 const opDeleteVpnConnection = "DeleteVpnConnection"
 5488 
 5489 // DeleteVpnConnectionRequest generates a "aws/request.Request" representing the
 5490 // client's request for the DeleteVpnConnection operation. The "output" return
 5491 // value can be used to capture response data after the request's "Send" method
 5492 // is called.
 5493 //
 5494 // See DeleteVpnConnection for usage and error information.
 5495 //
 5496 // Creating a request object using this method should be used when you want to inject
 5497 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5498 // access properties on the request object before or after sending the request. If
 5499 // you just want the service response, call the DeleteVpnConnection method directly
 5500 // instead.
 5501 //
 5502 // Note: You must call the "Send" method on the returned request object in order
 5503 // to execute the request.
 5504 //
 5505 //    // Example sending a request using the DeleteVpnConnectionRequest method.
 5506 //    req, resp := client.DeleteVpnConnectionRequest(params)
 5507 //
 5508 //    err := req.Send()
 5509 //    if err == nil { // resp is now filled
 5510 //        fmt.Println(resp)
 5511 //    }
 5512 //
 5513 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnConnection
 5514 func (c *EC2) DeleteVpnConnectionRequest(input *DeleteVpnConnectionInput) (req *request.Request, output *DeleteVpnConnectionOutput) {
 5515     op := &request.Operation{
 5516         Name:       opDeleteVpnConnection,
 5517         HTTPMethod: "POST",
 5518         HTTPPath:   "/",
 5519     }
 5520 
 5521     if input == nil {
 5522         input = &DeleteVpnConnectionInput{}
 5523     }
 5524 
 5525     output = &DeleteVpnConnectionOutput{}
 5526     req = c.newRequest(op, input, output)
 5527     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 5528     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 5529     return
 5530 }
 5531 
 5532 // DeleteVpnConnection API operation for Amazon Elastic Compute Cloud.
 5533 //
 5534 // Deletes the specified VPN connection.
 5535 //
 5536 // If you're deleting the VPC and its associated components, we recommend that
 5537 // you detach the virtual private gateway from the VPC and delete the VPC before
 5538 // deleting the VPN connection. If you believe that the tunnel credentials for
 5539 // your VPN connection have been compromised, you can delete the VPN connection
 5540 // and create a new one that has new keys, without needing to delete the VPC
 5541 // or virtual private gateway. If you create a new VPN connection, you must
 5542 // reconfigure the customer gateway using the new configuration information
 5543 // returned with the new VPN connection ID.
 5544 //
 5545 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5546 // with awserr.Error's Code and Message methods to get detailed information about
 5547 // the error.
 5548 //
 5549 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5550 // API operation DeleteVpnConnection for usage and error information.
 5551 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnConnection
 5552 func (c *EC2) DeleteVpnConnection(input *DeleteVpnConnectionInput) (*DeleteVpnConnectionOutput, error) {
 5553     req, out := c.DeleteVpnConnectionRequest(input)
 5554     err := req.Send()
 5555     return out, err
 5556 }
 5557 
 5558 const opDeleteVpnConnectionRoute = "DeleteVpnConnectionRoute"
 5559 
 5560 // DeleteVpnConnectionRouteRequest generates a "aws/request.Request" representing the
 5561 // client's request for the DeleteVpnConnectionRoute operation. The "output" return
 5562 // value can be used to capture response data after the request's "Send" method
 5563 // is called.
 5564 //
 5565 // See DeleteVpnConnectionRoute for usage and error information.
 5566 //
 5567 // Creating a request object using this method should be used when you want to inject
 5568 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5569 // access properties on the request object before or after sending the request. If
 5570 // you just want the service response, call the DeleteVpnConnectionRoute method directly
 5571 // instead.
 5572 //
 5573 // Note: You must call the "Send" method on the returned request object in order
 5574 // to execute the request.
 5575 //
 5576 //    // Example sending a request using the DeleteVpnConnectionRouteRequest method.
 5577 //    req, resp := client.DeleteVpnConnectionRouteRequest(params)
 5578 //
 5579 //    err := req.Send()
 5580 //    if err == nil { // resp is now filled
 5581 //        fmt.Println(resp)
 5582 //    }
 5583 //
 5584 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnConnectionRoute
 5585 func (c *EC2) DeleteVpnConnectionRouteRequest(input *DeleteVpnConnectionRouteInput) (req *request.Request, output *DeleteVpnConnectionRouteOutput) {
 5586     op := &request.Operation{
 5587         Name:       opDeleteVpnConnectionRoute,
 5588         HTTPMethod: "POST",
 5589         HTTPPath:   "/",
 5590     }
 5591 
 5592     if input == nil {
 5593         input = &DeleteVpnConnectionRouteInput{}
 5594     }
 5595 
 5596     output = &DeleteVpnConnectionRouteOutput{}
 5597     req = c.newRequest(op, input, output)
 5598     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 5599     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 5600     return
 5601 }
 5602 
 5603 // DeleteVpnConnectionRoute API operation for Amazon Elastic Compute Cloud.
 5604 //
 5605 // Deletes the specified static route associated with a VPN connection between
 5606 // an existing virtual private gateway and a VPN customer gateway. The static
 5607 // route allows traffic to be routed from the virtual private gateway to the
 5608 // VPN customer gateway.
 5609 //
 5610 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5611 // with awserr.Error's Code and Message methods to get detailed information about
 5612 // the error.
 5613 //
 5614 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5615 // API operation DeleteVpnConnectionRoute for usage and error information.
 5616 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnConnectionRoute
 5617 func (c *EC2) DeleteVpnConnectionRoute(input *DeleteVpnConnectionRouteInput) (*DeleteVpnConnectionRouteOutput, error) {
 5618     req, out := c.DeleteVpnConnectionRouteRequest(input)
 5619     err := req.Send()
 5620     return out, err
 5621 }
 5622 
 5623 const opDeleteVpnGateway = "DeleteVpnGateway"
 5624 
 5625 // DeleteVpnGatewayRequest generates a "aws/request.Request" representing the
 5626 // client's request for the DeleteVpnGateway operation. The "output" return
 5627 // value can be used to capture response data after the request's "Send" method
 5628 // is called.
 5629 //
 5630 // See DeleteVpnGateway for usage and error information.
 5631 //
 5632 // Creating a request object using this method should be used when you want to inject
 5633 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5634 // access properties on the request object before or after sending the request. If
 5635 // you just want the service response, call the DeleteVpnGateway method directly
 5636 // instead.
 5637 //
 5638 // Note: You must call the "Send" method on the returned request object in order
 5639 // to execute the request.
 5640 //
 5641 //    // Example sending a request using the DeleteVpnGatewayRequest method.
 5642 //    req, resp := client.DeleteVpnGatewayRequest(params)
 5643 //
 5644 //    err := req.Send()
 5645 //    if err == nil { // resp is now filled
 5646 //        fmt.Println(resp)
 5647 //    }
 5648 //
 5649 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnGateway
 5650 func (c *EC2) DeleteVpnGatewayRequest(input *DeleteVpnGatewayInput) (req *request.Request, output *DeleteVpnGatewayOutput) {
 5651     op := &request.Operation{
 5652         Name:       opDeleteVpnGateway,
 5653         HTTPMethod: "POST",
 5654         HTTPPath:   "/",
 5655     }
 5656 
 5657     if input == nil {
 5658         input = &DeleteVpnGatewayInput{}
 5659     }
 5660 
 5661     output = &DeleteVpnGatewayOutput{}
 5662     req = c.newRequest(op, input, output)
 5663     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 5664     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 5665     return
 5666 }
 5667 
 5668 // DeleteVpnGateway API operation for Amazon Elastic Compute Cloud.
 5669 //
 5670 // Deletes the specified virtual private gateway. We recommend that before you
 5671 // delete a virtual private gateway, you detach it from the VPC and delete the
 5672 // VPN connection. Note that you don't need to delete the virtual private gateway
 5673 // if you plan to delete and recreate the VPN connection between your VPC and
 5674 // your network.
 5675 //
 5676 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5677 // with awserr.Error's Code and Message methods to get detailed information about
 5678 // the error.
 5679 //
 5680 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5681 // API operation DeleteVpnGateway for usage and error information.
 5682 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnGateway
 5683 func (c *EC2) DeleteVpnGateway(input *DeleteVpnGatewayInput) (*DeleteVpnGatewayOutput, error) {
 5684     req, out := c.DeleteVpnGatewayRequest(input)
 5685     err := req.Send()
 5686     return out, err
 5687 }
 5688 
 5689 const opDeregisterImage = "DeregisterImage"
 5690 
 5691 // DeregisterImageRequest generates a "aws/request.Request" representing the
 5692 // client's request for the DeregisterImage operation. The "output" return
 5693 // value can be used to capture response data after the request's "Send" method
 5694 // is called.
 5695 //
 5696 // See DeregisterImage for usage and error information.
 5697 //
 5698 // Creating a request object using this method should be used when you want to inject
 5699 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5700 // access properties on the request object before or after sending the request. If
 5701 // you just want the service response, call the DeregisterImage method directly
 5702 // instead.
 5703 //
 5704 // Note: You must call the "Send" method on the returned request object in order
 5705 // to execute the request.
 5706 //
 5707 //    // Example sending a request using the DeregisterImageRequest method.
 5708 //    req, resp := client.DeregisterImageRequest(params)
 5709 //
 5710 //    err := req.Send()
 5711 //    if err == nil { // resp is now filled
 5712 //        fmt.Println(resp)
 5713 //    }
 5714 //
 5715 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterImage
 5716 func (c *EC2) DeregisterImageRequest(input *DeregisterImageInput) (req *request.Request, output *DeregisterImageOutput) {
 5717     op := &request.Operation{
 5718         Name:       opDeregisterImage,
 5719         HTTPMethod: "POST",
 5720         HTTPPath:   "/",
 5721     }
 5722 
 5723     if input == nil {
 5724         input = &DeregisterImageInput{}
 5725     }
 5726 
 5727     output = &DeregisterImageOutput{}
 5728     req = c.newRequest(op, input, output)
 5729     req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler)
 5730     req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
 5731     return
 5732 }
 5733 
 5734 // DeregisterImage API operation for Amazon Elastic Compute Cloud.
 5735 //
 5736 // Deregisters the specified AMI. After you deregister an AMI, it can't be used
 5737 // to launch new instances.
 5738 //
 5739 // This command does not delete the AMI.
 5740 //
 5741 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5742 // with awserr.Error's Code and Message methods to get detailed information about
 5743 // the error.
 5744 //
 5745 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5746 // API operation DeregisterImage for usage and error information.
 5747 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterImage
 5748 func (c *EC2) DeregisterImage(input *DeregisterImageInput) (*DeregisterImageOutput, error) {
 5749     req, out := c.DeregisterImageRequest(input)
 5750     err := req.Send()
 5751     return out, err
 5752 }
 5753 
 5754 const opDescribeAccountAttributes = "DescribeAccountAttributes"
 5755 
 5756 // DescribeAccountAttributesRequest generates a "aws/request.Request" representing the
 5757 // client's request for the DescribeAccountAttributes operation. The "output" return
 5758 // value can be used to capture response data after the request's "Send" method
 5759 // is called.
 5760 //
 5761 // See DescribeAccountAttributes for usage and error information.
 5762 //
 5763 // Creating a request object using this method should be used when you want to inject
 5764 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5765 // access properties on the request object before or after sending the request. If
 5766 // you just want the service response, call the DescribeAccountAttributes method directly
 5767 // instead.
 5768 //
 5769 // Note: You must call the "Send" method on the returned request object in order
 5770 // to execute the request.
 5771 //
 5772 //    // Example sending a request using the DescribeAccountAttributesRequest method.
 5773 //    req, resp := client.DescribeAccountAttributesRequest(params)
 5774 //
 5775 //    err := req.Send()
 5776 //    if err == nil { // resp is now filled
 5777 //        fmt.Println(resp)
 5778 //    }
 5779 //
 5780 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAccountAttributes
 5781 func (c *EC2) DescribeAccountAttributesRequest(input *DescribeAccountAttributesInput) (req *request.Request, output *DescribeAccountAttributesOutput) {
 5782     op := &request.Operation{
 5783         Name:       opDescribeAccountAttributes,
 5784         HTTPMethod: "POST",
 5785         HTTPPath:   "/",
 5786     }
 5787 
 5788     if input == nil {
 5789         input = &DescribeAccountAttributesInput{}
 5790     }
 5791 
 5792     output = &DescribeAccountAttributesOutput{}
 5793     req = c.newRequest(op, input, output)
 5794     return
 5795 }
 5796 
 5797 // DescribeAccountAttributes API operation for Amazon Elastic Compute Cloud.
 5798 //
 5799 // Describes attributes of your AWS account. The following are the supported
 5800 // account attributes:
 5801 //
 5802 //    * supported-platforms: Indicates whether your account can launch instances
 5803 //    into EC2-Classic and EC2-VPC, or only into EC2-VPC.
 5804 //
 5805 //    * default-vpc: The ID of the default VPC for your account, or none.
 5806 //
 5807 //    * max-instances: The maximum number of On-Demand instances that you can
 5808 //    run.
 5809 //
 5810 //    * vpc-max-security-groups-per-interface: The maximum number of security
 5811 //    groups that you can assign to a network interface.
 5812 //
 5813 //    * max-elastic-ips: The maximum number of Elastic IP addresses that you
 5814 //    can allocate for use with EC2-Classic.
 5815 //
 5816 //    * vpc-max-elastic-ips: The maximum number of Elastic IP addresses that
 5817 //    you can allocate for use with EC2-VPC.
 5818 //
 5819 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5820 // with awserr.Error's Code and Message methods to get detailed information about
 5821 // the error.
 5822 //
 5823 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5824 // API operation DescribeAccountAttributes for usage and error information.
 5825 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAccountAttributes
 5826 func (c *EC2) DescribeAccountAttributes(input *DescribeAccountAttributesInput) (*DescribeAccountAttributesOutput, error) {
 5827     req, out := c.DescribeAccountAttributesRequest(input)
 5828     err := req.Send()
 5829     return out, err
 5830 }
 5831 
 5832 const opDescribeAddresses = "DescribeAddresses"
 5833 
 5834 // DescribeAddressesRequest generates a "aws/request.Request" representing the
 5835 // client's request for the DescribeAddresses operation. The "output" return
 5836 // value can be used to capture response data after the request's "Send" method
 5837 // is called.
 5838 //
 5839 // See DescribeAddresses for usage and error information.
 5840 //
 5841 // Creating a request object using this method should be used when you want to inject
 5842 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5843 // access properties on the request object before or after sending the request. If
 5844 // you just want the service response, call the DescribeAddresses method directly
 5845 // instead.
 5846 //
 5847 // Note: You must call the "Send" method on the returned request object in order
 5848 // to execute the request.
 5849 //
 5850 //    // Example sending a request using the DescribeAddressesRequest method.
 5851 //    req, resp := client.DescribeAddressesRequest(params)
 5852 //
 5853 //    err := req.Send()
 5854 //    if err == nil { // resp is now filled
 5855 //        fmt.Println(resp)
 5856 //    }
 5857 //
 5858 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddresses
 5859 func (c *EC2) DescribeAddressesRequest(input *DescribeAddressesInput) (req *request.Request, output *DescribeAddressesOutput) {
 5860     op := &request.Operation{
 5861         Name:       opDescribeAddresses,
 5862         HTTPMethod: "POST",
 5863         HTTPPath:   "/",
 5864     }
 5865 
 5866     if input == nil {
 5867         input = &DescribeAddressesInput{}
 5868     }
 5869 
 5870     output = &DescribeAddressesOutput{}
 5871     req = c.newRequest(op, input, output)
 5872     return
 5873 }
 5874 
 5875 // DescribeAddresses API operation for Amazon Elastic Compute Cloud.
 5876 //
 5877 // Describes one or more of your Elastic IP addresses.
 5878 //
 5879 // An Elastic IP address is for use in either the EC2-Classic platform or in
 5880 // a VPC. For more information, see Elastic IP Addresses (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html)
 5881 // in the Amazon Elastic Compute Cloud User Guide.
 5882 //
 5883 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5884 // with awserr.Error's Code and Message methods to get detailed information about
 5885 // the error.
 5886 //
 5887 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5888 // API operation DescribeAddresses for usage and error information.
 5889 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddresses
 5890 func (c *EC2) DescribeAddresses(input *DescribeAddressesInput) (*DescribeAddressesOutput, error) {
 5891     req, out := c.DescribeAddressesRequest(input)
 5892     err := req.Send()
 5893     return out, err
 5894 }
 5895 
 5896 const opDescribeAvailabilityZones = "DescribeAvailabilityZones"
 5897 
 5898 // DescribeAvailabilityZonesRequest generates a "aws/request.Request" representing the
 5899 // client's request for the DescribeAvailabilityZones operation. The "output" return
 5900 // value can be used to capture response data after the request's "Send" method
 5901 // is called.
 5902 //
 5903 // See DescribeAvailabilityZones for usage and error information.
 5904 //
 5905 // Creating a request object using this method should be used when you want to inject
 5906 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5907 // access properties on the request object before or after sending the request. If
 5908 // you just want the service response, call the DescribeAvailabilityZones method directly
 5909 // instead.
 5910 //
 5911 // Note: You must call the "Send" method on the returned request object in order
 5912 // to execute the request.
 5913 //
 5914 //    // Example sending a request using the DescribeAvailabilityZonesRequest method.
 5915 //    req, resp := client.DescribeAvailabilityZonesRequest(params)
 5916 //
 5917 //    err := req.Send()
 5918 //    if err == nil { // resp is now filled
 5919 //        fmt.Println(resp)
 5920 //    }
 5921 //
 5922 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAvailabilityZones
 5923 func (c *EC2) DescribeAvailabilityZonesRequest(input *DescribeAvailabilityZonesInput) (req *request.Request, output *DescribeAvailabilityZonesOutput) {
 5924     op := &request.Operation{
 5925         Name:       opDescribeAvailabilityZones,
 5926         HTTPMethod: "POST",
 5927         HTTPPath:   "/",
 5928     }
 5929 
 5930     if input == nil {
 5931         input = &DescribeAvailabilityZonesInput{}
 5932     }
 5933 
 5934     output = &DescribeAvailabilityZonesOutput{}
 5935     req = c.newRequest(op, input, output)
 5936     return
 5937 }
 5938 
 5939 // DescribeAvailabilityZones API operation for Amazon Elastic Compute Cloud.
 5940 //
 5941 // Describes one or more of the Availability Zones that are available to you.
 5942 // The results include zones only for the region you're currently using. If
 5943 // there is an event impacting an Availability Zone, you can use this request
 5944 // to view the state and any provided message for that Availability Zone.
 5945 //
 5946 // For more information, see Regions and Availability Zones (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html)
 5947 // in the Amazon Elastic Compute Cloud User Guide.
 5948 //
 5949 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 5950 // with awserr.Error's Code and Message methods to get detailed information about
 5951 // the error.
 5952 //
 5953 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 5954 // API operation DescribeAvailabilityZones for usage and error information.
 5955 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAvailabilityZones
 5956 func (c *EC2) DescribeAvailabilityZones(input *DescribeAvailabilityZonesInput) (*DescribeAvailabilityZonesOutput, error) {
 5957     req, out := c.DescribeAvailabilityZonesRequest(input)
 5958     err := req.Send()
 5959     return out, err
 5960 }
 5961 
 5962 const opDescribeBundleTasks = "DescribeBundleTasks"
 5963 
 5964 // DescribeBundleTasksRequest generates a "aws/request.Request" representing the
 5965 // client's request for the DescribeBundleTasks operation. The "output" return
 5966 // value can be used to capture response data after the request's "Send" method
 5967 // is called.
 5968 //
 5969 // See DescribeBundleTasks for usage and error information.
 5970 //
 5971 // Creating a request object using this method should be used when you want to inject
 5972 // custom logic into the request's lifecycle using a custom handler, or if you want to
 5973 // access properties on the request object before or after sending the request. If
 5974 // you just want the service response, call the DescribeBundleTasks method directly
 5975 // instead.
 5976 //
 5977 // Note: You must call the "Send" method on the returned request object in order
 5978 // to execute the request.
 5979 //
 5980 //    // Example sending a request using the DescribeBundleTasksRequest method.
 5981 //    req, resp := client.DescribeBundleTasksRequest(params)
 5982 //
 5983 //    err := req.Send()
 5984 //    if err == nil { // resp is now filled
 5985 //        fmt.Println(resp)
 5986 //    }
 5987 //
 5988 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeBundleTasks
 5989 func (c *EC2) DescribeBundleTasksRequest(input *DescribeBundleTasksInput) (req *request.Request, output *DescribeBundleTasksOutput) {
 5990     op := &request.Operation{
 5991         Name:       opDescribeBundleTasks,
 5992         HTTPMethod: "POST",
 5993         HTTPPath:   "/",
 5994     }
 5995 
 5996     if input == nil {
 5997         input = &DescribeBundleTasksInput{}
 5998     }
 5999 
 6000     output = &DescribeBundleTasksOutput{}
 6001     req = c.newRequest(op, input, output)
 6002     return
 6003 }
 6004 
 6005 // DescribeBundleTasks API operation for Amazon Elastic Compute Cloud.
 6006 //
 6007 // Describes one or more of your bundling tasks.
 6008 //
 6009 // Completed bundle tasks are listed for only a limited time. If your bundle
 6010 // task is no longer in the list, you can still register an AMI from it. Just
 6011 // use RegisterImage with the Amazon S3 bucket name and image manifest name
 6012 // you provided to the bundle task.
 6013 //
 6014 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 6015 // with awserr.Error's Code and Message methods to get detailed information about
 6016 // the error.
 6017 //
 6018 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 6019 // API operation DescribeBundleTasks for usage and error information.
 6020 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeBundleTasks
 6021 func (c *EC2) DescribeBundleTasks(input *DescribeBundleTasksInput) (*DescribeBundleTasksOutput, error) {
 6022     req, out := c.DescribeBundleTasksRequest(input)
 6023     err := req.Send()
 6024     return out, err
 6025 }
 6026 
 6027 const opDescribeClassicLinkInstances = "DescribeClassicLinkInstances"
 6028 
 6029 // DescribeClassicLinkInstancesRequest generates a "aws/request.Request" representing the
 6030 // client's request for the DescribeClassicLinkInstances operation. The "output" return
 6031 // value can be used to capture response data after the request's "Send" method
 6032 // is called.
 6033 //
 6034 // See DescribeClassicLinkInstances for usage and error information.
 6035 //
 6036 // Creating a request object using this method should be used when you want to inject
 6037 // custom logic into the request's lifecycle using a custom handler, or if you want to
 6038 // access properties on the request object before or after sending the request. If
 6039 // you just want the service response, call the DescribeClassicLinkInstances method directly
 6040 // instead.
 6041 //
 6042 // Note: You must call the "Send" method on the returned request object in order
 6043 // to execute the request.
 6044 //
 6045 //    // Example sending a request using the DescribeClassicLinkInstancesRequest method.
 6046 //    req, resp := client.DescribeClassicLinkInstancesRequest(params)
 6047 //
 6048 //    err := req.Send()
 6049 //    if err == nil { // resp is now filled
 6050 //        fmt.Println(resp)
 6051 //    }
 6052 //
 6053 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClassicLinkInstances
 6054 func (c *EC2) DescribeClassicLinkInstancesRequest(input *DescribeClassicLinkInstancesInput) (req *request.Request, output *DescribeClassicLinkInstancesOutput) {
 6055     op := &request.Operation{
 6056         Name:       opDescribeClassicLinkInstances,
 6057         HTTPMethod: "POST",
 6058         HTTPPath:   "/",
 6059     }
 6060 
 6061     if input == nil {
 6062         input = &DescribeClassicLinkInstancesInput{}
 6063     }
 6064 
 6065     output = &DescribeClassicLinkInstancesOutput{}
 6066     req = c.newRequest(op, input, output)
 6067     return
 6068 }
 6069 
 6070 // DescribeClassicLinkInstances API operation for Amazon Elastic Compute Cloud.
 6071 //
 6072 // Describes one or more of your linked EC2-Classic instances. This request
 6073 // only returns information about EC2-Classic instances linked to a VPC through
 6074 // ClassicLink; you cannot use this request to return information about other
 6075 // instances.
 6076 //
 6077 // Returns awserr.Error for service API and SDK errors. Use runtime type assertions
 6078 // with awserr.Error's Code and Message methods to get detailed information about
 6079 // the error.
 6080 //
 6081 // See the AWS API reference guide for Amazon Elastic Compute Cloud's
 6082 // API operation DescribeClassicLinkInstances for usage and error information.
 6083 // Please also see https://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClassicLinkInstances
 6084 func (c *EC2) DescribeClassicLinkInstances(input *DescribeClassicLinkInstancesInput) (*DescribeClassicLinkInstancesOutput, error)