amazonica.aws.ec2 — com.signal-ai/amazonica 0.3.167-signal-1

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})

allocate-ipam-pool-cidr clj

(allocate-ipam-pool-cidr &
                         {:keys [cidr client-token description disallowed-cidrs
                                 dry-run-request ipam-pool-id netmask-length
                                 preview-next-cidr]
                          :as allocate-ipam-pool-cidr-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
                               ipv6-prefix-count ipv6-prefixes
                               network-interface-id]
                        :as assign-ipv6-addresses-request})

assign-ipv6addresses clj

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

assign-private-ip-addresses clj

(assign-private-ip-addresses &
                             {:keys [allow-reassignment dry-run-request
                                     ipv4-prefix-count ipv4-prefixes
                                     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-instance-event-window clj

(associate-instance-event-window &
                                 {:keys [association-target dry-run-request
                                         instance-event-window-id]
                                  :as associate-instance-event-window-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-trunk-interface clj

(associate-trunk-interface &
                           {:keys [branch-interface-id client-token
                                   dry-run-request gre-key trunk-interface-id
                                   vlan-id]
                            :as associate-trunk-interface-request})

associate-vpc-cidr-block clj

(associate-vpc-cidr-block
  &
  {:keys [amazon-provided-ipv6-cidr-block cidr-block dry-run-request
          ipv4-ipam-pool-id ipv4-netmask-length ipv6-cidr-block
          ipv6-cidr-block-network-border-group ipv6-ipam-pool-id
          ipv6-netmask-length 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
          tag-specifications 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
          tag-specifications 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-capacity-reservation-fleets clj

(cancel-capacity-reservation-fleets
  &
  {:keys [capacity-reservation-fleet-ids dry-run-request]
   :as cancel-capacity-reservation-fleets-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 outpost-arn
          tag-specifications tenancy]
   :as create-capacity-reservation-request})

create-capacity-reservation-fleet clj

(create-capacity-reservation-fleet
  &
  {:keys [allocation-strategy client-token dry-run-request end-date
          instance-match-criteria instance-type-specifications
          tag-specifications tenancy total-target-capacity]
   :as create-capacity-reservation-fleet-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 ipv6-native]
                        :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 context 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
                          destination-options 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-event-window clj

(create-instance-event-window &
                              {:keys [cron-expression dry-run-request name
                                      tag-specifications time-ranges]
                               :as create-instance-event-window-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-ipam clj

(create-ipam &
             {:keys [client-token description dry-run-request operating-regions
                     tag-specifications]
              :as create-ipam-request})

create-ipam-pool clj

(create-ipam-pool
  &
  {:keys [address-family allocation-default-netmask-length
          allocation-max-netmask-length allocation-min-netmask-length
          allocation-resource-tags auto-import aws-service client-token
          description dry-run-request ipam-scope-id locale publicly-advertisable
          source-ipam-pool-id tag-specifications]
   :as create-ipam-pool-request})

create-ipam-scope clj

(create-ipam-scope &
                   {:keys [client-token description dry-run-request ipam-id
                           tag-specifications]
                    :as create-ipam-scope-request})

create-key-pair clj

(create-key-pair &
                 {:keys [dry-run-request key-name key-type 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 connectivity-type
                            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-access-scope clj

(create-network-insights-access-scope
  &
  {:keys [client-token dry-run-request exclude-paths match-paths
          tag-specifications]
   :as create-network-insights-access-scope-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 [client-token description dry-run-request groups interface-type
          ipv4-prefix-count ipv4-prefixes ipv6-address-count ipv6-addresses
          ipv6-prefix-count ipv6-prefixes 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-public-ipv4-pool clj

(create-public-ipv4-pool &
                         {:keys [dry-run-request tag-specifications]
                          :as create-public-ipv4-pool-request})

create-public-ipv4pool clj

(create-public-ipv4pool &
                        {:keys [dry-run-request tag-specifications]
                         :as create-public-ipv4-pool-request})

create-replace-root-volume-task clj

(create-replace-root-volume-task &
                                 {:keys [client-token dry-run-request
                                         instance-id snapshot-id
                                         tag-specifications]
                                  :as create-replace-root-volume-task-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-restore-image-task clj

(create-restore-image-task &
                           {:keys [bucket dry-run-request name object-key
                                   tag-specifications]
                            :as create-restore-image-task-request})

create-route clj

(create-route &
              {:keys [carrier-gateway-id core-network-arn 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-store-image-task clj

(create-store-image-task &
                         {:keys [bucket dry-run-request image-id s3-object-tags]
                          :as create-store-image-task-request})

create-subnet clj

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

create-subnet-cidr-reservation clj

(create-subnet-cidr-reservation &
                                {:keys [cidr description dry-run-request
                                        reservation-type subnet-id
                                        tag-specifications]
                                 :as create-subnet-cidr-reservation-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 client-token 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 ipv4-ipam-pool-id ipv4-netmask-length
                    ipv6-cidr-block ipv6-cidr-block-network-border-group
                    ipv6-ipam-pool-id ipv6-netmask-length 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-instance-event-window clj

(delete-instance-event-window &
                              {:keys [dry-run-request force-delete
                                      instance-event-window-id]
                               :as delete-instance-event-window-request})

delete-internet-gateway clj

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

delete-ipam clj

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

delete-ipam-pool clj

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

delete-ipam-scope clj

(delete-ipam-scope &
                   {:keys [dry-run-request ipam-scope-id]
                    :as delete-ipam-scope-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-access-scope clj

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

delete-network-insights-access-scope-analysis clj

(delete-network-insights-access-scope-analysis
  &
  {:keys [dry-run-request network-insights-access-scope-analysis-id]
   :as delete-network-insights-access-scope-analysis-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-public-ipv4-pool clj

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

delete-public-ipv4pool clj

(delete-public-ipv4pool &
                        {:keys [dry-run-request pool-id]
                         :as delete-public-ipv4-pool-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-subnet-cidr-reservation clj

(delete-subnet-cidr-reservation &
                                {:keys [dry-run-request
                                        subnet-cidr-reservation-id]
                                 :as delete-subnet-cidr-reservation-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})

deprovision-ipam-pool-cidr clj

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

deprovision-public-ipv4-pool-cidr clj

(deprovision-public-ipv4-pool-cidr
  &
  {:keys [cidr dry-run-request pool-id]
   :as deprovision-public-ipv4-pool-cidr-request})

deprovision-public-ipv4pool-cidr clj

(deprovision-public-ipv4pool-cidr &
                                  {:keys [cidr dry-run-request pool-id]
                                   :as
                                     deprovision-public-ipv4-pool-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-reservation-fleets clj

(describe-capacity-reservation-fleets
  &
  {:keys [capacity-reservation-fleet-ids dry-run-request filters max-results
          next-token]
   :as describe-capacity-reservation-fleets-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
                         include-deprecated 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-event-windows clj

(describe-instance-event-windows &
                                 {:keys [dry-run-request filters
                                         instance-event-window-ids max-results
                                         next-token]
                                  :as describe-instance-event-windows-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-ipam-pools clj

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

describe-ipam-scopes clj

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

describe-ipams clj

(describe-ipams &
                {:keys [dry-run-request filters ipam-ids max-results next-token]
                 :as describe-ipams-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-access-scope-analyses clj

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

describe-network-insights-access-scopes clj

(describe-network-insights-access-scopes
  &
  {:keys [dry-run-request filters max-results network-insights-access-scope-ids
          next-token]
   :as describe-network-insights-access-scopes-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-replace-root-volume-tasks clj

(describe-replace-root-volume-tasks
  &
  {:keys [dry-run-request filters max-results next-token
          replace-root-volume-task-ids]
   :as describe-replace-root-volume-tasks-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-group-rules clj

(describe-security-group-rules &
                               {:keys [dry-run-request filters max-results
                                       next-token security-group-rule-ids]
                                :as describe-security-group-rules-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-snapshot-tier-status clj

(describe-snapshot-tier-status &
                               {:keys [dry-run-request filters max-results
                                       next-token]
                                :as describe-snapshot-tier-status-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-store-image-tasks clj

(describe-store-image-tasks &
                            {:keys [dry-run-request filters image-ids
                                    max-results next-token]
                             :as describe-store-image-tasks-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-trunk-interface-associations clj

(describe-trunk-interface-associations
  &
  {:keys [association-ids dry-run-request filters max-results next-token]
   :as describe-trunk-interface-associations-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-image-deprecation clj

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

disable-ipam-organization-admin-account clj

(disable-ipam-organization-admin-account
  &
  {:keys [delegated-admin-account-id dry-run-request]
   :as disable-ipam-organization-admin-account-request})

disable-serial-console-access clj

(disable-serial-console-access &
                               {:keys [dry-run-request]
                                :as disable-serial-console-access-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-instance-event-window clj

(disassociate-instance-event-window
  &
  {:keys [association-target dry-run-request instance-event-window-id]
   :as disassociate-instance-event-window-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-trunk-interface clj

(disassociate-trunk-interface &
                              {:keys [association-id client-token
                                      dry-run-request]
                               :as disassociate-trunk-interface-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-image-deprecation clj

(enable-image-deprecation &
                          {:keys [deprecate-at dry-run-request image-id]
                           :as enable-image-deprecation-request})

enable-ipam-organization-admin-account clj

(enable-ipam-organization-admin-account
  &
  {:keys [delegated-admin-account-id dry-run-request]
   :as enable-ipam-organization-admin-account-request})

enable-serial-console-access clj

(enable-serial-console-access &
                              {:keys [dry-run-request]
                               :as enable-serial-console-access-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-flow-logs-integration-template clj

(get-flow-logs-integration-template
  &
  {:keys [config-delivery-s3-destination-arn dry-run-request flow-log-id
          integrate-services]
   :as get-flow-logs-integration-template-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-instance-types-from-instance-requirements clj

(get-instance-types-from-instance-requirements
  &
  {:keys [architecture-types dry-run-request instance-requirements max-results
          next-token virtualization-types]
   :as get-instance-types-from-instance-requirements-request})

get-ipam-address-history clj

(get-ipam-address-history &
                          {:keys [cidr dry-run-request end-time ipam-scope-id
                                  max-results next-token start-time vpc-id]
                           :as get-ipam-address-history-request})

get-ipam-pool-allocations clj

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

get-ipam-pool-cidrs clj

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

get-ipam-resource-cidrs clj

(get-ipam-resource-cidrs
  &
  {:keys [dry-run-request filters ipam-pool-id ipam-scope-id max-results
          next-token resource-id resource-owner resource-tag resource-type]
   :as get-ipam-resource-cidrs-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-network-insights-access-scope-analysis-findings clj

(get-network-insights-access-scope-analysis-findings
  &
  {:keys [dry-run-request max-results network-insights-access-scope-analysis-id
          next-token]
   :as get-network-insights-access-scope-analysis-findings-request})

get-network-insights-access-scope-content clj

(get-network-insights-access-scope-content
  &
  {:keys [dry-run-request network-insights-access-scope-id]
   :as get-network-insights-access-scope-content-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-serial-console-access-status clj

(get-serial-console-access-status
  &
  {:keys [dry-run-request] :as get-serial-console-access-status-request})

get-spot-placement-scores clj

(get-spot-placement-scores
  &
  {:keys [dry-run-request instance-requirements-with-metadata instance-types
          max-results next-token region-names single-availability-zone
          target-capacity target-capacity-unit-type]
   :as get-spot-placement-scores-request})

get-subnet-cidr-reservations clj

(get-subnet-cidr-reservations &
                              {:keys [dry-run-request filters max-results
                                      next-token subnet-id]
                               :as get-subnet-cidr-reservations-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})

get-vpn-connection-device-sample-configuration clj

(get-vpn-connection-device-sample-configuration
  &
  {:keys [dry-run-request internet-key-exchange-version
          vpn-connection-device-type-id vpn-connection-id]
   :as get-vpn-connection-device-sample-configuration-request})

get-vpn-connection-device-types clj

(get-vpn-connection-device-types &
                                 {:keys [dry-run-request max-results next-token]
                                  :as get-vpn-connection-device-types-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 boot-mode client-data client-token
                      description disk-containers dry-run-request encrypted
                      hypervisor kms-key-id license-specifications license-type
                      platform role-name tag-specifications usage-operation]
               :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})

list-snapshots-in-recycle-bin clj

(list-snapshots-in-recycle-bin &
                               {:keys [dry-run-request max-results next-token
                                       snapshot-ids]
                                :as list-snapshots-in-recycle-bin-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 additional-info
                                     capacity-reservation-id dry-run-request
                                     end-date end-date-type instance-count]
                              :as modify-capacity-reservation-request})

modify-capacity-reservation-fleet clj

(modify-capacity-reservation-fleet
  &
  {:keys [capacity-reservation-fleet-id dry-run-request end-date remove-end-date
          total-target-capacity]
   :as modify-capacity-reservation-fleet-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 [context 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
                                organization-arns organizational-unit-arns
                                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-event-window clj

(modify-instance-event-window &
                              {:keys [cron-expression dry-run-request
                                      instance-event-window-id name time-ranges]
                               :as modify-instance-event-window-request})

modify-instance-metadata-options clj

(modify-instance-metadata-options
  &
  {:keys [dry-run-request http-endpoint http-protocol-ipv6
          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-ipam clj

(modify-ipam &
             {:keys [add-operating-regions description dry-run-request ipam-id
                     remove-operating-regions]
              :as modify-ipam-request})

modify-ipam-pool clj

(modify-ipam-pool
  &
  {:keys [add-allocation-resource-tags allocation-default-netmask-length
          allocation-max-netmask-length allocation-min-netmask-length
          auto-import clear-allocation-default-netmask-length description
          dry-run-request ipam-pool-id remove-allocation-resource-tags]
   :as modify-ipam-pool-request})

modify-ipam-resource-cidr clj

(modify-ipam-resource-cidr
  &
  {:keys [current-ipam-scope-id destination-ipam-scope-id dry-run-request
          monitored resource-cidr resource-id resource-region]
   :as modify-ipam-resource-cidr-request})

modify-ipam-scope clj

(modify-ipam-scope &
                   {:keys [description dry-run-request ipam-scope-id]
                    :as modify-ipam-scope-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
                                    max-entries 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-private-dns-name-options clj

(modify-private-dns-name-options &
                                 {:keys [dry-run-request
                                         enable-resource-name-dns-a-record
                                         enable-resource-name-dns-aaaa-record
                                         instance-id private-dns-hostname-type]
                                  :as modify-private-dns-name-options-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-security-group-rules clj

(modify-security-group-rules &
                             {:keys [dry-run-request group-id
                                     security-group-rules]
                              :as modify-security-group-rules-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-snapshot-tier clj

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

modify-spot-fleet-request clj

(modify-spot-fleet-request
  &
  {:keys [context 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
          disable-lni-at-device-index dry-run-request enable-dns64
          enable-lni-at-device-index enable-resource-name-dns-a-record-on-launch
          enable-resource-name-dns-aaaa-record-on-launch
          map-customer-owned-ip-on-launch map-public-ip-on-launch
          private-dns-hostname-type-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})

move-byoip-cidr-to-ipam clj

(move-byoip-cidr-to-ipam &
                         {:keys [cidr dry-run-request ipam-pool-id
                                 ipam-pool-owner]
                          :as move-byoip-cidr-to-ipam-request})

provision-byoip-cidr clj

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

provision-ipam-pool-cidr clj

(provision-ipam-pool-cidr &
                          {:keys [cidr cidr-authorization-context
                                  dry-run-request ipam-pool-id]
                           :as provision-ipam-pool-cidr-request})

provision-public-ipv4-pool-cidr clj

(provision-public-ipv4-pool-cidr &
                                 {:keys [dry-run-request ipam-pool-id
                                         netmask-length pool-id]
                                  :as provision-public-ipv4-pool-cidr-request})

provision-public-ipv4pool-cidr clj

(provision-public-ipv4pool-cidr &
                                {:keys [dry-run-request ipam-pool-id
                                        netmask-length pool-id]
                                 :as provision-public-ipv4-pool-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
                        boot-mode 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})

release-ipam-pool-allocation clj

(release-ipam-pool-allocation &
                              {:keys [cidr dry-run-request
                                      ipam-pool-allocation-id ipam-pool-id]
                               :as release-ipam-pool-allocation-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 core-network-arn
                       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})

restore-snapshot-from-recycle-bin clj

(restore-snapshot-from-recycle-bin
  &
  {:keys [dry-run-request snapshot-id]
   :as restore-snapshot-from-recycle-bin-request})

restore-snapshot-tier clj

(restore-snapshot-tier &
                       {:keys [dry-run-request permanent-restore snapshot-id
                               temporary-restore-days]
                        :as restore-snapshot-tier-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
          security-group-rule-ids 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 security-group-rule-ids 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-dns-name-options 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-access-scope-analysis clj

(start-network-insights-access-scope-analysis
  &
  {:keys [client-token dry-run-request network-insights-access-scope-id
          tag-specifications]
   :as start-network-insights-access-scope-analysis-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 ipv6-prefixes
                                 network-interface-id]
                          :as unassign-ipv6-addresses-request})

unassign-ipv6addresses clj

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

unassign-private-ip-addresses clj

(unassign-private-ip-addresses &
                               {:keys [dry-run-request ipv4-prefixes
                                       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
          security-group-rule-descriptions]
   :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
          security-group-rule-descriptions]
   :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})