amazonica.aws.lightsail — com.signal-ai/amazonica 0.3.165-signal-3

allocate-static-ip clj

(allocate-static-ip & {:keys [static-ip-name] :as allocate-static-ip-request})

attach-certificate-to-distribution clj

(attach-certificate-to-distribution
  &
  {:keys [certificate-name distribution-name]
   :as attach-certificate-to-distribution-request})

attach-disk clj

(attach-disk &
             {:keys [disk-name disk-path instance-name]
              :as attach-disk-request})

attach-instances-to-load-balancer clj

(attach-instances-to-load-balancer
  &
  {:keys [instance-names load-balancer-name]
   :as attach-instances-to-load-balancer-request})

attach-load-balancer-tls-certificate clj

(attach-load-balancer-tls-certificate
  &
  {:keys [certificate-name load-balancer-name]
   :as attach-load-balancer-tls-certificate-request})

attach-static-ip clj

(attach-static-ip &
                  {:keys [instance-name static-ip-name]
                   :as attach-static-ip-request})

client-class clj

close-instance-public-ports clj

(close-instance-public-ports &
                             {:keys [instance-name port-info]
                              :as close-instance-public-ports-request})

copy-snapshot clj

(copy-snapshot &
               {:keys [restore-date source-region source-resource-name
                       source-snapshot-name target-snapshot-name
                       use-latest-restorable-auto-snapshot]
                :as copy-snapshot-request})

create-bucket clj

(create-bucket &
               {:keys [bucket-name bundle-id enable-object-versioning tags]
                :as create-bucket-request})

create-bucket-access-key clj

(create-bucket-access-key &
                          {:keys [bucket-name]
                           :as create-bucket-access-key-request})

create-certificate clj

(create-certificate &
                    {:keys [certificate-name domain-name
                            subject-alternative-names tags]
                     :as create-certificate-request})

create-cloud-formation-stack clj

(create-cloud-formation-stack &
                              {:keys [instances]
                               :as create-cloud-formation-stack-request})

create-contact-method clj

(create-contact-method &
                       {:keys [contact-endpoint protocol]
                        :as create-contact-method-request})

create-container-service clj

(create-container-service &
                          {:keys [deployment power public-domain-names scale
                                  service-name tags]
                           :as create-container-service-request})

create-container-service-deployment clj

(create-container-service-deployment
  &
  {:keys [containers public-endpoint service-name]
   :as create-container-service-deployment-request})

create-container-service-registry-login clj

(create-container-service-registry-login
  &
  {:keys [] :as create-container-service-registry-login-request})

create-disk clj

(create-disk &
             {:keys [add-ons availability-zone disk-name size-in-gb tags]
              :as create-disk-request})

create-disk-from-snapshot clj

(create-disk-from-snapshot
  &
  {:keys [add-ons availability-zone disk-name disk-snapshot-name restore-date
          size-in-gb source-disk-name tags use-latest-restorable-auto-snapshot]
   :as create-disk-from-snapshot-request})

create-disk-snapshot clj

(create-disk-snapshot &
                      {:keys [disk-name disk-snapshot-name instance-name tags]
                       :as create-disk-snapshot-request})

create-distribution clj

(create-distribution &
                     {:keys [bundle-id cache-behavior-settings cache-behaviors
                             default-cache-behavior distribution-name
                             ip-address-type origin tags]
                      :as create-distribution-request})

create-domain clj

(create-domain & {:keys [domain-name tags] :as create-domain-request})

create-domain-entry clj

(create-domain-entry &
                     {:keys [domain-entry domain-name]
                      :as create-domain-entry-request})

create-instance-snapshot clj

(create-instance-snapshot &
                          {:keys [instance-name instance-snapshot-name tags]
                           :as create-instance-snapshot-request})

create-instances clj

(create-instances &
                  {:keys [add-ons availability-zone blueprint-id bundle-id
                          custom-image-name instance-names ip-address-type
                          key-pair-name tags user-data]
                   :as create-instances-request})

create-instances-from-snapshot clj

(create-instances-from-snapshot
  &
  {:keys [add-ons attached-disk-mapping availability-zone bundle-id
          instance-names instance-snapshot-name ip-address-type key-pair-name
          restore-date source-instance-name tags
          use-latest-restorable-auto-snapshot user-data]
   :as create-instances-from-snapshot-request})

create-key-pair clj

(create-key-pair & {:keys [key-pair-name tags] :as create-key-pair-request})

create-load-balancer clj

(create-load-balancer &
                      {:keys [certificate-alternative-names
                              certificate-domain-name certificate-name
                              health-check-path instance-port ip-address-type
                              load-balancer-name tags]
                       :as create-load-balancer-request})

create-load-balancer-tls-certificate clj

(create-load-balancer-tls-certificate
  &
  {:keys [certificate-alternative-names certificate-domain-name certificate-name
          load-balancer-name tags]
   :as create-load-balancer-tls-certificate-request})

create-relational-database clj

(create-relational-database
  &
  {:keys [availability-zone master-database-name master-user-password
          master-username preferred-backup-window preferred-maintenance-window
          publicly-accessible relational-database-blueprint-id
          relational-database-bundle-id relational-database-name tags]
   :as create-relational-database-request})

create-relational-database-from-snapshot clj

(create-relational-database-from-snapshot
  &
  {:keys [availability-zone publicly-accessible relational-database-bundle-id
          relational-database-name relational-database-snapshot-name
          restore-time source-relational-database-name tags
          use-latest-restorable-time]
   :as create-relational-database-from-snapshot-request})

create-relational-database-snapshot clj

(create-relational-database-snapshot
  &
  {:keys [relational-database-name relational-database-snapshot-name tags]
   :as create-relational-database-snapshot-request})

delete-alarm clj

(delete-alarm & {:keys [alarm-name] :as delete-alarm-request})

delete-auto-snapshot clj

(delete-auto-snapshot &
                      {:keys [date resource-name]
                       :as delete-auto-snapshot-request})

delete-bucket clj

(delete-bucket & {:keys [bucket-name force-delete] :as delete-bucket-request})

delete-bucket-access-key clj

(delete-bucket-access-key &
                          {:keys [access-key-id bucket-name]
                           :as delete-bucket-access-key-request})

delete-certificate clj

(delete-certificate & {:keys [certificate-name] :as delete-certificate-request})

delete-contact-method clj

(delete-contact-method & {:keys [protocol] :as delete-contact-method-request})

delete-container-image clj

(delete-container-image &
                        {:keys [image service-name]
                         :as delete-container-image-request})

delete-container-service clj

(delete-container-service &
                          {:keys [service-name]
                           :as delete-container-service-request})

delete-disk clj

(delete-disk & {:keys [disk-name force-delete-add-ons] :as delete-disk-request})

delete-disk-snapshot clj

(delete-disk-snapshot &
                      {:keys [disk-snapshot-name]
                       :as delete-disk-snapshot-request})

delete-distribution clj

(delete-distribution &
                     {:keys [distribution-name]
                      :as delete-distribution-request})

delete-domain clj

(delete-domain & {:keys [domain-name] :as delete-domain-request})

delete-domain-entry clj

(delete-domain-entry &
                     {:keys [domain-entry domain-name]
                      :as delete-domain-entry-request})

delete-instance clj

(delete-instance &
                 {:keys [force-delete-add-ons instance-name]
                  :as delete-instance-request})

delete-instance-snapshot clj

(delete-instance-snapshot &
                          {:keys [instance-snapshot-name]
                           :as delete-instance-snapshot-request})

delete-key-pair clj

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

delete-known-host-keys clj

(delete-known-host-keys &
                        {:keys [instance-name]
                         :as delete-known-host-keys-request})

delete-load-balancer clj

(delete-load-balancer &
                      {:keys [load-balancer-name]
                       :as delete-load-balancer-request})

delete-load-balancer-tls-certificate clj

(delete-load-balancer-tls-certificate
  &
  {:keys [certificate-name force load-balancer-name]
   :as delete-load-balancer-tls-certificate-request})

delete-relational-database clj

(delete-relational-database &
                            {:keys [final-relational-database-snapshot-name
                                    relational-database-name
                                    skip-final-snapshot]
                             :as delete-relational-database-request})

delete-relational-database-snapshot clj

(delete-relational-database-snapshot
  &
  {:keys [relational-database-snapshot-name]
   :as delete-relational-database-snapshot-request})

detach-certificate-from-distribution clj

(detach-certificate-from-distribution
  &
  {:keys [distribution-name] :as detach-certificate-from-distribution-request})

detach-disk clj

(detach-disk & {:keys [disk-name] :as detach-disk-request})

detach-instances-from-load-balancer clj

(detach-instances-from-load-balancer
  &
  {:keys [instance-names load-balancer-name]
   :as detach-instances-from-load-balancer-request})

detach-static-ip clj

(detach-static-ip & {:keys [static-ip-name] :as detach-static-ip-request})

disable-add-on clj

(disable-add-on &
                {:keys [add-on-type resource-name] :as disable-add-on-request})

download-default-key-pair clj

(download-default-key-pair & {:keys [] :as download-default-key-pair-request})

enable-add-on clj

(enable-add-on &
               {:keys [add-on-request resource-name] :as enable-add-on-request})

export-snapshot clj

(export-snapshot & {:keys [source-snapshot-name] :as export-snapshot-request})

get-active-names clj

(get-active-names & {:keys [page-token] :as get-active-names-request})

get-alarms clj

(get-alarms &
            {:keys [alarm-name monitored-resource-name page-token]
             :as get-alarms-request})

get-auto-snapshots clj

(get-auto-snapshots & {:keys [resource-name] :as get-auto-snapshots-request})

get-blueprints clj

(get-blueprints &
                {:keys [include-inactive page-token]
                 :as get-blueprints-request})

get-bucket-access-keys clj

(get-bucket-access-keys &
                        {:keys [bucket-name]
                         :as get-bucket-access-keys-request})

get-bucket-bundles clj

(get-bucket-bundles & {:keys [include-inactive] :as get-bucket-bundles-request})

get-bucket-metric-data clj

(get-bucket-metric-data &
                        {:keys [bucket-name end-time metric-name period
                                start-time statistics unit]
                         :as get-bucket-metric-data-request})

get-buckets clj

(get-buckets &
             {:keys [bucket-name include-connected-resources page-token]
              :as get-buckets-request})

get-bundles clj

(get-bundles & {:keys [include-inactive page-token] :as get-bundles-request})

get-cached-response-metadata clj

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

get-certificates clj

(get-certificates &
                  {:keys [certificate-name certificate-statuses
                          include-certificate-details]
                   :as get-certificates-request})

get-cloud-formation-stack-records clj

(get-cloud-formation-stack-records
  &
  {:keys [page-token] :as get-cloud-formation-stack-records-request})

get-contact-methods clj

(get-contact-methods & {:keys [protocols] :as get-contact-methods-request})

get-container-api-metadata clj

(get-container-api-metadata & {:keys [] :as get-container-apimetadata-request})

get-container-apimetadata clj

(get-container-apimetadata & {:keys [] :as get-container-apimetadata-request})

get-container-images clj

(get-container-images & {:keys [service-name] :as get-container-images-request})

get-container-log clj

(get-container-log &
                   {:keys [container-name end-time filter-pattern page-token
                           service-name start-time]
                    :as get-container-log-request})

get-container-service-deployments clj

(get-container-service-deployments
  &
  {:keys [service-name] :as get-container-service-deployments-request})

get-container-service-metric-data clj

(get-container-service-metric-data
  &
  {:keys [end-time metric-name period service-name start-time statistics]
   :as get-container-service-metric-data-request})

get-container-service-powers clj

(get-container-service-powers &
                              {:keys []
                               :as get-container-service-powers-request})

get-container-services clj

(get-container-services &
                        {:keys [service-name]
                         :as get-container-services-request})

get-disk clj

(get-disk & {:keys [disk-name] :as get-disk-request})

get-disk-snapshot clj

(get-disk-snapshot & {:keys [disk-snapshot-name] :as get-disk-snapshot-request})

get-disk-snapshots clj

(get-disk-snapshots & {:keys [page-token] :as get-disk-snapshots-request})

get-disks clj

(get-disks & {:keys [page-token] :as get-disks-request})

get-distribution-bundles clj

(get-distribution-bundles & {:keys [] :as get-distribution-bundles-request})

get-distribution-latest-cache-reset clj

(get-distribution-latest-cache-reset
  &
  {:keys [distribution-name] :as get-distribution-latest-cache-reset-request})

get-distribution-metric-data clj

(get-distribution-metric-data &
                              {:keys [distribution-name end-time metric-name
                                      period start-time statistics unit]
                               :as get-distribution-metric-data-request})

get-distributions clj

(get-distributions &
                   {:keys [distribution-name page-token]
                    :as get-distributions-request})

get-domain clj

(get-domain & {:keys [domain-name] :as get-domain-request})

get-domains clj

(get-domains & {:keys [page-token] :as get-domains-request})

get-export-snapshot-records clj

(get-export-snapshot-records &
                             {:keys [page-token]
                              :as get-export-snapshot-records-request})

get-instance clj

(get-instance & {:keys [instance-name] :as get-instance-request})

get-instance-access-details clj

(get-instance-access-details &
                             {:keys [instance-name protocol]
                              :as get-instance-access-details-request})

get-instance-metric-data clj

(get-instance-metric-data &
                          {:keys [end-time instance-name metric-name period
                                  start-time statistics unit]
                           :as get-instance-metric-data-request})

get-instance-port-states clj

(get-instance-port-states &
                          {:keys [instance-name]
                           :as get-instance-port-states-request})

get-instance-snapshot clj

(get-instance-snapshot &
                       {:keys [instance-snapshot-name]
                        :as get-instance-snapshot-request})

get-instance-snapshots clj

(get-instance-snapshots &
                        {:keys [page-token] :as get-instance-snapshots-request})

get-instance-state clj

(get-instance-state & {:keys [instance-name] :as get-instance-state-request})

get-instances clj

(get-instances & {:keys [page-token] :as get-instances-request})

get-key-pair clj

(get-key-pair & {:keys [key-pair-name] :as get-key-pair-request})

get-key-pairs clj

(get-key-pairs & {:keys [page-token] :as get-key-pairs-request})

get-load-balancer clj

(get-load-balancer & {:keys [load-balancer-name] :as get-load-balancer-request})

get-load-balancer-metric-data clj

(get-load-balancer-metric-data &
                               {:keys [end-time load-balancer-name metric-name
                                       period start-time statistics unit]
                                :as get-load-balancer-metric-data-request})

get-load-balancer-tls-certificates clj

(get-load-balancer-tls-certificates
  &
  {:keys [load-balancer-name] :as get-load-balancer-tls-certificates-request})

get-load-balancers clj

(get-load-balancers & {:keys [page-token] :as get-load-balancers-request})

get-operation clj

(get-operation & {:keys [operation-id] :as get-operation-request})

get-operations clj

(get-operations & {:keys [page-token] :as get-operations-request})

get-operations-for-resource clj

(get-operations-for-resource &
                             {:keys [page-token resource-name]
                              :as get-operations-for-resource-request})

get-regions clj

(get-regions &
             {:keys [include-availability-zones
                     include-relational-database-availability-zones]
              :as get-regions-request})

get-relational-database clj

(get-relational-database &
                         {:keys [relational-database-name]
                          :as get-relational-database-request})

get-relational-database-blueprints clj

(get-relational-database-blueprints
  &
  {:keys [page-token] :as get-relational-database-blueprints-request})

get-relational-database-bundles clj

(get-relational-database-bundles &
                                 {:keys [page-token]
                                  :as get-relational-database-bundles-request})

get-relational-database-events clj

(get-relational-database-events &
                                {:keys [duration-in-minutes page-token
                                        relational-database-name]
                                 :as get-relational-database-events-request})

get-relational-database-log-events clj

(get-relational-database-log-events
  &
  {:keys [end-time log-stream-name page-token relational-database-name
          start-from-head start-time]
   :as get-relational-database-log-events-request})

get-relational-database-log-streams clj

(get-relational-database-log-streams
  &
  {:keys [relational-database-name]
   :as get-relational-database-log-streams-request})

get-relational-database-master-user-password clj

(get-relational-database-master-user-password
  &
  {:keys [password-version relational-database-name]
   :as get-relational-database-master-user-password-request})

get-relational-database-metric-data clj

(get-relational-database-metric-data
  &
  {:keys [end-time metric-name period relational-database-name start-time
          statistics unit]
   :as get-relational-database-metric-data-request})

get-relational-database-parameters clj

(get-relational-database-parameters
  &
  {:keys [page-token relational-database-name]
   :as get-relational-database-parameters-request})

get-relational-database-snapshot clj

(get-relational-database-snapshot &
                                  {:keys [relational-database-snapshot-name]
                                   :as
                                     get-relational-database-snapshot-request})

get-relational-database-snapshots clj

(get-relational-database-snapshots
  &
  {:keys [page-token] :as get-relational-database-snapshots-request})

get-relational-databases clj

(get-relational-databases &
                          {:keys [page-token]
                           :as get-relational-databases-request})

get-static-ip clj

(get-static-ip & {:keys [static-ip-name] :as get-static-ip-request})

get-static-ips clj

(get-static-ips & {:keys [page-token] :as get-static-ips-request})

import-key-pair clj

(import-key-pair &
                 {:keys [key-pair-name public-key-base64]
                  :as import-key-pair-request})

is-vpc-peered clj

(is-vpc-peered & {:keys [] :as is-vpc-peered-request})

open-instance-public-ports clj

(open-instance-public-ports &
                            {:keys [instance-name port-info]
                             :as open-instance-public-ports-request})

peer-vpc clj

(peer-vpc & {:keys [] :as peer-vpc-request})

put-alarm clj

(put-alarm &
           {:keys [alarm-name comparison-operator contact-protocols
                   datapoints-to-alarm evaluation-periods metric-name
                   monitored-resource-name notification-enabled
                   notification-triggers threshold treat-missing-data]
            :as put-alarm-request})

put-instance-public-ports clj

(put-instance-public-ports &
                           {:keys [instance-name port-infos]
                            :as put-instance-public-ports-request})

reboot-instance clj

(reboot-instance & {:keys [instance-name] :as reboot-instance-request})

reboot-relational-database clj

(reboot-relational-database &
                            {:keys [relational-database-name]
                             :as reboot-relational-database-request})

register-container-image clj

(register-container-image &
                          {:keys [digest label service-name]
                           :as register-container-image-request})

release-static-ip clj

(release-static-ip & {:keys [static-ip-name] :as release-static-ip-request})

reset-distribution-cache clj

(reset-distribution-cache &
                          {:keys [distribution-name]
                           :as reset-distribution-cache-request})

send-contact-method-verification clj

(send-contact-method-verification
  &
  {:keys [protocol] :as send-contact-method-verification-request})

set-ip-address-type clj

(set-ip-address-type &
                     {:keys [ip-address-type resource-name resource-type]
                      :as set-ip-address-type-request})

set-resource-access-for-bucket clj

(set-resource-access-for-bucket &
                                {:keys [access bucket-name resource-name]
                                 :as set-resource-access-for-bucket-request})

show-functions clj

shutdown clj

(shutdown)

start-instance clj

(start-instance & {:keys [instance-name] :as start-instance-request})

start-relational-database clj

(start-relational-database &
                           {:keys [relational-database-name]
                            :as start-relational-database-request})

stop-instance clj

(stop-instance & {:keys [force instance-name] :as stop-instance-request})

stop-relational-database clj

(stop-relational-database &
                          {:keys [relational-database-name
                                  relational-database-snapshot-name]
                           :as stop-relational-database-request})

tag-resource clj

(tag-resource &
              {:keys [resource-arn resource-name tags]
               :as tag-resource-request})

test-alarm clj

(test-alarm & {:keys [alarm-name state] :as test-alarm-request})

unpeer-vpc clj

(unpeer-vpc & {:keys [] :as unpeer-vpc-request})

untag-resource clj

(untag-resource &
                {:keys [resource-arn resource-name tag-keys]
                 :as untag-resource-request})

update-bucket clj

(update-bucket &
               {:keys [access-log-config access-rules bucket-name
                       readonly-access-accounts versioning]
                :as update-bucket-request})

update-bucket-bundle clj

(update-bucket-bundle &
                      {:keys [bucket-name bundle-id]
                       :as update-bucket-bundle-request})

update-container-service clj

(update-container-service &
                          {:keys [is-disabled power public-domain-names scale
                                  service-name]
                           :as update-container-service-request})

update-distribution clj

(update-distribution &
                     {:keys [cache-behavior-settings cache-behaviors
                             default-cache-behavior distribution-name is-enabled
                             origin]
                      :as update-distribution-request})

update-distribution-bundle clj

(update-distribution-bundle &
                            {:keys [bundle-id distribution-name]
                             :as update-distribution-bundle-request})

update-domain-entry clj

(update-domain-entry &
                     {:keys [domain-entry domain-name]
                      :as update-domain-entry-request})

update-load-balancer-attribute clj

(update-load-balancer-attribute &
                                {:keys [attribute-name attribute-value
                                        load-balancer-name]
                                 :as update-load-balancer-attribute-request})

update-relational-database clj

(update-relational-database
  &
  {:keys [apply-immediately ca-certificate-identifier disable-backup-retention
          enable-backup-retention master-user-password preferred-backup-window
          preferred-maintenance-window publicly-accessible
          relational-database-name rotate-master-user-password]
   :as update-relational-database-request})

update-relational-database-parameters clj

(update-relational-database-parameters
  &
  {:keys [parameters relational-database-name]
   :as update-relational-database-parameters-request})