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

accept-certificate-transfer clj

(accept-certificate-transfer &
                             {:keys [certificate-id set-as-active]
                              :as accept-certificate-transfer-request})

add-thing-to-billing-group clj

(add-thing-to-billing-group &
                            {:keys [billing-group-arn billing-group-name
                                    thing-arn thing-name]
                             :as add-thing-to-billing-group-request})

add-thing-to-thing-group clj

(add-thing-to-thing-group &
                          {:keys [override-dynamic-groups thing-arn
                                  thing-group-arn thing-group-name thing-name]
                           :as add-thing-to-thing-group-request})

associate-targets-with-job clj

(associate-targets-with-job &
                            {:keys [comment job-id namespace-id targets]
                             :as associate-targets-with-job-request})

attach-policy clj

(attach-policy & {:keys [policy-name target] :as attach-policy-request})

attach-principal-policy clj

(attach-principal-policy &
                         {:keys [policy-name principal]
                          :as attach-principal-policy-request})

attach-security-profile clj

(attach-security-profile &
                         {:keys [security-profile-name
                                 security-profile-target-arn]
                          :as attach-security-profile-request})

attach-thing-principal clj

(attach-thing-principal &
                        {:keys [principal thing-name]
                         :as attach-thing-principal-request})

cancel-audit-mitigation-actions-task clj

(cancel-audit-mitigation-actions-task
  &
  {:keys [task-id] :as cancel-audit-mitigation-actions-task-request})

cancel-audit-task clj

(cancel-audit-task & {:keys [task-id] :as cancel-audit-task-request})

cancel-certificate-transfer clj

(cancel-certificate-transfer &
                             {:keys [certificate-id]
                              :as cancel-certificate-transfer-request})

cancel-detect-mitigation-actions-task clj

(cancel-detect-mitigation-actions-task
  &
  {:keys [task-id] :as cancel-detect-mitigation-actions-task-request})

cancel-job clj

(cancel-job & {:keys [comment force job-id reason-code] :as cancel-job-request})

cancel-job-execution clj

(cancel-job-execution &
                      {:keys [expected-version force job-id status-details
                              thing-name]
                       :as cancel-job-execution-request})

clear-default-authorizer clj

(clear-default-authorizer & {:keys [] :as clear-default-authorizer-request})

client-class clj

confirm-topic-rule-destination clj

(confirm-topic-rule-destination &
                                {:keys [confirmation-token]
                                 :as confirm-topic-rule-destination-request})

create-audit-suppression clj

(create-audit-suppression &
                          {:keys [check-name client-request-token description
                                  expiration-date resource-identifier
                                  suppress-indefinitely]
                           :as create-audit-suppression-request})

create-authorizer clj

(create-authorizer &
                   {:keys [authorizer-function-arn authorizer-name
                           enable-caching-for-http signing-disabled status tags
                           token-key-name token-signing-public-keys]
                    :as create-authorizer-request})

create-billing-group clj

(create-billing-group &
                      {:keys [billing-group-name billing-group-properties tags]
                       :as create-billing-group-request})

create-certificate-from-csr clj

(create-certificate-from-csr &
                             {:keys [certificate-signing-request set-as-active]
                              :as create-certificate-from-csr-request})

create-custom-metric clj

(create-custom-metric &
                      {:keys [client-request-token display-name metric-name
                              metric-type tags]
                       :as create-custom-metric-request})

create-dimension clj

(create-dimension &
                  {:keys [client-request-token name string-values tags type]
                   :as create-dimension-request})

create-domain-configuration clj

(create-domain-configuration
  &
  {:keys [authorizer-config domain-configuration-name domain-name
          server-certificate-arns service-type tags validation-certificate-arn]
   :as create-domain-configuration-request})

create-dynamic-thing-group clj

(create-dynamic-thing-group &
                            {:keys [index-name query-string query-version tags
                                    thing-group-name thing-group-properties]
                             :as create-dynamic-thing-group-request})

create-fleet-metric clj

(create-fleet-metric &
                     {:keys [aggregation-field aggregation-type description
                             index-name metric-name period query-string
                             query-version tags unit]
                      :as create-fleet-metric-request})

create-job clj

(create-job &
            {:keys [abort-config description document document-parameters
                    document-source job-executions-rollout-config job-id
                    job-template-arn namespace-id presigned-url-config tags
                    target-selection targets timeout-config]
             :as create-job-request})

create-job-template clj

(create-job-template &
                     {:keys [abort-config description document document-source
                             job-arn job-executions-rollout-config
                             job-template-id presigned-url-config tags
                             timeout-config]
                      :as create-job-template-request})

create-keys-and-certificate clj

(create-keys-and-certificate &
                             {:keys [set-as-active]
                              :as create-keys-and-certificate-request})

create-mitigation-action clj

(create-mitigation-action &
                          {:keys [action-name action-params role-arn tags]
                           :as create-mitigation-action-request})

create-ota-update clj

(create-ota-update &
                   {:keys [additional-parameters aws-job-abort-config
                           aws-job-executions-rollout-config
                           aws-job-presigned-url-config aws-job-timeout-config
                           description files ota-update-id protocols role-arn
                           tags target-selection targets]
                    :as create-otaupdate-request})

create-otaupdate clj

(create-otaupdate &
                  {:keys [additional-parameters aws-job-abort-config
                          aws-job-executions-rollout-config
                          aws-job-presigned-url-config aws-job-timeout-config
                          description files ota-update-id protocols role-arn
                          tags target-selection targets]
                   :as create-otaupdate-request})

create-policy clj

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

create-policy-version clj

(create-policy-version &
                       {:keys [policy-document policy-name set-as-default]
                        :as create-policy-version-request})

create-provisioning-claim clj

(create-provisioning-claim &
                           {:keys [template-name]
                            :as create-provisioning-claim-request})

create-provisioning-template clj

(create-provisioning-template &
                              {:keys [description enabled pre-provisioning-hook
                                      provisioning-role-arn tags template-body
                                      template-name]
                               :as create-provisioning-template-request})

create-provisioning-template-version clj

(create-provisioning-template-version
  &
  {:keys [set-as-default template-body template-name]
   :as create-provisioning-template-version-request})

create-role-alias clj

(create-role-alias &
                   {:keys [credential-duration-seconds role-alias role-arn tags]
                    :as create-role-alias-request})

create-scheduled-audit clj

(create-scheduled-audit &
                        {:keys [day-of-month day-of-week frequency
                                scheduled-audit-name tags target-check-names]
                         :as create-scheduled-audit-request})

create-security-profile clj

(create-security-profile &
                         {:keys [additional-metrics-to-retain
                                 additional-metrics-to-retain-v2 alert-targets
                                 behaviors security-profile-description
                                 security-profile-name tags]
                          :as create-security-profile-request})

create-stream clj

(create-stream &
               {:keys [description files role-arn stream-id tags]
                :as create-stream-request})

create-thing clj

(create-thing &
              {:keys [attribute-payload billing-group-name thing-name
                      thing-type-name]
               :as create-thing-request})

create-thing-group clj

(create-thing-group &
                    {:keys [parent-group-name tags thing-group-name
                            thing-group-properties]
                     :as create-thing-group-request})

create-thing-type clj

(create-thing-type &
                   {:keys [tags thing-type-name thing-type-properties]
                    :as create-thing-type-request})

create-topic-rule clj

(create-topic-rule &
                   {:keys [rule-name tags topic-rule-payload]
                    :as create-topic-rule-request})

create-topic-rule-destination clj

(create-topic-rule-destination &
                               {:keys [destination-configuration]
                                :as create-topic-rule-destination-request})

delete-account-audit-configuration clj

(delete-account-audit-configuration
  &
  {:keys [delete-scheduled-audits]
   :as delete-account-audit-configuration-request})

delete-audit-suppression clj

(delete-audit-suppression &
                          {:keys [check-name resource-identifier]
                           :as delete-audit-suppression-request})

delete-authorizer clj

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

delete-billing-group clj

(delete-billing-group &
                      {:keys [billing-group-name expected-version]
                       :as delete-billing-group-request})

delete-ca-certificate clj

(delete-ca-certificate &
                       {:keys [certificate-id]
                        :as delete-cacertificate-request})

delete-cacertificate clj

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

delete-certificate clj

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

delete-custom-metric clj

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

delete-dimension clj

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

delete-domain-configuration clj

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

delete-dynamic-thing-group clj

(delete-dynamic-thing-group &
                            {:keys [expected-version thing-group-name]
                             :as delete-dynamic-thing-group-request})

delete-fleet-metric clj

(delete-fleet-metric &
                     {:keys [expected-version metric-name]
                      :as delete-fleet-metric-request})

delete-job clj

(delete-job & {:keys [force job-id namespace-id] :as delete-job-request})

delete-job-execution clj

(delete-job-execution &
                      {:keys [execution-number force job-id namespace-id
                              thing-name]
                       :as delete-job-execution-request})

delete-job-template clj

(delete-job-template &
                     {:keys [job-template-id] :as delete-job-template-request})

delete-mitigation-action clj

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

delete-ota-update clj

(delete-ota-update &
                   {:keys [delete-stream force-delete-aws-job ota-update-id]
                    :as delete-otaupdate-request})

delete-otaupdate clj

(delete-otaupdate &
                  {:keys [delete-stream force-delete-aws-job ota-update-id]
                   :as delete-otaupdate-request})

delete-policy clj

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

delete-policy-version clj

(delete-policy-version &
                       {:keys [policy-name policy-version-id]
                        :as delete-policy-version-request})

delete-provisioning-template clj

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

delete-provisioning-template-version clj

(delete-provisioning-template-version
  &
  {:keys [template-name version-id]
   :as delete-provisioning-template-version-request})

delete-registration-code clj

(delete-registration-code & {:keys [] :as delete-registration-code-request})

delete-role-alias clj

(delete-role-alias & {:keys [role-alias] :as delete-role-alias-request})

delete-scheduled-audit clj

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

delete-security-profile clj

(delete-security-profile &
                         {:keys [expected-version security-profile-name]
                          :as delete-security-profile-request})

delete-stream clj

(delete-stream & {:keys [stream-id] :as delete-stream-request})

delete-thing clj

(delete-thing & {:keys [expected-version thing-name] :as delete-thing-request})

delete-thing-group clj

(delete-thing-group &
                    {:keys [expected-version thing-group-name]
                     :as delete-thing-group-request})

delete-thing-type clj

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

delete-topic-rule clj

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

delete-topic-rule-destination clj

(delete-topic-rule-destination &
                               {:keys [arn]
                                :as delete-topic-rule-destination-request})

delete-v2-logging-level clj

(delete-v2-logging-level &
                         {:keys [target-name target-type]
                          :as delete-v2-logging-level-request})

delete-v2logging-level clj

(delete-v2logging-level &
                        {:keys [target-name target-type]
                         :as delete-v2-logging-level-request})

deprecate-thing-type clj

(deprecate-thing-type &
                      {:keys [thing-type-name undo-deprecate]
                       :as deprecate-thing-type-request})

describe-account-audit-configuration clj

(describe-account-audit-configuration
  &
  {:keys [] :as describe-account-audit-configuration-request})

describe-audit-finding clj

(describe-audit-finding &
                        {:keys [finding-id] :as describe-audit-finding-request})

describe-audit-mitigation-actions-task clj

(describe-audit-mitigation-actions-task
  &
  {:keys [task-id] :as describe-audit-mitigation-actions-task-request})

describe-audit-suppression clj

(describe-audit-suppression &
                            {:keys [check-name resource-identifier]
                             :as describe-audit-suppression-request})

describe-audit-task clj

(describe-audit-task & {:keys [task-id] :as describe-audit-task-request})

describe-authorizer clj

(describe-authorizer &
                     {:keys [authorizer-name] :as describe-authorizer-request})

describe-billing-group clj

(describe-billing-group &
                        {:keys [billing-group-name]
                         :as describe-billing-group-request})

describe-ca-certificate clj

(describe-ca-certificate &
                         {:keys [certificate-id]
                          :as describe-cacertificate-request})

describe-cacertificate clj

(describe-cacertificate &
                        {:keys [certificate-id]
                         :as describe-cacertificate-request})

describe-certificate clj

(describe-certificate &
                      {:keys [certificate-id] :as describe-certificate-request})

describe-custom-metric clj

(describe-custom-metric &
                        {:keys [metric-name]
                         :as describe-custom-metric-request})

describe-default-authorizer clj

(describe-default-authorizer &
                             {:keys [] :as describe-default-authorizer-request})

describe-detect-mitigation-actions-task clj

(describe-detect-mitigation-actions-task
  &
  {:keys [task-id] :as describe-detect-mitigation-actions-task-request})

describe-dimension clj

(describe-dimension & {:keys [name] :as describe-dimension-request})

describe-domain-configuration clj

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

describe-endpoint clj

(describe-endpoint & {:keys [endpoint-type] :as describe-endpoint-request})

describe-event-configurations clj

(describe-event-configurations &
                               {:keys []
                                :as describe-event-configurations-request})

describe-fleet-metric clj

(describe-fleet-metric &
                       {:keys [metric-name] :as describe-fleet-metric-request})

describe-index clj

(describe-index & {:keys [index-name] :as describe-index-request})

describe-job clj

(describe-job & {:keys [job-id] :as describe-job-request})

describe-job-execution clj

(describe-job-execution &
                        {:keys [execution-number job-id thing-name]
                         :as describe-job-execution-request})

describe-job-template clj

(describe-job-template &
                       {:keys [job-template-id]
                        :as describe-job-template-request})

describe-managed-job-template clj

(describe-managed-job-template &
                               {:keys [template-name template-version]
                                :as describe-managed-job-template-request})

describe-mitigation-action clj

(describe-mitigation-action &
                            {:keys [action-name]
                             :as describe-mitigation-action-request})

describe-provisioning-template clj

(describe-provisioning-template &
                                {:keys [template-name]
                                 :as describe-provisioning-template-request})

describe-provisioning-template-version clj

(describe-provisioning-template-version
  &
  {:keys [template-name version-id]
   :as describe-provisioning-template-version-request})

describe-role-alias clj

(describe-role-alias & {:keys [role-alias] :as describe-role-alias-request})

describe-scheduled-audit clj

(describe-scheduled-audit &
                          {:keys [scheduled-audit-name]
                           :as describe-scheduled-audit-request})

describe-security-profile clj

(describe-security-profile &
                           {:keys [security-profile-name]
                            :as describe-security-profile-request})

describe-stream clj

(describe-stream & {:keys [stream-id] :as describe-stream-request})

describe-thing clj

(describe-thing & {:keys [thing-name] :as describe-thing-request})

describe-thing-group clj

(describe-thing-group &
                      {:keys [thing-group-name]
                       :as describe-thing-group-request})

describe-thing-registration-task clj

(describe-thing-registration-task
  &
  {:keys [task-id] :as describe-thing-registration-task-request})

describe-thing-type clj

(describe-thing-type &
                     {:keys [thing-type-name] :as describe-thing-type-request})

detach-policy clj

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

detach-principal-policy clj

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

detach-security-profile clj

(detach-security-profile &
                         {:keys [security-profile-name
                                 security-profile-target-arn]
                          :as detach-security-profile-request})

detach-thing-principal clj

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

disable-topic-rule clj

(disable-topic-rule & {:keys [rule-name] :as disable-topic-rule-request})

enable-topic-rule clj

(enable-topic-rule & {:keys [rule-name] :as enable-topic-rule-request})

get-behavior-model-training-summaries clj

(get-behavior-model-training-summaries
  &
  {:keys [max-results next-token security-profile-name]
   :as get-behavior-model-training-summaries-request})

get-buckets-aggregation clj

(get-buckets-aggregation &
                         {:keys [aggregation-field buckets-aggregation-type
                                 index-name query-string query-version]
                          :as get-buckets-aggregation-request})

get-cached-response-metadata clj

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

get-cardinality clj

(get-cardinality &
                 {:keys [aggregation-field index-name query-string
                         query-version]
                  :as get-cardinality-request})

get-effective-policies clj

(get-effective-policies &
                        {:keys [cognito-identity-pool-id principal thing-name]
                         :as get-effective-policies-request})

get-indexing-configuration clj

(get-indexing-configuration & {:keys [] :as get-indexing-configuration-request})

get-job-document clj

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

get-logging-options clj

(get-logging-options & {:keys [] :as get-logging-options-request})

get-ota-update clj

(get-ota-update & {:keys [ota-update-id] :as get-otaupdate-request})

get-otaupdate clj

(get-otaupdate & {:keys [ota-update-id] :as get-otaupdate-request})

get-percentiles clj

(get-percentiles &
                 {:keys [aggregation-field index-name percents query-string
                         query-version]
                  :as get-percentiles-request})

get-policy clj

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

get-policy-version clj

(get-policy-version &
                    {:keys [policy-name policy-version-id]
                     :as get-policy-version-request})

get-registration-code clj

(get-registration-code & {:keys [] :as get-registration-code-request})

get-statistics clj

(get-statistics &
                {:keys [aggregation-field index-name query-string query-version]
                 :as get-statistics-request})

get-topic-rule clj

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

get-topic-rule-destination clj

(get-topic-rule-destination &
                            {:keys [arn]
                             :as get-topic-rule-destination-request})

get-v2-logging-options clj

(get-v2-logging-options & {:keys [] :as get-v2-logging-options-request})

get-v2logging-options clj

(get-v2logging-options & {:keys [] :as get-v2-logging-options-request})

list-active-violations clj

(list-active-violations &
                        {:keys [behavior-criteria-type list-suppressed-alerts
                                max-results next-token security-profile-name
                                thing-name verification-state]
                         :as list-active-violations-request})

list-attached-policies clj

(list-attached-policies &
                        {:keys [marker page-size recursive target]
                         :as list-attached-policies-request})

list-audit-findings clj

(list-audit-findings &
                     {:keys [check-name end-time list-suppressed-findings
                             max-results next-token resource-identifier
                             start-time task-id]
                      :as list-audit-findings-request})

list-audit-mitigation-actions-executions clj

(list-audit-mitigation-actions-executions
  &
  {:keys [action-status finding-id max-results next-token task-id]
   :as list-audit-mitigation-actions-executions-request})

list-audit-mitigation-actions-tasks clj

(list-audit-mitigation-actions-tasks
  &
  {:keys [audit-task-id end-time finding-id max-results next-token start-time
          task-status]
   :as list-audit-mitigation-actions-tasks-request})

list-audit-suppressions clj

(list-audit-suppressions &
                         {:keys [ascending-order check-name max-results
                                 next-token resource-identifier]
                          :as list-audit-suppressions-request})

list-audit-tasks clj

(list-audit-tasks &
                  {:keys [end-time max-results next-token start-time task-status
                          task-type]
                   :as list-audit-tasks-request})

list-authorizers clj

(list-authorizers &
                  {:keys [ascending-order marker page-size status]
                   :as list-authorizers-request})

list-billing-groups clj

(list-billing-groups &
                     {:keys [max-results name-prefix-filter next-token]
                      :as list-billing-groups-request})

list-ca-certificates clj

(list-ca-certificates &
                      {:keys [ascending-order marker page-size]
                       :as list-cacertificates-request})

list-cacertificates clj

(list-cacertificates &
                     {:keys [ascending-order marker page-size]
                      :as list-cacertificates-request})

list-certificates clj

(list-certificates &
                   {:keys [ascending-order marker page-size]
                    :as list-certificates-request})

list-certificates-by-ca clj

(list-certificates-by-ca &
                         {:keys [ascending-order ca-certificate-id marker
                                 page-size]
                          :as list-certificates-by-carequest})

list-custom-metrics clj

(list-custom-metrics &
                     {:keys [max-results next-token]
                      :as list-custom-metrics-request})

list-detect-mitigation-actions-executions clj

(list-detect-mitigation-actions-executions
  &
  {:keys [end-time max-results next-token start-time task-id thing-name
          violation-id]
   :as list-detect-mitigation-actions-executions-request})

list-detect-mitigation-actions-tasks clj

(list-detect-mitigation-actions-tasks
  &
  {:keys [end-time max-results next-token start-time]
   :as list-detect-mitigation-actions-tasks-request})

list-dimensions clj

(list-dimensions & {:keys [max-results next-token] :as list-dimensions-request})

list-domain-configurations clj

(list-domain-configurations &
                            {:keys [marker page-size service-type]
                             :as list-domain-configurations-request})

list-fleet-metrics clj

(list-fleet-metrics &
                    {:keys [max-results next-token]
                     :as list-fleet-metrics-request})

list-indices clj

(list-indices & {:keys [max-results next-token] :as list-indices-request})

list-job-executions-for-job clj

(list-job-executions-for-job &
                             {:keys [job-id max-results next-token status]
                              :as list-job-executions-for-job-request})

list-job-executions-for-thing clj

(list-job-executions-for-thing &
                               {:keys [max-results namespace-id next-token
                                       status thing-name]
                                :as list-job-executions-for-thing-request})

list-job-templates clj

(list-job-templates &
                    {:keys [max-results next-token]
                     :as list-job-templates-request})

list-jobs clj

(list-jobs &
           {:keys [max-results namespace-id next-token status target-selection
                   thing-group-id thing-group-name]
            :as list-jobs-request})

list-managed-job-templates clj

(list-managed-job-templates &
                            {:keys [max-results next-token template-name]
                             :as list-managed-job-templates-request})

list-mitigation-actions clj

(list-mitigation-actions &
                         {:keys [action-type max-results next-token]
                          :as list-mitigation-actions-request})

list-ota-updates clj

(list-ota-updates &
                  {:keys [max-results next-token ota-update-status]
                   :as list-otaupdates-request})

list-otaupdates clj

(list-otaupdates &
                 {:keys [max-results next-token ota-update-status]
                  :as list-otaupdates-request})

list-outgoing-certificates clj

(list-outgoing-certificates &
                            {:keys [ascending-order marker page-size]
                             :as list-outgoing-certificates-request})

list-policies clj

(list-policies &
               {:keys [ascending-order marker page-size]
                :as list-policies-request})

list-policy-principals clj

(list-policy-principals &
                        {:keys [ascending-order marker page-size policy-name]
                         :as list-policy-principals-request})

list-policy-versions clj

(list-policy-versions & {:keys [policy-name] :as list-policy-versions-request})

list-principal-policies clj

(list-principal-policies &
                         {:keys [ascending-order marker page-size principal]
                          :as list-principal-policies-request})

list-principal-things clj

(list-principal-things &
                       {:keys [max-results next-token principal]
                        :as list-principal-things-request})

list-provisioning-template-versions clj

(list-provisioning-template-versions
  &
  {:keys [max-results next-token template-name]
   :as list-provisioning-template-versions-request})

list-provisioning-templates clj

(list-provisioning-templates &
                             {:keys [max-results next-token]
                              :as list-provisioning-templates-request})

list-role-aliases clj

(list-role-aliases &
                   {:keys [ascending-order marker page-size]
                    :as list-role-aliases-request})

list-scheduled-audits clj

(list-scheduled-audits &
                       {:keys [max-results next-token]
                        :as list-scheduled-audits-request})

list-security-profiles clj

(list-security-profiles &
                        {:keys [dimension-name max-results metric-name
                                next-token]
                         :as list-security-profiles-request})

list-security-profiles-for-target clj

(list-security-profiles-for-target
  &
  {:keys [max-results next-token recursive security-profile-target-arn]
   :as list-security-profiles-for-target-request})

list-streams clj

(list-streams &
              {:keys [ascending-order max-results next-token]
               :as list-streams-request})

list-tags-for-resource clj

(list-tags-for-resource &
                        {:keys [next-token resource-arn]
                         :as list-tags-for-resource-request})

list-targets-for-policy clj

(list-targets-for-policy &
                         {:keys [marker page-size policy-name]
                          :as list-targets-for-policy-request})

list-targets-for-security-profile clj

(list-targets-for-security-profile
  &
  {:keys [max-results next-token security-profile-name]
   :as list-targets-for-security-profile-request})

list-thing-groups clj

(list-thing-groups &
                   {:keys [max-results name-prefix-filter next-token
                           parent-group recursive]
                    :as list-thing-groups-request})

list-thing-groups-for-thing clj

(list-thing-groups-for-thing &
                             {:keys [max-results next-token thing-name]
                              :as list-thing-groups-for-thing-request})

list-thing-principals clj

(list-thing-principals &
                       {:keys [max-results next-token thing-name]
                        :as list-thing-principals-request})

list-thing-registration-task-reports clj

(list-thing-registration-task-reports
  &
  {:keys [max-results next-token report-type task-id]
   :as list-thing-registration-task-reports-request})

list-thing-registration-tasks clj

(list-thing-registration-tasks &
                               {:keys [max-results next-token status]
                                :as list-thing-registration-tasks-request})

list-thing-types clj

(list-thing-types &
                  {:keys [max-results next-token thing-type-name]
                   :as list-thing-types-request})

list-things clj

(list-things &
             {:keys [attribute-name attribute-value max-results next-token
                     thing-type-name use-prefix-attribute-value]
              :as list-things-request})

list-things-in-billing-group clj

(list-things-in-billing-group &
                              {:keys [billing-group-name max-results next-token]
                               :as list-things-in-billing-group-request})

list-things-in-thing-group clj

(list-things-in-thing-group &
                            {:keys [max-results next-token recursive
                                    thing-group-name]
                             :as list-things-in-thing-group-request})

list-topic-rule-destinations clj

(list-topic-rule-destinations &
                              {:keys [max-results next-token]
                               :as list-topic-rule-destinations-request})

list-topic-rules clj

(list-topic-rules &
                  {:keys [max-results next-token rule-disabled topic]
                   :as list-topic-rules-request})

list-v2-logging-levels clj

(list-v2-logging-levels &
                        {:keys [max-results next-token target-type]
                         :as list-v2-logging-levels-request})

list-v2logging-levels clj

(list-v2logging-levels &
                       {:keys [max-results next-token target-type]
                        :as list-v2-logging-levels-request})

list-violation-events clj

(list-violation-events &
                       {:keys [behavior-criteria-type end-time
                               list-suppressed-alerts max-results next-token
                               security-profile-name start-time thing-name
                               verification-state]
                        :as list-violation-events-request})

put-verification-state-on-violation clj

(put-verification-state-on-violation
  &
  {:keys [verification-state verification-state-description violation-id]
   :as put-verification-state-on-violation-request})

register-ca-certificate clj

(register-ca-certificate &
                         {:keys [allow-auto-registration ca-certificate
                                 registration-config set-as-active tags
                                 verification-certificate]
                          :as register-cacertificate-request})

register-cacertificate clj

(register-cacertificate &
                        {:keys [allow-auto-registration ca-certificate
                                registration-config set-as-active tags
                                verification-certificate]
                         :as register-cacertificate-request})

register-certificate clj

(register-certificate &
                      {:keys [ca-certificate-pem certificate-pem set-as-active
                              status]
                       :as register-certificate-request})

register-certificate-without-ca clj

(register-certificate-without-ca &
                                 {:keys [certificate-pem status]
                                  :as register-certificate-without-carequest})

register-thing clj

(register-thing & {:keys [parameters template-body] :as register-thing-request})

reject-certificate-transfer clj

(reject-certificate-transfer &
                             {:keys [certificate-id reject-reason]
                              :as reject-certificate-transfer-request})

remove-thing-from-billing-group clj

(remove-thing-from-billing-group &
                                 {:keys [billing-group-arn billing-group-name
                                         thing-arn thing-name]
                                  :as remove-thing-from-billing-group-request})

remove-thing-from-thing-group clj

(remove-thing-from-thing-group &
                               {:keys [thing-arn thing-group-arn
                                       thing-group-name thing-name]
                                :as remove-thing-from-thing-group-request})

replace-topic-rule clj

(replace-topic-rule &
                    {:keys [rule-name topic-rule-payload]
                     :as replace-topic-rule-request})

search-index clj

(search-index &
              {:keys [index-name max-results next-token query-string
                      query-version]
               :as search-index-request})

set-default-authorizer clj

(set-default-authorizer &
                        {:keys [authorizer-name]
                         :as set-default-authorizer-request})

set-default-policy-version clj

(set-default-policy-version &
                            {:keys [policy-name policy-version-id]
                             :as set-default-policy-version-request})

set-logging-options clj

(set-logging-options &
                     {:keys [logging-options-payload]
                      :as set-logging-options-request})

set-v2-logging-level clj

(set-v2-logging-level &
                      {:keys [log-level log-target]
                       :as set-v2-logging-level-request})

set-v2-logging-options clj

(set-v2-logging-options &
                        {:keys [default-log-level disable-all-logs role-arn]
                         :as set-v2-logging-options-request})

set-v2logging-level clj

(set-v2logging-level &
                     {:keys [log-level log-target]
                      :as set-v2-logging-level-request})

set-v2logging-options clj

(set-v2logging-options &
                       {:keys [default-log-level disable-all-logs role-arn]
                        :as set-v2-logging-options-request})

show-functions clj

shutdown clj

(shutdown)

start-audit-mitigation-actions-task clj

(start-audit-mitigation-actions-task
  &
  {:keys [audit-check-to-actions-mapping client-request-token target task-id]
   :as start-audit-mitigation-actions-task-request})

start-detect-mitigation-actions-task clj

(start-detect-mitigation-actions-task
  &
  {:keys [actions client-request-token include-only-active-violations
          include-suppressed-alerts target task-id
          violation-event-occurrence-range]
   :as start-detect-mitigation-actions-task-request})

start-on-demand-audit-task clj

(start-on-demand-audit-task &
                            {:keys [target-check-names]
                             :as start-on-demand-audit-task-request})

start-thing-registration-task clj

(start-thing-registration-task &
                               {:keys [input-file-bucket input-file-key role-arn
                                       template-body]
                                :as start-thing-registration-task-request})

stop-thing-registration-task clj

(stop-thing-registration-task &
                              {:keys [task-id]
                               :as stop-thing-registration-task-request})

tag-resource clj

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

test-authorization clj

(test-authorization &
                    {:keys [auth-infos client-id cognito-identity-pool-id
                            policy-names-to-add policy-names-to-skip principal]
                     :as test-authorization-request})

test-invoke-authorizer clj

(test-invoke-authorizer &
                        {:keys [authorizer-name http-context mqtt-context
                                tls-context token token-signature]
                         :as test-invoke-authorizer-request})

transfer-certificate clj

(transfer-certificate &
                      {:keys [certificate-id target-aws-account
                              transfer-message]
                       :as transfer-certificate-request})

untag-resource clj

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

update-account-audit-configuration clj

(update-account-audit-configuration
  &
  {:keys [audit-check-configurations audit-notification-target-configurations
          role-arn]
   :as update-account-audit-configuration-request})

update-audit-suppression clj

(update-audit-suppression &
                          {:keys [check-name description expiration-date
                                  resource-identifier suppress-indefinitely]
                           :as update-audit-suppression-request})

update-authorizer clj

(update-authorizer &
                   {:keys [authorizer-function-arn authorizer-name
                           enable-caching-for-http status token-key-name
                           token-signing-public-keys]
                    :as update-authorizer-request})

update-billing-group clj

(update-billing-group &
                      {:keys [billing-group-name billing-group-properties
                              expected-version]
                       :as update-billing-group-request})

update-ca-certificate clj

(update-ca-certificate &
                       {:keys [certificate-id new-auto-registration-status
                               new-status registration-config
                               remove-auto-registration]
                        :as update-cacertificate-request})

update-cacertificate clj

(update-cacertificate &
                      {:keys [certificate-id new-auto-registration-status
                              new-status registration-config
                              remove-auto-registration]
                       :as update-cacertificate-request})

update-certificate clj

(update-certificate &
                    {:keys [certificate-id new-status]
                     :as update-certificate-request})

update-custom-metric clj

(update-custom-metric &
                      {:keys [display-name metric-name]
                       :as update-custom-metric-request})

update-dimension clj

(update-dimension & {:keys [name string-values] :as update-dimension-request})

update-domain-configuration clj

(update-domain-configuration &
                             {:keys [authorizer-config domain-configuration-name
                                     domain-configuration-status
                                     remove-authorizer-config]
                              :as update-domain-configuration-request})

update-dynamic-thing-group clj

(update-dynamic-thing-group &
                            {:keys [expected-version index-name query-string
                                    query-version thing-group-name
                                    thing-group-properties]
                             :as update-dynamic-thing-group-request})

update-event-configurations clj

(update-event-configurations &
                             {:keys [event-configurations]
                              :as update-event-configurations-request})

update-fleet-metric clj

(update-fleet-metric &
                     {:keys [aggregation-field aggregation-type description
                             expected-version index-name metric-name period
                             query-string query-version unit]
                      :as update-fleet-metric-request})

update-indexing-configuration clj

(update-indexing-configuration &
                               {:keys [thing-group-indexing-configuration
                                       thing-indexing-configuration]
                                :as update-indexing-configuration-request})

update-job clj

(update-job &
            {:keys [abort-config description job-executions-rollout-config
                    job-id namespace-id presigned-url-config timeout-config]
             :as update-job-request})

update-mitigation-action clj

(update-mitigation-action &
                          {:keys [action-name action-params role-arn]
                           :as update-mitigation-action-request})

update-provisioning-template clj

(update-provisioning-template
  &
  {:keys [default-version-id description enabled pre-provisioning-hook
          provisioning-role-arn remove-pre-provisioning-hook template-name]
   :as update-provisioning-template-request})

update-role-alias clj

(update-role-alias &
                   {:keys [credential-duration-seconds role-alias role-arn]
                    :as update-role-alias-request})

update-scheduled-audit clj

(update-scheduled-audit &
                        {:keys [day-of-month day-of-week frequency
                                scheduled-audit-name target-check-names]
                         :as update-scheduled-audit-request})

update-security-profile clj

(update-security-profile
  &
  {:keys [additional-metrics-to-retain additional-metrics-to-retain-v2
          alert-targets behaviors delete-additional-metrics-to-retain
          delete-alert-targets delete-behaviors expected-version
          security-profile-description security-profile-name]
   :as update-security-profile-request})

update-stream clj

(update-stream &
               {:keys [description files role-arn stream-id]
                :as update-stream-request})

update-thing clj

(update-thing &
              {:keys [attribute-payload expected-version remove-thing-type
                      thing-name thing-type-name]
               :as update-thing-request})

update-thing-group clj

(update-thing-group &
                    {:keys [expected-version thing-group-name
                            thing-group-properties]
                     :as update-thing-group-request})

update-thing-groups-for-thing clj

(update-thing-groups-for-thing &
                               {:keys [override-dynamic-groups
                                       thing-groups-to-add
                                       thing-groups-to-remove thing-name]
                                :as update-thing-groups-for-thing-request})

update-topic-rule-destination clj

(update-topic-rule-destination &
                               {:keys [arn status]
                                :as update-topic-rule-destination-request})

validate-security-profile-behaviors clj

(validate-security-profile-behaviors
  &
  {:keys [behaviors] :as validate-security-profile-behaviors-request})