Liking cljdoc? Tell your friends :D
Clojure only.

amazonica.aws.lightsail

allocate-static-ipclj

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

attach-certificate-to-distributionclj

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

attach-diskclj

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

attach-instances-to-load-balancerclj

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

attach-load-balancer-tls-certificateclj

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

attach-static-ipclj

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

client-classclj

close-instance-public-portsclj

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

copy-snapshotclj

(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-bucketclj

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

create-bucket-access-keyclj

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

create-certificateclj

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

create-cloud-formation-stackclj

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

create-contact-methodclj

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

create-container-serviceclj

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

create-container-service-deploymentclj

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

create-container-service-registry-loginclj

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

create-diskclj

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

create-disk-from-snapshotclj

(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-snapshotclj

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

create-distributionclj

(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-domainclj

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

create-domain-entryclj

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

create-instance-snapshotclj

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

create-instancesclj

(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-snapshotclj

(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-pairclj

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

create-load-balancerclj

(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-certificateclj

(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-databaseclj

(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-snapshotclj

(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-snapshotclj

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

delete-alarmclj

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

delete-auto-snapshotclj

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

delete-bucketclj

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

delete-bucket-access-keyclj

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

delete-certificateclj

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

delete-contact-methodclj

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

delete-container-imageclj

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

delete-container-serviceclj

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

delete-diskclj

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

delete-disk-snapshotclj

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

delete-distributionclj

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

delete-domainclj

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

delete-domain-entryclj

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

delete-instanceclj

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

delete-instance-snapshotclj

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

delete-key-pairclj

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

delete-known-host-keysclj

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

delete-load-balancerclj

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

delete-load-balancer-tls-certificateclj

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

delete-relational-databaseclj

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

delete-relational-database-snapshotclj

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

detach-certificate-from-distributionclj

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

detach-diskclj

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

detach-instances-from-load-balancerclj

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

detach-static-ipclj

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

disable-add-onclj

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

download-default-key-pairclj

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

enable-add-onclj

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

export-snapshotclj

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

get-active-namesclj

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

get-alarmsclj

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

get-auto-snapshotsclj

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

get-blueprintsclj

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

get-bucket-access-keysclj

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

get-bucket-bundlesclj

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

get-bucket-metric-dataclj

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

get-bucketsclj

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

get-bundlesclj

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

get-cached-response-metadataclj

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

get-certificatesclj

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

get-cloud-formation-stack-recordsclj

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

get-contact-methodsclj

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

get-container-api-metadataclj

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

get-container-apimetadataclj

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

get-container-imagesclj

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

get-container-logclj

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

get-container-service-deploymentsclj

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

get-container-service-metric-dataclj

(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-powersclj

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

get-container-servicesclj

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

get-diskclj

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

get-disk-snapshotclj

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

get-disk-snapshotsclj

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

get-disksclj

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

get-distribution-bundlesclj

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

get-distribution-latest-cache-resetclj

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

get-distribution-metric-dataclj

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

get-distributionsclj

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

get-domainclj

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

get-domainsclj

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

get-export-snapshot-recordsclj

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

get-instanceclj

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

get-instance-access-detailsclj

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

get-instance-metric-dataclj

(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-statesclj

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

get-instance-snapshotclj

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

get-instance-snapshotsclj

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

get-instance-stateclj

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

get-instancesclj

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

get-key-pairclj

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

get-key-pairsclj

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

get-load-balancerclj

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

get-load-balancer-metric-dataclj

(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-certificatesclj

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

get-load-balancersclj

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

get-operationclj

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

get-operationsclj

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

get-operations-for-resourceclj

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

get-regionsclj

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

get-relational-databaseclj

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

get-relational-database-blueprintsclj

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

get-relational-database-bundlesclj

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

get-relational-database-eventsclj

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

get-relational-database-log-eventsclj

(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-streamsclj

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

get-relational-database-master-user-passwordclj

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

get-relational-database-metric-dataclj

(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-parametersclj

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

get-relational-database-snapshotclj

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

get-relational-database-snapshotsclj

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

get-relational-databasesclj

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

get-static-ipclj

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

get-static-ipsclj

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

import-key-pairclj

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

is-vpc-peeredclj

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

open-instance-public-portsclj

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

peer-vpcclj

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

put-alarmclj

(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-portsclj

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

reboot-instanceclj

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

reboot-relational-databaseclj

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

register-container-imageclj

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

release-static-ipclj

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

reset-distribution-cacheclj

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

send-contact-method-verificationclj

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

set-ip-address-typeclj

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

set-resource-access-for-bucketclj

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

show-functionsclj

shutdownclj

(shutdown)

start-instanceclj

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

start-relational-databaseclj

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

stop-instanceclj

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

stop-relational-databaseclj

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

tag-resourceclj

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

test-alarmclj

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

unpeer-vpcclj

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

untag-resourceclj

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

update-bucketclj

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

update-bucket-bundleclj

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

update-container-serviceclj

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

update-distributionclj

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

update-distribution-bundleclj

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

update-domain-entryclj

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

update-load-balancer-attributeclj

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

update-relational-databaseclj

(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-parametersclj

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

cljdoc is a website building & hosting documentation for Clojure/Script libraries

Keyboard shortcutsReport a problemcljdoc on GitHub
× close