amazonica.aws.ec2 — com.signal-ai/amazonica 0.3.157-signal-2

accept-reserved-instances-exchange-quote clj

(accept-reserved-instances-exchange-quote
  &
  {:keys [dry-run-request reserved-instance-ids target-configurations]
   :as accept-reserved-instances-exchange-quote-request})

accept-transit-gateway-multicast-domain-associations clj

(accept-transit-gateway-multicast-domain-associations
  &
  {:keys [dry-run-request subnet-ids transit-gateway-attachment-id
          transit-gateway-multicast-domain-id]
   :as accept-transit-gateway-multicast-domain-associations-request})

accept-transit-gateway-peering-attachment clj

(accept-transit-gateway-peering-attachment
  &
  {:keys [dry-run-request transit-gateway-attachment-id]
   :as accept-transit-gateway-peering-attachment-request})

accept-transit-gateway-vpc-attachment clj

(accept-transit-gateway-vpc-attachment
  &
  {:keys [dry-run-request transit-gateway-attachment-id]
   :as accept-transit-gateway-vpc-attachment-request})

accept-vpc-endpoint-connections clj

(accept-vpc-endpoint-connections &
                                 {:keys [dry-run-request service-id
                                         vpc-endpoint-ids]
                                  :as accept-vpc-endpoint-connections-request})

accept-vpc-peering-connection clj

(accept-vpc-peering-connection)

(accept-vpc-peering-connection &
                               {:keys [dry-run-request
                                       vpc-peering-connection-id]
                                :as accept-vpc-peering-connection-request})

advertise-byoip-cidr clj

(advertise-byoip-cidr &
                      {:keys [cidr dry-run-request]
                       :as advertise-byoip-cidr-request})

allocate-address clj

(allocate-address)

(allocate-address &
                  {:keys [address customer-owned-ipv4-pool domain
                          dry-run-request network-border-group public-ipv4-pool
                          tag-specifications]
                   :as allocate-address-request})

allocate-hosts clj

(allocate-hosts &
                {:keys [auto-placement availability-zone client-token
                        dry-run-request host-recovery instance-family
                        instance-type quantity tag-specifications]
                 :as allocate-hosts-request})

apply-security-groups-to-client-vpn-target-network clj

(apply-security-groups-to-client-vpn-target-network
  &
  {:keys [client-vpn-endpoint-id dry-run-request security-group-ids vpc-id]
   :as apply-security-groups-to-client-vpn-target-network-request})

assign-ipv6-addresses clj

(assign-ipv6-addresses &
                       {:keys [dry-run-request ipv6-address-count ipv6-addresses
                               network-interface-id]
                        :as assign-ipv6-addresses-request})

assign-ipv6addresses clj

(assign-ipv6addresses &
                      {:keys [dry-run-request ipv6-address-count ipv6-addresses
                              network-interface-id]
                       :as assign-ipv6-addresses-request})

assign-private-ip-addresses clj

(assign-private-ip-addresses &
                             {:keys [allow-reassignment dry-run-request
                                     network-interface-id private-ip-addresses
                                     secondary-private-ip-address-count]
                              :as assign-private-ip-addresses-request})

associate-address clj

(associate-address &
                   {:keys [allocation-id allow-reassociation dry-run-request
                           instance-id network-interface-id private-ip-address
                           public-ip]
                    :as associate-address-request})

associate-client-vpn-target-network clj

(associate-client-vpn-target-network
  &
  {:keys [client-token client-vpn-endpoint-id dry-run-request subnet-id]
   :as associate-client-vpn-target-network-request})

associate-dhcp-options clj

(associate-dhcp-options &
                        {:keys [dhcp-options-id dry-run-request vpc-id]
                         :as associate-dhcp-options-request})

associate-enclave-certificate-iam-role clj

(associate-enclave-certificate-iam-role
  &
  {:keys [certificate-arn dry-run-request role-arn]
   :as associate-enclave-certificate-iam-role-request})

associate-iam-instance-profile clj

(associate-iam-instance-profile &
                                {:keys [dry-run-request iam-instance-profile
                                        instance-id]
                                 :as associate-iam-instance-profile-request})

associate-route-table clj

(associate-route-table &
                       {:keys [dry-run-request gateway-id route-table-id
                               subnet-id]
                        :as associate-route-table-request})

associate-subnet-cidr-block clj

(associate-subnet-cidr-block &
                             {:keys [dry-run-request ipv6-cidr-block subnet-id]
                              :as associate-subnet-cidr-block-request})

associate-transit-gateway-multicast-domain clj

(associate-transit-gateway-multicast-domain
  &
  {:keys [dry-run-request subnet-ids transit-gateway-attachment-id
          transit-gateway-multicast-domain-id]
   :as associate-transit-gateway-multicast-domain-request})

associate-transit-gateway-route-table clj

(associate-transit-gateway-route-table
  &
  {:keys [dry-run-request transit-gateway-attachment-id
          transit-gateway-route-table-id]
   :as associate-transit-gateway-route-table-request})

associate-vpc-cidr-block clj

(associate-vpc-cidr-block
  &
  {:keys [amazon-provided-ipv6-cidr-block cidr-block dry-run-request
          ipv6-cidr-block ipv6-cidr-block-network-border-group ipv6-pool vpc-id]
   :as associate-vpc-cidr-block-request})

attach-classic-link-vpc clj

(attach-classic-link-vpc &
                         {:keys [dry-run-request groups instance-id vpc-id]
                          :as attach-classic-link-vpc-request})

attach-internet-gateway clj

(attach-internet-gateway &
                         {:keys [dry-run-request internet-gateway-id vpc-id]
                          :as attach-internet-gateway-request})

attach-network-interface clj

(attach-network-interface &
                          {:keys [device-index dry-run-request instance-id
                                  network-card-index network-interface-id]
                           :as attach-network-interface-request})

attach-volume clj

(attach-volume &
               {:keys [device dry-run-request instance-id volume-id]
                :as attach-volume-request})

attach-vpn-gateway clj

(attach-vpn-gateway &
                    {:keys [dry-run-request vpc-id vpn-gateway-id]
                     :as attach-vpn-gateway-request})

authorize-client-vpn-ingress clj

(authorize-client-vpn-ingress &
                              {:keys [access-group-id authorize-all-groups
                                      client-token client-vpn-endpoint-id
                                      description dry-run-request
                                      target-network-cidr]
                               :as authorize-client-vpn-ingress-request})

authorize-security-group-egress clj

(authorize-security-group-egress
  &
  {:keys [cidr-ip dry-run-request from-port group-id ip-permissions ip-protocol
          source-security-group-name source-security-group-owner-id to-port]
   :as authorize-security-group-egress-request})

authorize-security-group-ingress clj

(authorize-security-group-ingress
  &
  {:keys [cidr-ip dry-run-request from-port group-id group-name ip-permissions
          ip-protocol source-security-group-name source-security-group-owner-id
          to-port]
   :as authorize-security-group-ingress-request})

bundle-instance clj

(bundle-instance &
                 {:keys [dry-run-request instance-id storage]
                  :as bundle-instance-request})

cancel-bundle-task clj

(cancel-bundle-task &
                    {:keys [bundle-id dry-run-request]
                     :as cancel-bundle-task-request})

cancel-capacity-reservation clj

(cancel-capacity-reservation &
                             {:keys [capacity-reservation-id dry-run-request]
                              :as cancel-capacity-reservation-request})

cancel-conversion-task clj

(cancel-conversion-task &
                        {:keys [conversion-task-id dry-run-request
                                reason-message]
                         :as cancel-conversion-task-request})

cancel-export-task clj

(cancel-export-task &
                    {:keys [dry-run-request export-task-id]
                     :as cancel-export-task-request})

cancel-import-task clj

(cancel-import-task)

(cancel-import-task &
                    {:keys [cancel-reason dry-run-request import-task-id]
                     :as cancel-import-task-request})

cancel-reserved-instances-listing clj

(cancel-reserved-instances-listing
  &
  {:keys [dry-run-request reserved-instances-listing-id]
   :as cancel-reserved-instances-listing-request})

cancel-spot-fleet-requests clj

(cancel-spot-fleet-requests &
                            {:keys [dry-run-request spot-fleet-request-ids
                                    terminate-instances]
                             :as cancel-spot-fleet-requests-request})

cancel-spot-instance-requests clj

(cancel-spot-instance-requests &
                               {:keys [dry-run-request
                                       spot-instance-request-ids]
                                :as cancel-spot-instance-requests-request})

client-class clj

confirm-product-instance clj

(confirm-product-instance &
                          {:keys [dry-run-request instance-id product-code]
                           :as confirm-product-instance-request})

copy-fpga-image clj

(copy-fpga-image &
                 {:keys [client-token description dry-run-request name
                         source-fpga-image-id source-region]
                  :as copy-fpga-image-request})

copy-image clj

(copy-image &
            {:keys [client-token description destination-outpost-arn
                    dry-run-request encrypted kms-key-id name source-image-id
                    source-region]
             :as copy-image-request})

copy-snapshot clj

(copy-snapshot &
               {:keys [description destination-outpost-arn destination-region
                       dry-run-request encrypted kms-key-id presigned-url
                       source-region source-snapshot-id tag-specifications]
                :as copy-snapshot-request})

create-capacity-reservation clj

(create-capacity-reservation
  &
  {:keys [availability-zone availability-zone-id client-token dry-run-request
          ebs-optimized end-date end-date-type ephemeral-storage instance-count
          instance-match-criteria instance-platform instance-type
          tag-specifications tenancy]
   :as create-capacity-reservation-request})

create-carrier-gateway clj

(create-carrier-gateway &
                        {:keys [client-token dry-run-request tag-specifications
                                vpc-id]
                         :as create-carrier-gateway-request})

create-client-vpn-endpoint clj

(create-client-vpn-endpoint
  &
  {:keys [authentication-options client-cidr-block client-connect-options
          client-token connection-log-options description dns-servers
          dry-run-request security-group-ids self-service-portal
          server-certificate-arn split-tunnel tag-specifications
          transport-protocol vpc-id vpn-port]
   :as create-client-vpn-endpoint-request})

create-client-vpn-route clj

(create-client-vpn-route &
                         {:keys [client-token client-vpn-endpoint-id description
                                 destination-cidr-block dry-run-request
                                 target-vpc-subnet-id]
                          :as create-client-vpn-route-request})

create-customer-gateway clj

(create-customer-gateway &
                         {:keys [bgp-asn certificate-arn device-name
                                 dry-run-request public-ip tag-specifications
                                 type]
                          :as create-customer-gateway-request})

create-default-subnet clj

(create-default-subnet &
                       {:keys [availability-zone dry-run-request]
                        :as create-default-subnet-request})

create-default-vpc clj

(create-default-vpc & {:keys [dry-run-request] :as create-default-vpc-request})

create-dhcp-options clj

(create-dhcp-options &
                     {:keys [dhcp-configurations dry-run-request
                             tag-specifications]
                      :as create-dhcp-options-request})

create-egress-only-internet-gateway clj

(create-egress-only-internet-gateway
  &
  {:keys [client-token dry-run-request tag-specifications vpc-id]
   :as create-egress-only-internet-gateway-request})

create-fleet clj

(create-fleet
  &
  {:keys [client-token dry-run-request excess-capacity-termination-policy
          launch-template-configs on-demand-options replace-unhealthy-instances
          spot-options tag-specifications target-capacity-specification
          terminate-instances-with-expiration type valid-from valid-until]
   :as create-fleet-request})

create-flow-logs clj

(create-flow-logs &
                  {:keys [client-token deliver-logs-permission-arn
                          dry-run-request log-destination log-destination-type
                          log-format log-group-name max-aggregation-interval
                          resource-ids resource-type tag-specifications
                          traffic-type]
                   :as create-flow-logs-request})

create-fpga-image clj

(create-fpga-image &
                   {:keys [client-token description dry-run-request
                           input-storage-location logs-storage-location name
                           tag-specifications]
                    :as create-fpga-image-request})

create-image clj

(create-image &
              {:keys [block-device-mappings description dry-run-request
                      instance-id name no-reboot tag-specifications]
               :as create-image-request})

create-instance-export-task clj

(create-instance-export-task &
                             {:keys [description dry-run-request
                                     export-to-s3-task instance-id
                                     tag-specifications target-environment]
                              :as create-instance-export-task-request})

create-internet-gateway clj

(create-internet-gateway)

(create-internet-gateway &
                         {:keys [dry-run-request tag-specifications]
                          :as create-internet-gateway-request})

create-key-pair clj

(create-key-pair &
                 {:keys [dry-run-request key-name tag-specifications]
                  :as create-key-pair-request})

create-launch-template clj

(create-launch-template &
                        {:keys [client-token dry-run-request
                                launch-template-data launch-template-name
                                tag-specifications version-description]
                         :as create-launch-template-request})

create-launch-template-version clj

(create-launch-template-version
  &
  {:keys [client-token dry-run-request launch-template-data launch-template-id
          launch-template-name source-version version-description]
   :as create-launch-template-version-request})

create-local-gateway-route clj

(create-local-gateway-route &
                            {:keys [destination-cidr-block dry-run-request
                                    local-gateway-route-table-id
                                    local-gateway-virtual-interface-group-id]
                             :as create-local-gateway-route-request})

create-local-gateway-route-table-vpc-association clj

(create-local-gateway-route-table-vpc-association
  &
  {:keys [dry-run-request local-gateway-route-table-id tag-specifications
          vpc-id]
   :as create-local-gateway-route-table-vpc-association-request})

create-managed-prefix-list clj

(create-managed-prefix-list &
                            {:keys [address-family client-token dry-run-request
                                    entries max-entries prefix-list-name
                                    tag-specifications]
                             :as create-managed-prefix-list-request})

create-nat-gateway clj

(create-nat-gateway &
                    {:keys [allocation-id client-token dry-run-request subnet-id
                            tag-specifications]
                     :as create-nat-gateway-request})

create-network-acl clj

(create-network-acl &
                    {:keys [dry-run-request tag-specifications vpc-id]
                     :as create-network-acl-request})

create-network-acl-entry clj

(create-network-acl-entry &
                          {:keys [cidr-block dry-run-request egress
                                  icmp-type-code ipv6-cidr-block network-acl-id
                                  port-range protocol rule-action rule-number]
                           :as create-network-acl-entry-request})

create-network-insights-path clj

(create-network-insights-path &
                              {:keys [client-token destination destination-ip
                                      destination-port dry-run-request protocol
                                      source source-ip tag-specifications]
                               :as create-network-insights-path-request})

create-network-interface clj

(create-network-interface
  &
  {:keys [description dry-run-request groups interface-type ipv6-address-count
          ipv6-addresses private-ip-address private-ip-addresses
          secondary-private-ip-address-count subnet-id tag-specifications]
   :as create-network-interface-request})

create-network-interface-permission clj

(create-network-interface-permission
  &
  {:keys [aws-account-id aws-service dry-run-request network-interface-id
          permission]
   :as create-network-interface-permission-request})

create-placement-group clj

(create-placement-group &
                        {:keys [dry-run-request group-name partition-count
                                strategy tag-specifications]
                         :as create-placement-group-request})

create-reserved-instances-listing clj

(create-reserved-instances-listing
  &
  {:keys [client-token dry-run-request instance-count price-schedules
          reserved-instances-id]
   :as create-reserved-instances-listing-request})

create-route clj

(create-route &
              {:keys [carrier-gateway-id destination-cidr-block
                      destination-ipv6-cidr-block destination-prefix-list-id
                      dry-run-request egress-only-internet-gateway-id gateway-id
                      instance-id local-gateway-id nat-gateway-id
                      network-interface-id route-table-id transit-gateway-id
                      vpc-endpoint-id vpc-peering-connection-id]
               :as create-route-request})

create-route-table clj

(create-route-table &
                    {:keys [dry-run-request tag-specifications vpc-id]
                     :as create-route-table-request})

create-security-group clj

(create-security-group &
                       {:keys [description dry-run-request group-name
                               tag-specifications vpc-id]
                        :as create-security-group-request})

create-snapshot clj

(create-snapshot &
                 {:keys [description dry-run-request outpost-arn
                         tag-specifications volume-id]
                  :as create-snapshot-request})

create-snapshots clj

(create-snapshots &
                  {:keys [copy-tags-from-source description dry-run-request
                          instance-specification outpost-arn tag-specifications]
                   :as create-snapshots-request})

create-spot-datafeed-subscription clj

(create-spot-datafeed-subscription
  &
  {:keys [bucket dry-run-request prefix]
   :as create-spot-datafeed-subscription-request})

create-subnet clj

(create-subnet &
               {:keys [availability-zone availability-zone-id cidr-block
                       dry-run-request ipv6-cidr-block outpost-arn
                       tag-specifications vpc-id]
                :as create-subnet-request})

create-tags clj

(create-tags & {:keys [dry-run-request resources tags] :as create-tags-request})

create-traffic-mirror-filter clj

(create-traffic-mirror-filter &
                              {:keys [client-token description dry-run-request
                                      tag-specifications]
                               :as create-traffic-mirror-filter-request})

create-traffic-mirror-filter-rule clj

(create-traffic-mirror-filter-rule
  &
  {:keys [client-token description destination-cidr-block destination-port-range
          dry-run-request protocol rule-action rule-number source-cidr-block
          source-port-range traffic-direction traffic-mirror-filter-id]
   :as create-traffic-mirror-filter-rule-request})

create-traffic-mirror-session clj

(create-traffic-mirror-session
  &
  {:keys [client-token description dry-run-request network-interface-id
          packet-length session-number tag-specifications
          traffic-mirror-filter-id traffic-mirror-target-id virtual-network-id]
   :as create-traffic-mirror-session-request})

create-traffic-mirror-target clj

(create-traffic-mirror-target
  &
  {:keys [client-token description dry-run-request network-interface-id
          network-load-balancer-arn tag-specifications]
   :as create-traffic-mirror-target-request})

create-transit-gateway clj

(create-transit-gateway &
                        {:keys [description dry-run-request options
                                tag-specifications]
                         :as create-transit-gateway-request})

create-transit-gateway-connect clj

(create-transit-gateway-connect &
                                {:keys [dry-run-request options
                                        tag-specifications
                                        transport-transit-gateway-attachment-id]
                                 :as create-transit-gateway-connect-request})

create-transit-gateway-connect-peer clj

(create-transit-gateway-connect-peer
  &
  {:keys [bgp-options dry-run-request inside-cidr-blocks peer-address
          tag-specifications transit-gateway-address
          transit-gateway-attachment-id]
   :as create-transit-gateway-connect-peer-request})

create-transit-gateway-multicast-domain clj

(create-transit-gateway-multicast-domain
  &
  {:keys [dry-run-request options tag-specifications transit-gateway-id]
   :as create-transit-gateway-multicast-domain-request})

create-transit-gateway-peering-attachment clj

(create-transit-gateway-peering-attachment
  &
  {:keys [dry-run-request peer-account-id peer-region peer-transit-gateway-id
          tag-specifications transit-gateway-id]
   :as create-transit-gateway-peering-attachment-request})

create-transit-gateway-prefix-list-reference clj

(create-transit-gateway-prefix-list-reference
  &
  {:keys [blackhole dry-run-request prefix-list-id transit-gateway-attachment-id
          transit-gateway-route-table-id]
   :as create-transit-gateway-prefix-list-reference-request})

create-transit-gateway-route clj

(create-transit-gateway-route
  &
  {:keys [blackhole destination-cidr-block dry-run-request
          transit-gateway-attachment-id transit-gateway-route-table-id]
   :as create-transit-gateway-route-request})

create-transit-gateway-route-table clj

(create-transit-gateway-route-table
  &
  {:keys [dry-run-request tag-specifications transit-gateway-id]
   :as create-transit-gateway-route-table-request})

create-transit-gateway-vpc-attachment clj

(create-transit-gateway-vpc-attachment
  &
  {:keys [dry-run-request options subnet-ids tag-specifications
          transit-gateway-id vpc-id]
   :as create-transit-gateway-vpc-attachment-request})

create-volume clj

(create-volume &
               {:keys [availability-zone dry-run-request encrypted iops
                       kms-key-id multi-attach-enabled outpost-arn size
                       snapshot-id tag-specifications throughput volume-type]
                :as create-volume-request})

create-vpc clj

(create-vpc &
            {:keys [amazon-provided-ipv6-cidr-block cidr-block dry-run-request
                    instance-tenancy ipv6-cidr-block
                    ipv6-cidr-block-network-border-group ipv6-pool
                    tag-specifications]
             :as create-vpc-request})

create-vpc-endpoint clj

(create-vpc-endpoint &
                     {:keys [client-token dry-run-request policy-document
                             private-dns-enabled route-table-ids
                             security-group-ids service-name subnet-ids
                             tag-specifications vpc-endpoint-type vpc-id]
                      :as create-vpc-endpoint-request})

create-vpc-endpoint-connection-notification clj

(create-vpc-endpoint-connection-notification
  &
  {:keys [client-token connection-events connection-notification-arn
          dry-run-request service-id vpc-endpoint-id]
   :as create-vpc-endpoint-connection-notification-request})

create-vpc-endpoint-service-configuration clj

(create-vpc-endpoint-service-configuration
  &
  {:keys [acceptance-required client-token dry-run-request
          gateway-load-balancer-arns network-load-balancer-arns private-dns-name
          tag-specifications]
   :as create-vpc-endpoint-service-configuration-request})

create-vpc-peering-connection clj

(create-vpc-peering-connection)

(create-vpc-peering-connection &
                               {:keys [dry-run-request peer-owner-id peer-region
                                       peer-vpc-id tag-specifications vpc-id]
                                :as create-vpc-peering-connection-request})

create-vpn-connection clj

(create-vpn-connection &
                       {:keys [customer-gateway-id dry-run-request options
                               tag-specifications transit-gateway-id type
                               vpn-gateway-id]
                        :as create-vpn-connection-request})

create-vpn-connection-route clj

(create-vpn-connection-route &
                             {:keys [destination-cidr-block dry-run-request
                                     vpn-connection-id]
                              :as create-vpn-connection-route-request})

create-vpn-gateway clj

(create-vpn-gateway &
                    {:keys [amazon-side-asn availability-zone dry-run-request
                            tag-specifications type]
                     :as create-vpn-gateway-request})

delete-carrier-gateway clj

(delete-carrier-gateway &
                        {:keys [carrier-gateway-id dry-run-request]
                         :as delete-carrier-gateway-request})

delete-client-vpn-endpoint clj

(delete-client-vpn-endpoint &
                            {:keys [client-vpn-endpoint-id dry-run-request]
                             :as delete-client-vpn-endpoint-request})

delete-client-vpn-route clj

(delete-client-vpn-route &
                         {:keys [client-vpn-endpoint-id destination-cidr-block
                                 dry-run-request target-vpc-subnet-id]
                          :as delete-client-vpn-route-request})

delete-customer-gateway clj

(delete-customer-gateway &
                         {:keys [customer-gateway-id dry-run-request]
                          :as delete-customer-gateway-request})

delete-dhcp-options clj

(delete-dhcp-options &
                     {:keys [dhcp-options-id dry-run-request]
                      :as delete-dhcp-options-request})

delete-egress-only-internet-gateway clj

(delete-egress-only-internet-gateway
  &
  {:keys [dry-run-request egress-only-internet-gateway-id]
   :as delete-egress-only-internet-gateway-request})

delete-fleets clj

(delete-fleets &
               {:keys [dry-run-request fleet-ids terminate-instances]
                :as delete-fleets-request})

delete-flow-logs clj

(delete-flow-logs &
                  {:keys [dry-run-request flow-log-ids]
                   :as delete-flow-logs-request})

delete-fpga-image clj

(delete-fpga-image &
                   {:keys [dry-run-request fpga-image-id]
                    :as delete-fpga-image-request})

delete-internet-gateway clj

(delete-internet-gateway &
                         {:keys [dry-run-request internet-gateway-id]
                          :as delete-internet-gateway-request})

delete-key-pair clj

(delete-key-pair &
                 {:keys [dry-run-request key-name key-pair-id]
                  :as delete-key-pair-request})

delete-launch-template clj

(delete-launch-template &
                        {:keys [dry-run-request launch-template-id
                                launch-template-name]
                         :as delete-launch-template-request})

delete-launch-template-versions clj

(delete-launch-template-versions &
                                 {:keys [dry-run-request launch-template-id
                                         launch-template-name versions]
                                  :as delete-launch-template-versions-request})

delete-local-gateway-route clj

(delete-local-gateway-route &
                            {:keys [destination-cidr-block dry-run-request
                                    local-gateway-route-table-id]
                             :as delete-local-gateway-route-request})

delete-local-gateway-route-table-vpc-association clj

(delete-local-gateway-route-table-vpc-association
  &
  {:keys [dry-run-request local-gateway-route-table-vpc-association-id]
   :as delete-local-gateway-route-table-vpc-association-request})

delete-managed-prefix-list clj

(delete-managed-prefix-list &
                            {:keys [dry-run-request prefix-list-id]
                             :as delete-managed-prefix-list-request})

delete-nat-gateway clj

(delete-nat-gateway &
                    {:keys [dry-run-request nat-gateway-id]
                     :as delete-nat-gateway-request})

delete-network-acl clj

(delete-network-acl &
                    {:keys [dry-run-request network-acl-id]
                     :as delete-network-acl-request})

delete-network-acl-entry clj

(delete-network-acl-entry &
                          {:keys [dry-run-request egress network-acl-id
                                  rule-number]
                           :as delete-network-acl-entry-request})

delete-network-insights-analysis clj

(delete-network-insights-analysis
  &
  {:keys [dry-run-request network-insights-analysis-id]
   :as delete-network-insights-analysis-request})

delete-network-insights-path clj

(delete-network-insights-path &
                              {:keys [dry-run-request network-insights-path-id]
                               :as delete-network-insights-path-request})

delete-network-interface clj

(delete-network-interface &
                          {:keys [dry-run-request network-interface-id]
                           :as delete-network-interface-request})

delete-network-interface-permission clj

(delete-network-interface-permission
  &
  {:keys [dry-run-request force network-interface-permission-id]
   :as delete-network-interface-permission-request})

delete-placement-group clj

(delete-placement-group &
                        {:keys [dry-run-request group-name]
                         :as delete-placement-group-request})

delete-queued-reserved-instances clj

(delete-queued-reserved-instances
  &
  {:keys [dry-run-request reserved-instances-ids]
   :as delete-queued-reserved-instances-request})

delete-route clj

(delete-route &
              {:keys [destination-cidr-block destination-ipv6-cidr-block
                      destination-prefix-list-id dry-run-request route-table-id]
               :as delete-route-request})

delete-route-table clj

(delete-route-table &
                    {:keys [dry-run-request route-table-id]
                     :as delete-route-table-request})

delete-security-group clj

(delete-security-group &
                       {:keys [dry-run-request group-id group-name]
                        :as delete-security-group-request})

delete-snapshot clj

(delete-snapshot &
                 {:keys [dry-run-request snapshot-id]
                  :as delete-snapshot-request})

delete-spot-datafeed-subscription clj

(delete-spot-datafeed-subscription)

(delete-spot-datafeed-subscription
  &
  {:keys [dry-run-request] :as delete-spot-datafeed-subscription-request})

delete-subnet clj

(delete-subnet & {:keys [dry-run-request subnet-id] :as delete-subnet-request})

delete-tags clj

(delete-tags & {:keys [dry-run-request resources tags] :as delete-tags-request})

delete-traffic-mirror-filter clj

(delete-traffic-mirror-filter &
                              {:keys [dry-run-request traffic-mirror-filter-id]
                               :as delete-traffic-mirror-filter-request})

delete-traffic-mirror-filter-rule clj

(delete-traffic-mirror-filter-rule
  &
  {:keys [dry-run-request traffic-mirror-filter-rule-id]
   :as delete-traffic-mirror-filter-rule-request})

delete-traffic-mirror-session clj

(delete-traffic-mirror-session &
                               {:keys [dry-run-request
                                       traffic-mirror-session-id]
                                :as delete-traffic-mirror-session-request})

delete-traffic-mirror-target clj

(delete-traffic-mirror-target &
                              {:keys [dry-run-request traffic-mirror-target-id]
                               :as delete-traffic-mirror-target-request})

delete-transit-gateway clj

(delete-transit-gateway &
                        {:keys [dry-run-request transit-gateway-id]
                         :as delete-transit-gateway-request})

delete-transit-gateway-connect clj

(delete-transit-gateway-connect &
                                {:keys [dry-run-request
                                        transit-gateway-attachment-id]
                                 :as delete-transit-gateway-connect-request})

delete-transit-gateway-connect-peer clj

(delete-transit-gateway-connect-peer
  &
  {:keys [dry-run-request transit-gateway-connect-peer-id]
   :as delete-transit-gateway-connect-peer-request})

delete-transit-gateway-multicast-domain clj

(delete-transit-gateway-multicast-domain
  &
  {:keys [dry-run-request transit-gateway-multicast-domain-id]
   :as delete-transit-gateway-multicast-domain-request})

delete-transit-gateway-peering-attachment clj

(delete-transit-gateway-peering-attachment
  &
  {:keys [dry-run-request transit-gateway-attachment-id]
   :as delete-transit-gateway-peering-attachment-request})

delete-transit-gateway-prefix-list-reference clj

(delete-transit-gateway-prefix-list-reference
  &
  {:keys [dry-run-request prefix-list-id transit-gateway-route-table-id]
   :as delete-transit-gateway-prefix-list-reference-request})

delete-transit-gateway-route clj

(delete-transit-gateway-route &
                              {:keys [destination-cidr-block dry-run-request
                                      transit-gateway-route-table-id]
                               :as delete-transit-gateway-route-request})

delete-transit-gateway-route-table clj

(delete-transit-gateway-route-table
  &
  {:keys [dry-run-request transit-gateway-route-table-id]
   :as delete-transit-gateway-route-table-request})

delete-transit-gateway-vpc-attachment clj

(delete-transit-gateway-vpc-attachment
  &
  {:keys [dry-run-request transit-gateway-attachment-id]
   :as delete-transit-gateway-vpc-attachment-request})

delete-volume clj

(delete-volume & {:keys [dry-run-request volume-id] :as delete-volume-request})

delete-vpc clj

(delete-vpc & {:keys [dry-run-request vpc-id] :as delete-vpc-request})

delete-vpc-endpoint-connection-notifications clj

(delete-vpc-endpoint-connection-notifications
  &
  {:keys [connection-notification-ids dry-run-request]
   :as delete-vpc-endpoint-connection-notifications-request})

delete-vpc-endpoint-service-configurations clj

(delete-vpc-endpoint-service-configurations
  &
  {:keys [dry-run-request service-ids]
   :as delete-vpc-endpoint-service-configurations-request})

delete-vpc-endpoints clj

(delete-vpc-endpoints &
                      {:keys [dry-run-request vpc-endpoint-ids]
                       :as delete-vpc-endpoints-request})

delete-vpc-peering-connection clj

(delete-vpc-peering-connection &
                               {:keys [dry-run-request
                                       vpc-peering-connection-id]
                                :as delete-vpc-peering-connection-request})

delete-vpn-connection clj

(delete-vpn-connection &
                       {:keys [dry-run-request vpn-connection-id]
                        :as delete-vpn-connection-request})

delete-vpn-connection-route clj

(delete-vpn-connection-route &
                             {:keys [destination-cidr-block dry-run-request
                                     vpn-connection-id]
                              :as delete-vpn-connection-route-request})

delete-vpn-gateway clj

(delete-vpn-gateway &
                    {:keys [dry-run-request vpn-gateway-id]
                     :as delete-vpn-gateway-request})

deprovision-byoip-cidr clj

(deprovision-byoip-cidr &
                        {:keys [cidr dry-run-request]
                         :as deprovision-byoip-cidr-request})

deregister-image clj

(deregister-image &
                  {:keys [dry-run-request image-id]
                   :as deregister-image-request})

deregister-instance-event-notification-attributes clj

(deregister-instance-event-notification-attributes
  &
  {:keys [dry-run-request instance-tag-attribute]
   :as deregister-instance-event-notification-attributes-request})

deregister-transit-gateway-multicast-group-members clj

(deregister-transit-gateway-multicast-group-members
  &
  {:keys [dry-run-request group-ip-address network-interface-ids
          transit-gateway-multicast-domain-id]
   :as deregister-transit-gateway-multicast-group-members-request})

deregister-transit-gateway-multicast-group-sources clj

(deregister-transit-gateway-multicast-group-sources
  &
  {:keys [dry-run-request group-ip-address network-interface-ids
          transit-gateway-multicast-domain-id]
   :as deregister-transit-gateway-multicast-group-sources-request})

describe-account-attributes clj

(describe-account-attributes)

(describe-account-attributes &
                             {:keys [attribute-names dry-run-request]
                              :as describe-account-attributes-request})

describe-addresses clj

(describe-addresses)

(describe-addresses &
                    {:keys [allocation-ids dry-run-request filters public-ips]
                     :as describe-addresses-request})

describe-addresses-attribute clj

(describe-addresses-attribute &
                              {:keys [allocation-ids attribute dry-run-request
                                      max-results next-token]
                               :as describe-addresses-attribute-request})

describe-aggregate-id-format clj

(describe-aggregate-id-format &
                              {:keys [dry-run-request]
                               :as describe-aggregate-id-format-request})

describe-availability-zones clj

(describe-availability-zones)

(describe-availability-zones &
                             {:keys [all-availability-zones dry-run-request
                                     filters zone-ids zone-names]
                              :as describe-availability-zones-request})

describe-bundle-tasks clj

(describe-bundle-tasks)

(describe-bundle-tasks &
                       {:keys [bundle-ids dry-run-request filters]
                        :as describe-bundle-tasks-request})

describe-byoip-cidrs clj

(describe-byoip-cidrs &
                      {:keys [dry-run-request max-results next-token]
                       :as describe-byoip-cidrs-request})

describe-capacity-reservations clj

(describe-capacity-reservations &
                                {:keys [capacity-reservation-ids dry-run-request
                                        filters max-results next-token]
                                 :as describe-capacity-reservations-request})

describe-carrier-gateways clj

(describe-carrier-gateways &
                           {:keys [carrier-gateway-ids dry-run-request filters
                                   max-results next-token]
                            :as describe-carrier-gateways-request})

describe-classic-link-instances clj

(describe-classic-link-instances)

(describe-classic-link-instances &
                                 {:keys [dry-run-request filters instance-ids
                                         max-results next-token]
                                  :as describe-classic-link-instances-request})

describe-client-vpn-authorization-rules clj

(describe-client-vpn-authorization-rules
  &
  {:keys [client-vpn-endpoint-id dry-run-request filters max-results next-token]
   :as describe-client-vpn-authorization-rules-request})

describe-client-vpn-connections clj

(describe-client-vpn-connections &
                                 {:keys [client-vpn-endpoint-id dry-run-request
                                         filters max-results next-token]
                                  :as describe-client-vpn-connections-request})

describe-client-vpn-endpoints clj

(describe-client-vpn-endpoints &
                               {:keys [client-vpn-endpoint-ids dry-run-request
                                       filters max-results next-token]
                                :as describe-client-vpn-endpoints-request})

describe-client-vpn-routes clj

(describe-client-vpn-routes &
                            {:keys [client-vpn-endpoint-id dry-run-request
                                    filters max-results next-token]
                             :as describe-client-vpn-routes-request})

describe-client-vpn-target-networks clj

(describe-client-vpn-target-networks
  &
  {:keys [association-ids client-vpn-endpoint-id dry-run-request filters
          max-results next-token]
   :as describe-client-vpn-target-networks-request})

describe-coip-pools clj

(describe-coip-pools &
                     {:keys [dry-run-request filters max-results next-token
                             pool-ids]
                      :as describe-coip-pools-request})

describe-conversion-tasks clj

(describe-conversion-tasks)

(describe-conversion-tasks &
                           {:keys [conversion-task-ids dry-run-request]
                            :as describe-conversion-tasks-request})

describe-customer-gateways clj

(describe-customer-gateways)

(describe-customer-gateways &
                            {:keys [customer-gateway-ids dry-run-request
                                    filters]
                             :as describe-customer-gateways-request})

describe-dhcp-options clj

(describe-dhcp-options)

(describe-dhcp-options &
                       {:keys [dhcp-options-ids dry-run-request filters
                               max-results next-token]
                        :as describe-dhcp-options-request})

describe-egress-only-internet-gateways clj

(describe-egress-only-internet-gateways
  &
  {:keys [dry-run-request egress-only-internet-gateway-ids filters max-results
          next-token]
   :as describe-egress-only-internet-gateways-request})

describe-elastic-gpus clj

(describe-elastic-gpus &
                       {:keys [dry-run-request elastic-gpu-ids filters
                               max-results next-token]
                        :as describe-elastic-gpus-request})

describe-export-image-tasks clj

(describe-export-image-tasks &
                             {:keys [dry-run-request export-image-task-ids
                                     filters max-results next-token]
                              :as describe-export-image-tasks-request})

describe-export-tasks clj

(describe-export-tasks)

(describe-export-tasks &
                       {:keys [dry-run-request export-task-ids filters]
                        :as describe-export-tasks-request})

describe-fast-snapshot-restores clj

(describe-fast-snapshot-restores &
                                 {:keys [dry-run-request filters max-results
                                         next-token]
                                  :as describe-fast-snapshot-restores-request})

describe-fleet-history clj

(describe-fleet-history &
                        {:keys [dry-run-request event-type fleet-id max-results
                                next-token start-time]
                         :as describe-fleet-history-request})

describe-fleet-instances clj

(describe-fleet-instances &
                          {:keys [dry-run-request filters fleet-id max-results
                                  next-token]
                           :as describe-fleet-instances-request})

describe-fleets clj

(describe-fleets &
                 {:keys [dry-run-request filters fleet-ids max-results
                         next-token]
                  :as describe-fleets-request})

describe-flow-logs clj

(describe-flow-logs)

(describe-flow-logs &
                    {:keys [dry-run-request filter flow-log-ids max-results
                            next-token]
                     :as describe-flow-logs-request})

describe-fpga-image-attribute clj

(describe-fpga-image-attribute &
                               {:keys [attribute dry-run-request fpga-image-id]
                                :as describe-fpga-image-attribute-request})

describe-fpga-images clj

(describe-fpga-images &
                      {:keys [dry-run-request filters fpga-image-ids max-results
                              next-token owners]
                       :as describe-fpga-images-request})

describe-host-reservation-offerings clj

(describe-host-reservation-offerings
  &
  {:keys [dry-run-request filter max-duration max-results min-duration
          next-token offering-id]
   :as describe-host-reservation-offerings-request})

describe-host-reservations clj

(describe-host-reservations
  &
  {:keys [dry-run-request filter host-reservation-id-set max-results next-token]
   :as describe-host-reservations-request})

describe-hosts clj

(describe-hosts)

(describe-hosts &
                {:keys [dry-run-request filter host-ids max-results next-token]
                 :as describe-hosts-request})

describe-iam-instance-profile-associations clj

(describe-iam-instance-profile-associations
  &
  {:keys [association-ids dry-run-request filters max-results next-token]
   :as describe-iam-instance-profile-associations-request})

describe-id-format clj

(describe-id-format)

(describe-id-format &
                    {:keys [dry-run-request resource]
                     :as describe-id-format-request})

describe-identity-id-format clj

(describe-identity-id-format &
                             {:keys [dry-run-request principal-arn resource]
                              :as describe-identity-id-format-request})

describe-image-attribute clj

(describe-image-attribute &
                          {:keys [attribute dry-run-request image-id]
                           :as describe-image-attribute-request})

describe-images clj

(describe-images)

(describe-images &
                 {:keys [dry-run-request executable-users filters image-ids
                         owners]
                  :as describe-images-request})

describe-import-image-tasks clj

(describe-import-image-tasks)

(describe-import-image-tasks &
                             {:keys [dry-run-request filters import-task-ids
                                     max-results next-token]
                              :as describe-import-image-tasks-request})

describe-import-snapshot-tasks clj

(describe-import-snapshot-tasks)

(describe-import-snapshot-tasks &
                                {:keys [dry-run-request filters import-task-ids
                                        max-results next-token]
                                 :as describe-import-snapshot-tasks-request})

describe-instance-attribute clj

(describe-instance-attribute &
                             {:keys [attribute dry-run-request instance-id]
                              :as describe-instance-attribute-request})

describe-instance-credit-specifications clj

(describe-instance-credit-specifications
  &
  {:keys [dry-run-request filters instance-ids max-results next-token]
   :as describe-instance-credit-specifications-request})

describe-instance-event-notification-attributes clj

(describe-instance-event-notification-attributes
  &
  {:keys [dry-run-request]
   :as describe-instance-event-notification-attributes-request})

describe-instance-status clj

(describe-instance-status)

(describe-instance-status &
                          {:keys [dry-run-request filters include-all-instances
                                  instance-ids max-results next-token]
                           :as describe-instance-status-request})

describe-instance-type-offerings clj

(describe-instance-type-offerings
  &
  {:keys [dry-run-request filters location-type max-results next-token]
   :as describe-instance-type-offerings-request})

describe-instance-types clj

(describe-instance-types &
                         {:keys [dry-run-request filters instance-types
                                 max-results next-token]
                          :as describe-instance-types-request})

describe-instances clj

(describe-instances)

(describe-instances &
                    {:keys [dry-run-request filters instance-ids max-results
                            next-token]
                     :as describe-instances-request})

describe-internet-gateways clj

(describe-internet-gateways)

(describe-internet-gateways &
                            {:keys [dry-run-request filters internet-gateway-ids
                                    max-results next-token]
                             :as describe-internet-gateways-request})

describe-ipv6-pools clj

(describe-ipv6-pools &
                     {:keys [dry-run-request filters max-results next-token
                             pool-ids]
                      :as describe-ipv6-pools-request})

describe-ipv6pools clj

(describe-ipv6pools &
                    {:keys [dry-run-request filters max-results next-token
                            pool-ids]
                     :as describe-ipv6-pools-request})

describe-key-pairs clj

(describe-key-pairs)

(describe-key-pairs &
                    {:keys [dry-run-request filters key-names key-pair-ids]
                     :as describe-key-pairs-request})

describe-launch-template-versions clj

(describe-launch-template-versions
  &
  {:keys [dry-run-request filters launch-template-id launch-template-name
          max-results max-version min-version next-token versions]
   :as describe-launch-template-versions-request})

describe-launch-templates clj

(describe-launch-templates &
                           {:keys [dry-run-request filters launch-template-ids
                                   launch-template-names max-results next-token]
                            :as describe-launch-templates-request})

describe-local-gateway-route-table-virtual-interface-group-associations clj

(describe-local-gateway-route-table-virtual-interface-group-associations
  &
  {:keys [dry-run-request filters
          local-gateway-route-table-virtual-interface-group-association-ids
          max-results next-token]
   :as
     describe-local-gateway-route-table-virtual-interface-group-associations-request})

describe-local-gateway-route-table-vpc-associations clj

(describe-local-gateway-route-table-vpc-associations
  &
  {:keys [dry-run-request filters local-gateway-route-table-vpc-association-ids
          max-results next-token]
   :as describe-local-gateway-route-table-vpc-associations-request})

describe-local-gateway-route-tables clj

(describe-local-gateway-route-tables
  &
  {:keys [dry-run-request filters local-gateway-route-table-ids max-results
          next-token]
   :as describe-local-gateway-route-tables-request})

describe-local-gateway-virtual-interface-groups clj

(describe-local-gateway-virtual-interface-groups
  &
  {:keys [dry-run-request filters local-gateway-virtual-interface-group-ids
          max-results next-token]
   :as describe-local-gateway-virtual-interface-groups-request})

describe-local-gateway-virtual-interfaces clj

(describe-local-gateway-virtual-interfaces
  &
  {:keys [dry-run-request filters local-gateway-virtual-interface-ids
          max-results next-token]
   :as describe-local-gateway-virtual-interfaces-request})

describe-local-gateways clj

(describe-local-gateways &
                         {:keys [dry-run-request filters local-gateway-ids
                                 max-results next-token]
                          :as describe-local-gateways-request})

describe-managed-prefix-lists clj

(describe-managed-prefix-lists &
                               {:keys [dry-run-request filters max-results
                                       next-token prefix-list-ids]
                                :as describe-managed-prefix-lists-request})

describe-moving-addresses clj

(describe-moving-addresses)

(describe-moving-addresses &
                           {:keys [dry-run-request filters max-results
                                   next-token public-ips]
                            :as describe-moving-addresses-request})

describe-nat-gateways clj

(describe-nat-gateways &
                       {:keys [dry-run-request filter max-results
                               nat-gateway-ids next-token]
                        :as describe-nat-gateways-request})

describe-network-acls clj

(describe-network-acls)

(describe-network-acls &
                       {:keys [dry-run-request filters max-results
                               network-acl-ids next-token]
                        :as describe-network-acls-request})

describe-network-insights-analyses clj

(describe-network-insights-analyses
  &
  {:keys [analysis-end-time analysis-start-time dry-run-request filters
          max-results network-insights-analysis-ids network-insights-path-id
          next-token]
   :as describe-network-insights-analyses-request})

describe-network-insights-paths clj

(describe-network-insights-paths &
                                 {:keys [dry-run-request filters max-results
                                         network-insights-path-ids next-token]
                                  :as describe-network-insights-paths-request})

describe-network-interface-attribute clj

(describe-network-interface-attribute
  &
  {:keys [attribute dry-run-request network-interface-id]
   :as describe-network-interface-attribute-request})

describe-network-interface-permissions clj

(describe-network-interface-permissions
  &
  {:keys [dry-run-request filters max-results network-interface-permission-ids
          next-token]
   :as describe-network-interface-permissions-request})

describe-network-interfaces clj

(describe-network-interfaces)

(describe-network-interfaces &
                             {:keys [dry-run-request filters max-results
                                     network-interface-ids next-token]
                              :as describe-network-interfaces-request})

describe-placement-groups clj

(describe-placement-groups)

(describe-placement-groups &
                           {:keys [dry-run-request filters group-ids
                                   group-names]
                            :as describe-placement-groups-request})

describe-prefix-lists clj

(describe-prefix-lists)

(describe-prefix-lists &
                       {:keys [dry-run-request filters max-results next-token
                               prefix-list-ids]
                        :as describe-prefix-lists-request})

describe-principal-id-format clj

(describe-principal-id-format &
                              {:keys [dry-run-request max-results next-token
                                      resources]
                               :as describe-principal-id-format-request})

describe-public-ipv4-pools clj

(describe-public-ipv4-pools &
                            {:keys [dry-run-request filters max-results
                                    next-token pool-ids]
                             :as describe-public-ipv4-pools-request})

describe-public-ipv4pools clj

(describe-public-ipv4pools &
                           {:keys [dry-run-request filters max-results
                                   next-token pool-ids]
                            :as describe-public-ipv4-pools-request})

describe-regions clj

(describe-regions)

(describe-regions &
                  {:keys [all-regions dry-run-request filters region-names]
                   :as describe-regions-request})

describe-reserved-instances clj

(describe-reserved-instances)

(describe-reserved-instances &
                             {:keys [dry-run-request filters offering-class
                                     offering-type reserved-instances-ids]
                              :as describe-reserved-instances-request})

describe-reserved-instances-listings clj

(describe-reserved-instances-listings)

(describe-reserved-instances-listings
  &
  {:keys [dry-run-request filters reserved-instances-id
          reserved-instances-listing-id]
   :as describe-reserved-instances-listings-request})

describe-reserved-instances-modifications clj

(describe-reserved-instances-modifications)

(describe-reserved-instances-modifications
  &
  {:keys [dry-run-request filters next-token
          reserved-instances-modification-ids]
   :as describe-reserved-instances-modifications-request})

describe-reserved-instances-offerings clj

(describe-reserved-instances-offerings)

(describe-reserved-instances-offerings
  &
  {:keys [availability-zone dry-run-request filters include-marketplace
          instance-tenancy instance-type max-duration max-instance-count
          max-results min-duration next-token offering-class offering-type
          product-description reserved-instances-offering-ids]
   :as describe-reserved-instances-offerings-request})

describe-route-tables clj

(describe-route-tables)

(describe-route-tables &
                       {:keys [dry-run-request filters max-results next-token
                               route-table-ids]
                        :as describe-route-tables-request})

describe-scheduled-instance-availability clj

(describe-scheduled-instance-availability
  &
  {:keys [dry-run-request filters first-slot-start-time-range max-results
          max-slot-duration-in-hours min-slot-duration-in-hours next-token
          recurrence]
   :as describe-scheduled-instance-availability-request})

describe-scheduled-instances clj

(describe-scheduled-instances &
                              {:keys [dry-run-request filters max-results
                                      next-token scheduled-instance-ids
                                      slot-start-time-range]
                               :as describe-scheduled-instances-request})

describe-security-group-references clj

(describe-security-group-references
  &
  {:keys [dry-run-request group-id]
   :as describe-security-group-references-request})

describe-security-groups clj

(describe-security-groups)

(describe-security-groups &
                          {:keys [dry-run-request filters group-ids group-names
                                  max-results next-token]
                           :as describe-security-groups-request})

describe-snapshot-attribute clj

(describe-snapshot-attribute &
                             {:keys [attribute dry-run-request snapshot-id]
                              :as describe-snapshot-attribute-request})

describe-snapshots clj

(describe-snapshots)

(describe-snapshots &
                    {:keys [dry-run-request filters max-results next-token
                            owner-ids restorable-by-user-ids snapshot-ids]
                     :as describe-snapshots-request})

describe-spot-datafeed-subscription clj

(describe-spot-datafeed-subscription)

(describe-spot-datafeed-subscription
  &
  {:keys [dry-run-request] :as describe-spot-datafeed-subscription-request})

describe-spot-fleet-instances clj

(describe-spot-fleet-instances &
                               {:keys [dry-run-request max-results next-token
                                       spot-fleet-request-id]
                                :as describe-spot-fleet-instances-request})

describe-spot-fleet-request-history clj

(describe-spot-fleet-request-history
  &
  {:keys [dry-run-request event-type max-results next-token
          spot-fleet-request-id start-time]
   :as describe-spot-fleet-request-history-request})

describe-spot-fleet-requests clj

(describe-spot-fleet-requests)

(describe-spot-fleet-requests &
                              {:keys [dry-run-request max-results next-token
                                      spot-fleet-request-ids]
                               :as describe-spot-fleet-requests-request})

describe-spot-instance-requests clj

(describe-spot-instance-requests)

(describe-spot-instance-requests &
                                 {:keys [dry-run-request filters max-results
                                         next-token spot-instance-request-ids]
                                  :as describe-spot-instance-requests-request})

describe-spot-price-history clj

(describe-spot-price-history)

(describe-spot-price-history &
                             {:keys [availability-zone dry-run-request end-time
                                     filters instance-types max-results
                                     next-token product-descriptions start-time]
                              :as describe-spot-price-history-request})

describe-stale-security-groups clj

(describe-stale-security-groups &
                                {:keys [dry-run-request max-results next-token
                                        vpc-id]
                                 :as describe-stale-security-groups-request})

describe-subnets clj

(describe-subnets)

(describe-subnets &
                  {:keys [dry-run-request filters max-results next-token
                          subnet-ids]
                   :as describe-subnets-request})

describe-tags clj

(describe-tags)

(describe-tags &
               {:keys [dry-run-request filters max-results next-token]
                :as describe-tags-request})

describe-traffic-mirror-filters clj

(describe-traffic-mirror-filters &
                                 {:keys [dry-run-request filters max-results
                                         next-token traffic-mirror-filter-ids]
                                  :as describe-traffic-mirror-filters-request})

describe-traffic-mirror-sessions clj

(describe-traffic-mirror-sessions &
                                  {:keys [dry-run-request filters max-results
                                          next-token traffic-mirror-session-ids]
                                   :as
                                     describe-traffic-mirror-sessions-request})

describe-traffic-mirror-targets clj

(describe-traffic-mirror-targets &
                                 {:keys [dry-run-request filters max-results
                                         next-token traffic-mirror-target-ids]
                                  :as describe-traffic-mirror-targets-request})

describe-transit-gateway-attachments clj

(describe-transit-gateway-attachments
  &
  {:keys [dry-run-request filters max-results next-token
          transit-gateway-attachment-ids]
   :as describe-transit-gateway-attachments-request})

describe-transit-gateway-connect-peers clj

(describe-transit-gateway-connect-peers
  &
  {:keys [dry-run-request filters max-results next-token
          transit-gateway-connect-peer-ids]
   :as describe-transit-gateway-connect-peers-request})

describe-transit-gateway-connects clj

(describe-transit-gateway-connects
  &
  {:keys [dry-run-request filters max-results next-token
          transit-gateway-attachment-ids]
   :as describe-transit-gateway-connects-request})

describe-transit-gateway-multicast-domains clj

(describe-transit-gateway-multicast-domains
  &
  {:keys [dry-run-request filters max-results next-token
          transit-gateway-multicast-domain-ids]
   :as describe-transit-gateway-multicast-domains-request})

describe-transit-gateway-peering-attachments clj

(describe-transit-gateway-peering-attachments
  &
  {:keys [dry-run-request filters max-results next-token
          transit-gateway-attachment-ids]
   :as describe-transit-gateway-peering-attachments-request})

describe-transit-gateway-route-tables clj

(describe-transit-gateway-route-tables
  &
  {:keys [dry-run-request filters max-results next-token
          transit-gateway-route-table-ids]
   :as describe-transit-gateway-route-tables-request})

describe-transit-gateway-vpc-attachments clj

(describe-transit-gateway-vpc-attachments
  &
  {:keys [dry-run-request filters max-results next-token
          transit-gateway-attachment-ids]
   :as describe-transit-gateway-vpc-attachments-request})

describe-transit-gateways clj

(describe-transit-gateways &
                           {:keys [dry-run-request filters max-results
                                   next-token transit-gateway-ids]
                            :as describe-transit-gateways-request})

describe-volume-attribute clj

(describe-volume-attribute &
                           {:keys [attribute dry-run-request volume-id]
                            :as describe-volume-attribute-request})

describe-volume-status clj

(describe-volume-status)

(describe-volume-status &
                        {:keys [dry-run-request filters max-results next-token
                                volume-ids]
                         :as describe-volume-status-request})

describe-volumes clj

(describe-volumes)

(describe-volumes &
                  {:keys [dry-run-request filters max-results next-token
                          volume-ids]
                   :as describe-volumes-request})

describe-volumes-modifications clj

(describe-volumes-modifications &
                                {:keys [dry-run-request filters max-results
                                        next-token volume-ids]
                                 :as describe-volumes-modifications-request})

describe-vpc-attribute clj

(describe-vpc-attribute &
                        {:keys [attribute dry-run-request vpc-id]
                         :as describe-vpc-attribute-request})

describe-vpc-classic-link clj

(describe-vpc-classic-link)

(describe-vpc-classic-link &
                           {:keys [dry-run-request filters vpc-ids]
                            :as describe-vpc-classic-link-request})

describe-vpc-classic-link-dns-support clj

(describe-vpc-classic-link-dns-support
  &
  {:keys [dry-run-request max-results next-token vpc-ids]
   :as describe-vpc-classic-link-dns-support-request})

describe-vpc-endpoint-connection-notifications clj

(describe-vpc-endpoint-connection-notifications
  &
  {:keys [connection-notification-id dry-run-request filters max-results
          next-token]
   :as describe-vpc-endpoint-connection-notifications-request})

describe-vpc-endpoint-connections clj

(describe-vpc-endpoint-connections
  &
  {:keys [dry-run-request filters max-results next-token]
   :as describe-vpc-endpoint-connections-request})

describe-vpc-endpoint-service-configurations clj

(describe-vpc-endpoint-service-configurations
  &
  {:keys [dry-run-request filters max-results next-token service-ids]
   :as describe-vpc-endpoint-service-configurations-request})

describe-vpc-endpoint-service-permissions clj

(describe-vpc-endpoint-service-permissions
  &
  {:keys [dry-run-request filters max-results next-token service-id]
   :as describe-vpc-endpoint-service-permissions-request})

describe-vpc-endpoint-services clj

(describe-vpc-endpoint-services)

(describe-vpc-endpoint-services &
                                {:keys [dry-run-request filters max-results
                                        next-token service-names]
                                 :as describe-vpc-endpoint-services-request})

describe-vpc-endpoints clj

(describe-vpc-endpoints)

(describe-vpc-endpoints &
                        {:keys [dry-run-request filters max-results next-token
                                vpc-endpoint-ids]
                         :as describe-vpc-endpoints-request})

describe-vpc-peering-connections clj

(describe-vpc-peering-connections)

(describe-vpc-peering-connections &
                                  {:keys [dry-run-request filters max-results
                                          next-token vpc-peering-connection-ids]
                                   :as
                                     describe-vpc-peering-connections-request})

describe-vpcs clj

(describe-vpcs)

(describe-vpcs &
               {:keys [dry-run-request filters max-results next-token vpc-ids]
                :as describe-vpcs-request})

describe-vpn-connections clj

(describe-vpn-connections)

(describe-vpn-connections &
                          {:keys [dry-run-request filters vpn-connection-ids]
                           :as describe-vpn-connections-request})

describe-vpn-gateways clj

(describe-vpn-gateways)

(describe-vpn-gateways &
                       {:keys [dry-run-request filters vpn-gateway-ids]
                        :as describe-vpn-gateways-request})

detach-classic-link-vpc clj

(detach-classic-link-vpc &
                         {:keys [dry-run-request instance-id vpc-id]
                          :as detach-classic-link-vpc-request})

detach-internet-gateway clj

(detach-internet-gateway &
                         {:keys [dry-run-request internet-gateway-id vpc-id]
                          :as detach-internet-gateway-request})

detach-network-interface clj

(detach-network-interface &
                          {:keys [attachment-id dry-run-request force]
                           :as detach-network-interface-request})

detach-volume clj

(detach-volume &
               {:keys [device dry-run-request force instance-id volume-id]
                :as detach-volume-request})

detach-vpn-gateway clj

(detach-vpn-gateway &
                    {:keys [dry-run-request vpc-id vpn-gateway-id]
                     :as detach-vpn-gateway-request})

disable-ebs-encryption-by-default clj

(disable-ebs-encryption-by-default
  &
  {:keys [dry-run-request] :as disable-ebs-encryption-by-default-request})

disable-fast-snapshot-restores clj

(disable-fast-snapshot-restores &
                                {:keys [availability-zones dry-run-request
                                        source-snapshot-ids]
                                 :as disable-fast-snapshot-restores-request})

disable-transit-gateway-route-table-propagation clj

(disable-transit-gateway-route-table-propagation
  &
  {:keys [dry-run-request transit-gateway-attachment-id
          transit-gateway-route-table-id]
   :as disable-transit-gateway-route-table-propagation-request})

disable-vgw-route-propagation clj

(disable-vgw-route-propagation &
                               {:keys [dry-run-request gateway-id
                                       route-table-id]
                                :as disable-vgw-route-propagation-request})

disable-vpc-classic-link clj

(disable-vpc-classic-link &
                          {:keys [dry-run-request vpc-id]
                           :as disable-vpc-classic-link-request})

disable-vpc-classic-link-dns-support clj

(disable-vpc-classic-link-dns-support
  &
  {:keys [dry-run-request vpc-id]
   :as disable-vpc-classic-link-dns-support-request})

disassociate-address clj

(disassociate-address &
                      {:keys [association-id dry-run-request public-ip]
                       :as disassociate-address-request})

disassociate-client-vpn-target-network clj

(disassociate-client-vpn-target-network
  &
  {:keys [association-id client-vpn-endpoint-id dry-run-request]
   :as disassociate-client-vpn-target-network-request})

disassociate-enclave-certificate-iam-role clj

(disassociate-enclave-certificate-iam-role
  &
  {:keys [certificate-arn dry-run-request role-arn]
   :as disassociate-enclave-certificate-iam-role-request})

disassociate-iam-instance-profile clj

(disassociate-iam-instance-profile
  &
  {:keys [association-id dry-run-request]
   :as disassociate-iam-instance-profile-request})

disassociate-route-table clj

(disassociate-route-table &
                          {:keys [association-id dry-run-request]
                           :as disassociate-route-table-request})

disassociate-subnet-cidr-block clj

(disassociate-subnet-cidr-block &
                                {:keys [association-id dry-run-request]
                                 :as disassociate-subnet-cidr-block-request})

disassociate-transit-gateway-multicast-domain clj

(disassociate-transit-gateway-multicast-domain
  &
  {:keys [dry-run-request subnet-ids transit-gateway-attachment-id
          transit-gateway-multicast-domain-id]
   :as disassociate-transit-gateway-multicast-domain-request})

disassociate-transit-gateway-route-table clj

(disassociate-transit-gateway-route-table
  &
  {:keys [dry-run-request transit-gateway-attachment-id
          transit-gateway-route-table-id]
   :as disassociate-transit-gateway-route-table-request})

disassociate-vpc-cidr-block clj

(disassociate-vpc-cidr-block &
                             {:keys [association-id dry-run-request]
                              :as disassociate-vpc-cidr-block-request})

dry-run clj

(dry-run & [dry-run-supported-request])

enable-ebs-encryption-by-default clj

(enable-ebs-encryption-by-default
  &
  {:keys [dry-run-request] :as enable-ebs-encryption-by-default-request})

enable-fast-snapshot-restores clj

(enable-fast-snapshot-restores &
                               {:keys [availability-zones dry-run-request
                                       source-snapshot-ids]
                                :as enable-fast-snapshot-restores-request})

enable-transit-gateway-route-table-propagation clj

(enable-transit-gateway-route-table-propagation
  &
  {:keys [dry-run-request transit-gateway-attachment-id
          transit-gateway-route-table-id]
   :as enable-transit-gateway-route-table-propagation-request})

enable-vgw-route-propagation clj

(enable-vgw-route-propagation &
                              {:keys [dry-run-request gateway-id route-table-id]
                               :as enable-vgw-route-propagation-request})

enable-volume-io clj

(enable-volume-io &
                  {:keys [dry-run-request volume-id]
                   :as enable-volume-iorequest})

enable-vpc-classic-link clj

(enable-vpc-classic-link &
                         {:keys [dry-run-request vpc-id]
                          :as enable-vpc-classic-link-request})

enable-vpc-classic-link-dns-support clj

(enable-vpc-classic-link-dns-support
  &
  {:keys [dry-run-request vpc-id]
   :as enable-vpc-classic-link-dns-support-request})

export-client-vpn-client-certificate-revocation-list clj

(export-client-vpn-client-certificate-revocation-list
  &
  {:keys [client-vpn-endpoint-id dry-run-request]
   :as export-client-vpn-client-certificate-revocation-list-request})

export-client-vpn-client-configuration clj

(export-client-vpn-client-configuration
  &
  {:keys [client-vpn-endpoint-id dry-run-request]
   :as export-client-vpn-client-configuration-request})

export-image clj

(export-image &
              {:keys [client-token description disk-image-format dry-run-request
                      image-id role-name s3-export-location tag-specifications]
               :as export-image-request})

export-transit-gateway-routes clj

(export-transit-gateway-routes &
                               {:keys [dry-run-request filters s3-bucket
                                       transit-gateway-route-table-id]
                                :as export-transit-gateway-routes-request})

get-associated-enclave-certificate-iam-roles clj

(get-associated-enclave-certificate-iam-roles
  &
  {:keys [certificate-arn dry-run-request]
   :as get-associated-enclave-certificate-iam-roles-request})

get-associated-ipv6-pool-cidrs clj

(get-associated-ipv6-pool-cidrs &
                                {:keys [dry-run-request max-results next-token
                                        pool-id]
                                 :as get-associated-ipv6-pool-cidrs-request})

get-associated-ipv6pool-cidrs clj

(get-associated-ipv6pool-cidrs &
                               {:keys [dry-run-request max-results next-token
                                       pool-id]
                                :as get-associated-ipv6-pool-cidrs-request})

get-cached-response-metadata clj

(get-cached-response-metadata & [amazon-web-service-request])

get-capacity-reservation-usage clj

(get-capacity-reservation-usage &
                                {:keys [capacity-reservation-id dry-run-request
                                        max-results next-token]
                                 :as get-capacity-reservation-usage-request})

get-coip-pool-usage clj

(get-coip-pool-usage &
                     {:keys [dry-run-request filters max-results next-token
                             pool-id]
                      :as get-coip-pool-usage-request})

get-console-output clj

(get-console-output &
                    {:keys [dry-run-request instance-id latest]
                     :as get-console-output-request})

get-console-screenshot clj

(get-console-screenshot &
                        {:keys [dry-run-request instance-id wake-up]
                         :as get-console-screenshot-request})

get-default-credit-specification clj

(get-default-credit-specification &
                                  {:keys [dry-run-request instance-family]
                                   :as
                                     get-default-credit-specification-request})

get-ebs-default-kms-key-id clj

(get-ebs-default-kms-key-id &
                            {:keys [dry-run-request]
                             :as get-ebs-default-kms-key-id-request})

get-ebs-encryption-by-default clj

(get-ebs-encryption-by-default &
                               {:keys [dry-run-request]
                                :as get-ebs-encryption-by-default-request})

get-groups-for-capacity-reservation clj

(get-groups-for-capacity-reservation
  &
  {:keys [capacity-reservation-id dry-run-request max-results next-token]
   :as get-groups-for-capacity-reservation-request})

get-host-reservation-purchase-preview clj

(get-host-reservation-purchase-preview
  &
  {:keys [dry-run-request host-id-set offering-id]
   :as get-host-reservation-purchase-preview-request})

get-launch-template-data clj

(get-launch-template-data &
                          {:keys [dry-run-request instance-id]
                           :as get-launch-template-data-request})

get-managed-prefix-list-associations clj

(get-managed-prefix-list-associations
  &
  {:keys [dry-run-request max-results next-token prefix-list-id]
   :as get-managed-prefix-list-associations-request})

get-managed-prefix-list-entries clj

(get-managed-prefix-list-entries &
                                 {:keys [dry-run-request max-results next-token
                                         prefix-list-id target-version]
                                  :as get-managed-prefix-list-entries-request})

get-password-data clj

(get-password-data &
                   {:keys [dry-run-request instance-id]
                    :as get-password-data-request})

get-reserved-instances-exchange-quote clj

(get-reserved-instances-exchange-quote
  &
  {:keys [dry-run-request reserved-instance-ids target-configurations]
   :as get-reserved-instances-exchange-quote-request})

get-transit-gateway-attachment-propagations clj

(get-transit-gateway-attachment-propagations
  &
  {:keys [dry-run-request filters max-results next-token
          transit-gateway-attachment-id]
   :as get-transit-gateway-attachment-propagations-request})

get-transit-gateway-multicast-domain-associations clj

(get-transit-gateway-multicast-domain-associations
  &
  {:keys [dry-run-request filters max-results next-token
          transit-gateway-multicast-domain-id]
   :as get-transit-gateway-multicast-domain-associations-request})

get-transit-gateway-prefix-list-references clj

(get-transit-gateway-prefix-list-references
  &
  {:keys [dry-run-request filters max-results next-token
          transit-gateway-route-table-id]
   :as get-transit-gateway-prefix-list-references-request})

get-transit-gateway-route-table-associations clj

(get-transit-gateway-route-table-associations
  &
  {:keys [dry-run-request filters max-results next-token
          transit-gateway-route-table-id]
   :as get-transit-gateway-route-table-associations-request})

get-transit-gateway-route-table-propagations clj

(get-transit-gateway-route-table-propagations
  &
  {:keys [dry-run-request filters max-results next-token
          transit-gateway-route-table-id]
   :as get-transit-gateway-route-table-propagations-request})

import-client-vpn-client-certificate-revocation-list clj

(import-client-vpn-client-certificate-revocation-list
  &
  {:keys [certificate-revocation-list client-vpn-endpoint-id dry-run-request]
   :as import-client-vpn-client-certificate-revocation-list-request})

import-image clj

(import-image)

(import-image &
              {:keys [architecture client-data client-token description
                      disk-containers dry-run-request encrypted hypervisor
                      kms-key-id license-specifications license-type platform
                      role-name tag-specifications]
               :as import-image-request})

import-instance clj

(import-instance &
                 {:keys [description disk-images dry-run-request
                         launch-specification platform]
                  :as import-instance-request})

import-key-pair clj

(import-key-pair &
                 {:keys [dry-run-request key-name public-key-material
                         tag-specifications]
                  :as import-key-pair-request})

import-snapshot clj

(import-snapshot)

(import-snapshot &
                 {:keys [client-data client-token description disk-container
                         dry-run-request encrypted kms-key-id role-name
                         tag-specifications]
                  :as import-snapshot-request})

import-volume clj

(import-volume &
               {:keys [availability-zone description dry-run-request image
                       volume]
                :as import-volume-request})

modify-address-attribute clj

(modify-address-attribute &
                          {:keys [allocation-id domain-name dry-run-request]
                           :as modify-address-attribute-request})

modify-availability-zone-group clj

(modify-availability-zone-group &
                                {:keys [dry-run-request group-name
                                        opt-in-status]
                                 :as modify-availability-zone-group-request})

modify-capacity-reservation clj

(modify-capacity-reservation &
                             {:keys [accept capacity-reservation-id
                                     dry-run-request end-date end-date-type
                                     instance-count]
                              :as modify-capacity-reservation-request})

modify-client-vpn-endpoint clj

(modify-client-vpn-endpoint
  &
  {:keys [client-connect-options client-vpn-endpoint-id connection-log-options
          description dns-servers dry-run-request security-group-ids
          self-service-portal server-certificate-arn split-tunnel vpc-id
          vpn-port]
   :as modify-client-vpn-endpoint-request})

modify-default-credit-specification clj

(modify-default-credit-specification
  &
  {:keys [cpu-credits dry-run-request instance-family]
   :as modify-default-credit-specification-request})

modify-ebs-default-kms-key-id clj

(modify-ebs-default-kms-key-id &
                               {:keys [dry-run-request kms-key-id]
                                :as modify-ebs-default-kms-key-id-request})

modify-fleet clj

(modify-fleet &
              {:keys [dry-run-request excess-capacity-termination-policy
                      fleet-id launch-template-configs
                      target-capacity-specification]
               :as modify-fleet-request})

modify-fpga-image-attribute clj

(modify-fpga-image-attribute
  &
  {:keys [attribute description dry-run-request fpga-image-id load-permission
          name operation-type product-codes user-groups user-ids]
   :as modify-fpga-image-attribute-request})

modify-hosts clj

(modify-hosts &
              {:keys [auto-placement dry-run-request host-ids host-recovery
                      instance-family instance-type]
               :as modify-hosts-request})

modify-id-format clj

(modify-id-format &
                  {:keys [dry-run-request resource use-long-ids]
                   :as modify-id-format-request})

modify-identity-id-format clj

(modify-identity-id-format &
                           {:keys [dry-run-request principal-arn resource
                                   use-long-ids]
                            :as modify-identity-id-format-request})

modify-image-attribute clj

(modify-image-attribute &
                        {:keys [attribute description dry-run-request image-id
                                launch-permission operation-type product-codes
                                user-groups user-ids value]
                         :as modify-image-attribute-request})

modify-instance-attribute clj

(modify-instance-attribute
  &
  {:keys [attribute block-device-mappings disable-api-termination
          dry-run-request ebs-optimized ena-support groups instance-id
          instance-initiated-shutdown-behavior instance-type kernel ramdisk
          source-dest-check sriov-net-support user-data value]
   :as modify-instance-attribute-request})

modify-instance-capacity-reservation-attributes clj

(modify-instance-capacity-reservation-attributes
  &
  {:keys [capacity-reservation-specification dry-run-request instance-id]
   :as modify-instance-capacity-reservation-attributes-request})

modify-instance-credit-specification clj

(modify-instance-credit-specification
  &
  {:keys [client-token dry-run-request instance-credit-specifications]
   :as modify-instance-credit-specification-request})

modify-instance-event-start-time clj

(modify-instance-event-start-time
  &
  {:keys [dry-run-request instance-event-id instance-id not-before]
   :as modify-instance-event-start-time-request})

modify-instance-metadata-options clj

(modify-instance-metadata-options
  &
  {:keys [dry-run-request http-endpoint http-put-response-hop-limit http-tokens
          instance-id]
   :as modify-instance-metadata-options-request})

modify-instance-placement clj

(modify-instance-placement &
                           {:keys [affinity dry-run-request group-name host-id
                                   host-resource-group-arn instance-id
                                   partition-number tenancy]
                            :as modify-instance-placement-request})

modify-launch-template clj

(modify-launch-template &
                        {:keys [client-token default-version dry-run-request
                                launch-template-id launch-template-name]
                         :as modify-launch-template-request})

modify-managed-prefix-list clj

(modify-managed-prefix-list &
                            {:keys [add-entries current-version dry-run-request
                                    prefix-list-id prefix-list-name
                                    remove-entries]
                             :as modify-managed-prefix-list-request})

modify-network-interface-attribute clj

(modify-network-interface-attribute
  &
  {:keys [attachment description dry-run-request groups network-interface-id
          source-dest-check]
   :as modify-network-interface-attribute-request})

modify-reserved-instances clj

(modify-reserved-instances &
                           {:keys [client-token dry-run-request
                                   reserved-instances-ids target-configurations]
                            :as modify-reserved-instances-request})

modify-snapshot-attribute clj

(modify-snapshot-attribute &
                           {:keys [attribute create-volume-permission
                                   dry-run-request group-names operation-type
                                   snapshot-id user-ids]
                            :as modify-snapshot-attribute-request})

modify-spot-fleet-request clj

(modify-spot-fleet-request
  &
  {:keys [dry-run-request excess-capacity-termination-policy
          launch-template-configs on-demand-target-capacity
          spot-fleet-request-id target-capacity]
   :as modify-spot-fleet-request-request})

modify-subnet-attribute clj

(modify-subnet-attribute &
                         {:keys [assign-ipv6-address-on-creation
                                 customer-owned-ipv4-pool dry-run-request
                                 map-customer-owned-ip-on-launch
                                 map-public-ip-on-launch subnet-id]
                          :as modify-subnet-attribute-request})

modify-traffic-mirror-filter-network-services clj

(modify-traffic-mirror-filter-network-services
  &
  {:keys [add-network-services dry-run-request remove-network-services
          traffic-mirror-filter-id]
   :as modify-traffic-mirror-filter-network-services-request})

modify-traffic-mirror-filter-rule clj

(modify-traffic-mirror-filter-rule
  &
  {:keys [description destination-cidr-block destination-port-range
          dry-run-request protocol remove-fields rule-action rule-number
          source-cidr-block source-port-range traffic-direction
          traffic-mirror-filter-rule-id]
   :as modify-traffic-mirror-filter-rule-request})

modify-traffic-mirror-session clj

(modify-traffic-mirror-session
  &
  {:keys [description dry-run-request packet-length remove-fields session-number
          traffic-mirror-filter-id traffic-mirror-session-id
          traffic-mirror-target-id virtual-network-id]
   :as modify-traffic-mirror-session-request})

modify-transit-gateway clj

(modify-transit-gateway &
                        {:keys [description dry-run-request options
                                transit-gateway-id]
                         :as modify-transit-gateway-request})

modify-transit-gateway-prefix-list-reference clj

(modify-transit-gateway-prefix-list-reference
  &
  {:keys [blackhole dry-run-request prefix-list-id transit-gateway-attachment-id
          transit-gateway-route-table-id]
   :as modify-transit-gateway-prefix-list-reference-request})

modify-transit-gateway-vpc-attachment clj

(modify-transit-gateway-vpc-attachment
  &
  {:keys [add-subnet-ids dry-run-request options remove-subnet-ids
          transit-gateway-attachment-id]
   :as modify-transit-gateway-vpc-attachment-request})

modify-volume clj

(modify-volume &
               {:keys [dry-run-request iops multi-attach-enabled size throughput
                       volume-id volume-type]
                :as modify-volume-request})

modify-volume-attribute clj

(modify-volume-attribute &
                         {:keys [auto-enable-io dry-run-request volume-id]
                          :as modify-volume-attribute-request})

modify-vpc-attribute clj

(modify-vpc-attribute &
                      {:keys [dry-run-request enable-dns-hostnames
                              enable-dns-support vpc-id]
                       :as modify-vpc-attribute-request})

modify-vpc-endpoint clj

(modify-vpc-endpoint &
                     {:keys [add-route-table-ids add-security-group-ids
                             add-subnet-ids dry-run-request policy-document
                             private-dns-enabled remove-route-table-ids
                             remove-security-group-ids remove-subnet-ids
                             reset-policy vpc-endpoint-id]
                      :as modify-vpc-endpoint-request})

modify-vpc-endpoint-connection-notification clj

(modify-vpc-endpoint-connection-notification
  &
  {:keys [connection-events connection-notification-arn
          connection-notification-id dry-run-request]
   :as modify-vpc-endpoint-connection-notification-request})

modify-vpc-endpoint-service-configuration clj

(modify-vpc-endpoint-service-configuration
  &
  {:keys [acceptance-required add-gateway-load-balancer-arns
          add-network-load-balancer-arns dry-run-request private-dns-name
          remove-gateway-load-balancer-arns remove-network-load-balancer-arns
          remove-private-dns-name service-id]
   :as modify-vpc-endpoint-service-configuration-request})

modify-vpc-endpoint-service-permissions clj

(modify-vpc-endpoint-service-permissions
  &
  {:keys [add-allowed-principals dry-run-request remove-allowed-principals
          service-id]
   :as modify-vpc-endpoint-service-permissions-request})

modify-vpc-peering-connection-options clj

(modify-vpc-peering-connection-options
  &
  {:keys [accepter-peering-connection-options dry-run-request
          requester-peering-connection-options vpc-peering-connection-id]
   :as modify-vpc-peering-connection-options-request})

modify-vpc-tenancy clj

(modify-vpc-tenancy &
                    {:keys [dry-run-request instance-tenancy vpc-id]
                     :as modify-vpc-tenancy-request})

modify-vpn-connection clj

(modify-vpn-connection &
                       {:keys [customer-gateway-id dry-run-request
                               transit-gateway-id vpn-connection-id
                               vpn-gateway-id]
                        :as modify-vpn-connection-request})

modify-vpn-connection-options clj

(modify-vpn-connection-options
  &
  {:keys [dry-run-request local-ipv4-network-cidr local-ipv6-network-cidr
          remote-ipv4-network-cidr remote-ipv6-network-cidr vpn-connection-id]
   :as modify-vpn-connection-options-request})

modify-vpn-tunnel-certificate clj

(modify-vpn-tunnel-certificate &
                               {:keys [dry-run-request vpn-connection-id
                                       vpn-tunnel-outside-ip-address]
                                :as modify-vpn-tunnel-certificate-request})

modify-vpn-tunnel-options clj

(modify-vpn-tunnel-options &
                           {:keys [dry-run-request tunnel-options
                                   vpn-connection-id
                                   vpn-tunnel-outside-ip-address]
                            :as modify-vpn-tunnel-options-request})

monitor-instances clj

(monitor-instances &
                   {:keys [dry-run-request instance-ids]
                    :as monitor-instances-request})

move-address-to-vpc clj

(move-address-to-vpc &
                     {:keys [dry-run-request public-ip]
                      :as move-address-to-vpc-request})

provision-byoip-cidr clj

(provision-byoip-cidr &
                      {:keys [cidr cidr-authorization-context description
                              dry-run-request pool-tag-specifications
                              publicly-advertisable]
                       :as provision-byoip-cidr-request})

purchase-host-reservation clj

(purchase-host-reservation &
                           {:keys [client-token currency-code dry-run-request
                                   host-id-set limit-price offering-id
                                   tag-specifications]
                            :as purchase-host-reservation-request})

purchase-reserved-instances-offering clj

(purchase-reserved-instances-offering
  &
  {:keys [dry-run-request instance-count limit-price purchase-time
          reserved-instances-offering-id]
   :as purchase-reserved-instances-offering-request})

purchase-scheduled-instances clj

(purchase-scheduled-instances &
                              {:keys [client-token dry-run-request
                                      purchase-requests]
                               :as purchase-scheduled-instances-request})

reboot-instances clj

(reboot-instances &
                  {:keys [dry-run-request instance-ids]
                   :as reboot-instances-request})

register-image clj

(register-image &
                {:keys [architecture billing-products block-device-mappings
                        description dry-run-request ena-support image-location
                        kernel-id name ramdisk-id root-device-name
                        sriov-net-support virtualization-type]
                 :as register-image-request})

register-instance-event-notification-attributes clj

(register-instance-event-notification-attributes
  &
  {:keys [dry-run-request instance-tag-attribute]
   :as register-instance-event-notification-attributes-request})

register-transit-gateway-multicast-group-members clj

(register-transit-gateway-multicast-group-members
  &
  {:keys [dry-run-request group-ip-address network-interface-ids
          transit-gateway-multicast-domain-id]
   :as register-transit-gateway-multicast-group-members-request})

register-transit-gateway-multicast-group-sources clj

(register-transit-gateway-multicast-group-sources
  &
  {:keys [dry-run-request group-ip-address network-interface-ids
          transit-gateway-multicast-domain-id]
   :as register-transit-gateway-multicast-group-sources-request})

reject-transit-gateway-multicast-domain-associations clj

(reject-transit-gateway-multicast-domain-associations
  &
  {:keys [dry-run-request subnet-ids transit-gateway-attachment-id
          transit-gateway-multicast-domain-id]
   :as reject-transit-gateway-multicast-domain-associations-request})

reject-transit-gateway-peering-attachment clj

(reject-transit-gateway-peering-attachment
  &
  {:keys [dry-run-request transit-gateway-attachment-id]
   :as reject-transit-gateway-peering-attachment-request})

reject-transit-gateway-vpc-attachment clj

(reject-transit-gateway-vpc-attachment
  &
  {:keys [dry-run-request transit-gateway-attachment-id]
   :as reject-transit-gateway-vpc-attachment-request})

reject-vpc-endpoint-connections clj

(reject-vpc-endpoint-connections &
                                 {:keys [dry-run-request service-id
                                         vpc-endpoint-ids]
                                  :as reject-vpc-endpoint-connections-request})

reject-vpc-peering-connection clj

(reject-vpc-peering-connection &
                               {:keys [dry-run-request
                                       vpc-peering-connection-id]
                                :as reject-vpc-peering-connection-request})

release-address clj

(release-address &
                 {:keys [allocation-id dry-run-request network-border-group
                         public-ip]
                  :as release-address-request})

release-hosts clj

(release-hosts & {:keys [dry-run-request host-ids] :as release-hosts-request})

replace-iam-instance-profile-association clj

(replace-iam-instance-profile-association
  &
  {:keys [association-id dry-run-request iam-instance-profile]
   :as replace-iam-instance-profile-association-request})

replace-network-acl-association clj

(replace-network-acl-association &
                                 {:keys [association-id dry-run-request
                                         network-acl-id]
                                  :as replace-network-acl-association-request})

replace-network-acl-entry clj

(replace-network-acl-entry &
                           {:keys [cidr-block dry-run-request egress
                                   icmp-type-code ipv6-cidr-block network-acl-id
                                   port-range protocol rule-action rule-number]
                            :as replace-network-acl-entry-request})

replace-route clj

(replace-route &
               {:keys [carrier-gateway-id destination-cidr-block
                       destination-ipv6-cidr-block destination-prefix-list-id
                       dry-run-request egress-only-internet-gateway-id
                       gateway-id instance-id local-gateway-id local-target
                       nat-gateway-id network-interface-id route-table-id
                       transit-gateway-id vpc-endpoint-id
                       vpc-peering-connection-id]
                :as replace-route-request})

replace-route-table-association clj

(replace-route-table-association &
                                 {:keys [association-id dry-run-request
                                         route-table-id]
                                  :as replace-route-table-association-request})

replace-transit-gateway-route clj

(replace-transit-gateway-route
  &
  {:keys [blackhole destination-cidr-block dry-run-request
          transit-gateway-attachment-id transit-gateway-route-table-id]
   :as replace-transit-gateway-route-request})

report-instance-status clj

(report-instance-status &
                        {:keys [description dry-run-request end-time instances
                                reason-codes start-time status]
                         :as report-instance-status-request})

request-spot-fleet clj

(request-spot-fleet &
                    {:keys [dry-run-request spot-fleet-request-config]
                     :as request-spot-fleet-request})

request-spot-instances clj

(request-spot-instances &
                        {:keys [availability-zone-group block-duration-minutes
                                client-token dry-run-request instance-count
                                instance-interruption-behavior launch-group
                                launch-specification spot-price
                                tag-specifications type valid-from valid-until]
                         :as request-spot-instances-request})

reset-address-attribute clj

(reset-address-attribute &
                         {:keys [allocation-id attribute dry-run-request]
                          :as reset-address-attribute-request})

reset-ebs-default-kms-key-id clj

(reset-ebs-default-kms-key-id &
                              {:keys [dry-run-request]
                               :as reset-ebs-default-kms-key-id-request})

reset-fpga-image-attribute clj

(reset-fpga-image-attribute &
                            {:keys [attribute dry-run-request fpga-image-id]
                             :as reset-fpga-image-attribute-request})

reset-image-attribute clj

(reset-image-attribute &
                       {:keys [attribute dry-run-request image-id]
                        :as reset-image-attribute-request})

reset-instance-attribute clj

(reset-instance-attribute &
                          {:keys [attribute dry-run-request instance-id]
                           :as reset-instance-attribute-request})

reset-network-interface-attribute clj

(reset-network-interface-attribute
  &
  {:keys [dry-run-request network-interface-id source-dest-check]
   :as reset-network-interface-attribute-request})

reset-snapshot-attribute clj

(reset-snapshot-attribute &
                          {:keys [attribute dry-run-request snapshot-id]
                           :as reset-snapshot-attribute-request})

restore-address-to-classic clj

(restore-address-to-classic &
                            {:keys [dry-run-request public-ip]
                             :as restore-address-to-classic-request})

restore-managed-prefix-list-version clj

(restore-managed-prefix-list-version
  &
  {:keys [current-version dry-run-request prefix-list-id previous-version]
   :as restore-managed-prefix-list-version-request})

revoke-client-vpn-ingress clj

(revoke-client-vpn-ingress &
                           {:keys [access-group-id client-vpn-endpoint-id
                                   dry-run-request revoke-all-groups
                                   target-network-cidr]
                            :as revoke-client-vpn-ingress-request})

revoke-security-group-egress clj

(revoke-security-group-egress
  &
  {:keys [cidr-ip dry-run-request from-port group-id ip-permissions ip-protocol
          source-security-group-name source-security-group-owner-id to-port]
   :as revoke-security-group-egress-request})

revoke-security-group-ingress clj

(revoke-security-group-ingress)

(revoke-security-group-ingress &
                               {:keys [cidr-ip dry-run-request from-port
                                       group-id group-name ip-permissions
                                       ip-protocol source-security-group-name
                                       source-security-group-owner-id to-port]
                                :as revoke-security-group-ingress-request})

run-instances clj

(run-instances
  &
  {:keys [additional-info block-device-mappings
          capacity-reservation-specification client-token cpu-options
          credit-specification disable-api-termination dry-run-request
          ebs-optimized elastic-gpu-specification elastic-inference-accelerators
          enclave-options hibernation-options iam-instance-profile image-id
          instance-initiated-shutdown-behavior instance-market-options
          instance-type ipv6-address-count ipv6-addresses kernel-id key-name
          launch-template license-specifications max-count metadata-options
          min-count monitoring network-interfaces placement private-ip-address
          ramdisk-id security-group-ids security-groups subnet-id
          tag-specifications user-data]
   :as run-instances-request})

run-scheduled-instances clj

(run-scheduled-instances &
                         {:keys [client-token dry-run-request instance-count
                                 launch-specification scheduled-instance-id]
                          :as run-scheduled-instances-request})

search-local-gateway-routes clj

(search-local-gateway-routes &
                             {:keys [dry-run-request filters
                                     local-gateway-route-table-id max-results
                                     next-token]
                              :as search-local-gateway-routes-request})

search-transit-gateway-multicast-groups clj

(search-transit-gateway-multicast-groups
  &
  {:keys [dry-run-request filters max-results next-token
          transit-gateway-multicast-domain-id]
   :as search-transit-gateway-multicast-groups-request})

search-transit-gateway-routes clj

(search-transit-gateway-routes &
                               {:keys [dry-run-request filters max-results
                                       transit-gateway-route-table-id]
                                :as search-transit-gateway-routes-request})

send-diagnostic-interrupt clj

(send-diagnostic-interrupt &
                           {:keys [dry-run-request instance-id]
                            :as send-diagnostic-interrupt-request})

show-functions clj

shutdown clj

(shutdown)

start-instances clj

(start-instances &
                 {:keys [additional-info dry-run-request instance-ids]
                  :as start-instances-request})

start-network-insights-analysis clj

(start-network-insights-analysis &
                                 {:keys [client-token dry-run-request
                                         filter-in-arns network-insights-path-id
                                         tag-specifications]
                                  :as start-network-insights-analysis-request})

start-vpc-endpoint-service-private-dns-verification clj

(start-vpc-endpoint-service-private-dns-verification
  &
  {:keys [dry-run-request service-id]
   :as start-vpc-endpoint-service-private-dns-verification-request})

stop-instances clj

(stop-instances &
                {:keys [dry-run-request force hibernate instance-ids]
                 :as stop-instances-request})

terminate-client-vpn-connections clj

(terminate-client-vpn-connections
  &
  {:keys [client-vpn-endpoint-id connection-id dry-run-request username]
   :as terminate-client-vpn-connections-request})

terminate-instances clj

(terminate-instances &
                     {:keys [dry-run-request instance-ids]
                      :as terminate-instances-request})

unassign-ipv6-addresses clj

(unassign-ipv6-addresses &
                         {:keys [dry-run-request ipv6-addresses
                                 network-interface-id]
                          :as unassign-ipv6-addresses-request})

unassign-ipv6addresses clj

(unassign-ipv6addresses &
                        {:keys [dry-run-request ipv6-addresses
                                network-interface-id]
                         :as unassign-ipv6-addresses-request})

unassign-private-ip-addresses clj

(unassign-private-ip-addresses &
                               {:keys [dry-run-request network-interface-id
                                       private-ip-addresses]
                                :as unassign-private-ip-addresses-request})

unmonitor-instances clj

(unmonitor-instances &
                     {:keys [dry-run-request instance-ids]
                      :as unmonitor-instances-request})

update-security-group-rule-descriptions-egress clj

(update-security-group-rule-descriptions-egress
  &
  {:keys [dry-run-request group-id group-name ip-permissions]
   :as update-security-group-rule-descriptions-egress-request})

update-security-group-rule-descriptions-ingress clj

(update-security-group-rule-descriptions-ingress
  &
  {:keys [dry-run-request group-id group-name ip-permissions]
   :as update-security-group-rule-descriptions-ingress-request})

waiters clj

(waiters)

withdraw-byoip-cidr clj

(withdraw-byoip-cidr &
                     {:keys [cidr dry-run-request]
                      :as withdraw-byoip-cidr-request})