amazonica.aws.sagemaker — com.signal-ai/amazonica 0.3.157-signal-1

add-association clj

(add-association &
                 {:keys [association-type destination-arn source-arn]
                  :as add-association-request})

add-tags clj

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

associate-trial-component clj

(associate-trial-component &
                           {:keys [trial-component-name trial-name]
                            :as associate-trial-component-request})

client-class clj

create-action clj

(create-action &
               {:keys [action-name action-type description metadata-properties
                       properties source status tags]
                :as create-action-request})

create-algorithm clj

(create-algorithm &
                  {:keys [algorithm-description algorithm-name
                          certify-for-marketplace inference-specification tags
                          training-specification validation-specification]
                   :as create-algorithm-request})

create-app clj

(create-app &
            {:keys [app-name app-type domain-id resource-spec tags
                    user-profile-name]
             :as create-app-request})

create-app-image-config clj

(create-app-image-config &
                         {:keys [app-image-config-name
                                 kernel-gateway-image-config tags]
                          :as create-app-image-config-request})

create-artifact clj

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

create-auto-ml-job clj

(create-auto-ml-job
  &
  {:keys [auto-ml-job-config auto-ml-job-name auto-ml-job-objective
          generate-candidate-definitions-only input-data-config
          output-data-config problem-type role-arn tags]
   :as create-auto-mljob-request})

create-auto-mljob clj

(create-auto-mljob &
                   {:keys [auto-ml-job-config auto-ml-job-name
                           auto-ml-job-objective
                           generate-candidate-definitions-only input-data-config
                           output-data-config problem-type role-arn tags]
                    :as create-auto-mljob-request})

create-code-repository clj

(create-code-repository &
                        {:keys [code-repository-name git-config tags]
                         :as create-code-repository-request})

create-compilation-job clj

(create-compilation-job &
                        {:keys [compilation-job-name input-config output-config
                                role-arn stopping-condition tags]
                         :as create-compilation-job-request})

create-context clj

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

create-data-quality-job-definition clj

(create-data-quality-job-definition
  &
  {:keys [data-quality-app-specification data-quality-baseline-config
          data-quality-job-input data-quality-job-output-config
          job-definition-name job-resources network-config role-arn
          stopping-condition tags]
   :as create-data-quality-job-definition-request})

create-device-fleet clj

(create-device-fleet &
                     {:keys [description device-fleet-name output-config
                             role-arn tags]
                      :as create-device-fleet-request})

create-domain clj

(create-domain &
               {:keys [app-network-access-type auth-mode default-user-settings
                       domain-name home-efs-file-system-kms-key-id kms-key-id
                       subnet-ids tags vpc-id]
                :as create-domain-request})

create-edge-packaging-job clj

(create-edge-packaging-job &
                           {:keys [compilation-job-name edge-packaging-job-name
                                   model-name model-version output-config
                                   resource-key role-arn tags]
                            :as create-edge-packaging-job-request})

create-endpoint clj

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

create-endpoint-config clj

(create-endpoint-config &
                        {:keys [data-capture-config endpoint-config-name
                                kms-key-id production-variants tags]
                         :as create-endpoint-config-request})

create-experiment clj

(create-experiment &
                   {:keys [description display-name experiment-name tags]
                    :as create-experiment-request})

create-feature-group clj

(create-feature-group &
                      {:keys [description event-time-feature-name
                              feature-definitions feature-group-name
                              offline-store-config online-store-config
                              record-identifier-feature-name role-arn tags]
                       :as create-feature-group-request})

create-flow-definition clj

(create-flow-definition
  &
  {:keys [flow-definition-name human-loop-activation-config human-loop-config
          human-loop-request-source output-config role-arn tags]
   :as create-flow-definition-request})

create-human-task-ui clj

(create-human-task-ui &
                      {:keys [human-task-ui-name tags ui-template]
                       :as create-human-task-ui-request})

create-hyper-parameter-tuning-job clj

(create-hyper-parameter-tuning-job
  &
  {:keys [hyper-parameter-tuning-job-config hyper-parameter-tuning-job-name tags
          training-job-definition training-job-definitions warm-start-config]
   :as create-hyper-parameter-tuning-job-request})

create-image clj

(create-image &
              {:keys [description display-name image-name role-arn tags]
               :as create-image-request})

create-image-version clj

(create-image-version &
                      {:keys [base-image client-token image-name]
                       :as create-image-version-request})

create-labeling-job clj

(create-labeling-job &
                     {:keys [human-task-config input-config label-attribute-name
                             label-category-config-s3-uri
                             labeling-job-algorithms-config labeling-job-name
                             output-config role-arn stopping-conditions tags]
                      :as create-labeling-job-request})

create-model clj

(create-model &
              {:keys [containers enable-network-isolation execution-role-arn
                      inference-execution-config model-name primary-container
                      tags vpc-config]
               :as create-model-request})

create-model-bias-job-definition clj

(create-model-bias-job-definition
  &
  {:keys [job-definition-name job-resources model-bias-app-specification
          model-bias-baseline-config model-bias-job-input
          model-bias-job-output-config network-config role-arn
          stopping-condition tags]
   :as create-model-bias-job-definition-request})

create-model-explainability-job-definition clj

(create-model-explainability-job-definition
  &
  {:keys [job-definition-name job-resources
          model-explainability-app-specification
          model-explainability-baseline-config model-explainability-job-input
          model-explainability-job-output-config network-config role-arn
          stopping-condition tags]
   :as create-model-explainability-job-definition-request})

create-model-package clj

(create-model-package
  &
  {:keys [certify-for-marketplace client-token inference-specification
          metadata-properties model-approval-status model-metrics
          model-package-description model-package-group-name model-package-name
          source-algorithm-specification tags validation-specification]
   :as create-model-package-request})

create-model-package-group clj

(create-model-package-group &
                            {:keys [model-package-group-description
                                    model-package-group-name tags]
                             :as create-model-package-group-request})

create-model-quality-job-definition clj

(create-model-quality-job-definition
  &
  {:keys [job-definition-name job-resources model-quality-app-specification
          model-quality-baseline-config model-quality-job-input
          model-quality-job-output-config network-config role-arn
          stopping-condition tags]
   :as create-model-quality-job-definition-request})

create-monitoring-schedule clj

(create-monitoring-schedule &
                            {:keys [monitoring-schedule-config
                                    monitoring-schedule-name tags]
                             :as create-monitoring-schedule-request})

create-notebook-instance clj

(create-notebook-instance
  &
  {:keys [accelerator-types additional-code-repositories default-code-repository
          direct-internet-access instance-type kms-key-id lifecycle-config-name
          notebook-instance-name role-arn root-access security-group-ids
          subnet-id tags volume-size-in-gb]
   :as create-notebook-instance-request})

create-notebook-instance-lifecycle-config clj

(create-notebook-instance-lifecycle-config
  &
  {:keys [notebook-instance-lifecycle-config-name on-create on-start]
   :as create-notebook-instance-lifecycle-config-request})

create-pipeline clj

(create-pipeline &
                 {:keys [client-request-token pipeline-definition
                         pipeline-description pipeline-display-name
                         pipeline-name role-arn tags]
                  :as create-pipeline-request})

create-presigned-domain-url clj

(create-presigned-domain-url &
                             {:keys [domain-id expires-in-seconds
                                     session-expiration-duration-in-seconds
                                     user-profile-name]
                              :as create-presigned-domain-url-request})

create-presigned-notebook-instance-url clj

(create-presigned-notebook-instance-url
  &
  {:keys [notebook-instance-name session-expiration-duration-in-seconds]
   :as create-presigned-notebook-instance-url-request})

create-processing-job clj

(create-processing-job
  &
  {:keys [app-specification environment experiment-config network-config
          processing-inputs processing-job-name processing-output-config
          processing-resources role-arn stopping-condition tags]
   :as create-processing-job-request})

create-project clj

(create-project &
                {:keys [project-description project-name
                        service-catalog-provisioning-details tags]
                 :as create-project-request})

create-training-job clj

(create-training-job
  &
  {:keys [algorithm-specification checkpoint-config debug-hook-config
          debug-rule-configurations enable-inter-container-traffic-encryption
          enable-managed-spot-training enable-network-isolation
          experiment-config hyper-parameters input-data-config
          output-data-config profiler-config profiler-rule-configurations
          resource-config role-arn stopping-condition tags
          tensor-board-output-config training-job-name vpc-config]
   :as create-training-job-request})

create-transform-job clj

(create-transform-job &
                      {:keys [batch-strategy data-processing environment
                              experiment-config max-concurrent-transforms
                              max-payload-in-mb model-client-config model-name
                              tags transform-input transform-job-name
                              transform-output transform-resources]
                       :as create-transform-job-request})

create-trial clj

(create-trial &
              {:keys [display-name experiment-name metadata-properties tags
                      trial-name]
               :as create-trial-request})

create-trial-component clj

(create-trial-component &
                        {:keys [display-name end-time input-artifacts
                                metadata-properties output-artifacts parameters
                                start-time status tags trial-component-name]
                         :as create-trial-component-request})

create-user-profile clj

(create-user-profile &
                     {:keys [domain-id single-sign-on-user-identifier
                             single-sign-on-user-value tags user-profile-name
                             user-settings]
                      :as create-user-profile-request})

create-workforce clj

(create-workforce &
                  {:keys [cognito-config oidc-config source-ip-config tags
                          workforce-name]
                   :as create-workforce-request})

create-workteam clj

(create-workteam &
                 {:keys [description member-definitions
                         notification-configuration tags workforce-name
                         workteam-name]
                  :as create-workteam-request})

delete-action clj

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

delete-algorithm clj

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

delete-app clj

(delete-app &
            {:keys [app-name app-type domain-id user-profile-name]
             :as delete-app-request})

delete-app-image-config clj

(delete-app-image-config &
                         {:keys [app-image-config-name]
                          :as delete-app-image-config-request})

delete-artifact clj

(delete-artifact & {:keys [artifact-arn source] :as delete-artifact-request})

delete-association clj

(delete-association &
                    {:keys [destination-arn source-arn]
                     :as delete-association-request})

delete-code-repository clj

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

delete-context clj

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

delete-data-quality-job-definition clj

(delete-data-quality-job-definition
  &
  {:keys [job-definition-name] :as delete-data-quality-job-definition-request})

delete-device-fleet clj

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

delete-domain clj

(delete-domain & {:keys [domain-id retention-policy] :as delete-domain-request})

delete-endpoint clj

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

delete-endpoint-config clj

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

delete-experiment clj

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

delete-feature-group clj

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

delete-flow-definition clj

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

delete-human-task-ui clj

(delete-human-task-ui &
                      {:keys [human-task-ui-name]
                       :as delete-human-task-ui-request})

delete-image clj

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

delete-image-version clj

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

delete-model clj

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

delete-model-bias-job-definition clj

(delete-model-bias-job-definition
  &
  {:keys [job-definition-name] :as delete-model-bias-job-definition-request})

delete-model-explainability-job-definition clj

(delete-model-explainability-job-definition
  &
  {:keys [job-definition-name]
   :as delete-model-explainability-job-definition-request})

delete-model-package clj

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

delete-model-package-group clj

(delete-model-package-group &
                            {:keys [model-package-group-name]
                             :as delete-model-package-group-request})

delete-model-package-group-policy clj

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

delete-model-quality-job-definition clj

(delete-model-quality-job-definition
  &
  {:keys [job-definition-name] :as delete-model-quality-job-definition-request})

delete-monitoring-schedule clj

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

delete-notebook-instance clj

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

delete-notebook-instance-lifecycle-config clj

(delete-notebook-instance-lifecycle-config
  &
  {:keys [notebook-instance-lifecycle-config-name]
   :as delete-notebook-instance-lifecycle-config-request})

delete-pipeline clj

(delete-pipeline &
                 {:keys [client-request-token pipeline-name]
                  :as delete-pipeline-request})

delete-project clj

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

delete-tags clj

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

delete-trial clj

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

delete-trial-component clj

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

delete-user-profile clj

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

delete-workforce clj

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

delete-workteam clj

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

deregister-devices clj

(deregister-devices &
                    {:keys [device-fleet-name device-names]
                     :as deregister-devices-request})

describe-action clj

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

describe-algorithm clj

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

describe-app clj

(describe-app &
              {:keys [app-name app-type domain-id user-profile-name]
               :as describe-app-request})

describe-app-image-config clj

(describe-app-image-config &
                           {:keys [app-image-config-name]
                            :as describe-app-image-config-request})

describe-artifact clj

(describe-artifact & {:keys [artifact-arn] :as describe-artifact-request})

describe-auto-ml-job clj

(describe-auto-ml-job &
                      {:keys [auto-ml-job-name]
                       :as describe-auto-mljob-request})

describe-auto-mljob clj

(describe-auto-mljob &
                     {:keys [auto-ml-job-name] :as describe-auto-mljob-request})

describe-code-repository clj

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

describe-compilation-job clj

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

describe-context clj

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

describe-data-quality-job-definition clj

(describe-data-quality-job-definition
  &
  {:keys [job-definition-name]
   :as describe-data-quality-job-definition-request})

describe-device clj

(describe-device &
                 {:keys [device-fleet-name device-name next-token]
                  :as describe-device-request})

describe-device-fleet clj

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

describe-domain clj

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

describe-edge-packaging-job clj

(describe-edge-packaging-job &
                             {:keys [edge-packaging-job-name]
                              :as describe-edge-packaging-job-request})

describe-endpoint clj

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

describe-endpoint-config clj

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

describe-experiment clj

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

describe-feature-group clj

(describe-feature-group &
                        {:keys [feature-group-name next-token]
                         :as describe-feature-group-request})

describe-flow-definition clj

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

describe-human-task-ui clj

(describe-human-task-ui &
                        {:keys [human-task-ui-name]
                         :as describe-human-task-ui-request})

describe-hyper-parameter-tuning-job clj

(describe-hyper-parameter-tuning-job
  &
  {:keys [hyper-parameter-tuning-job-name]
   :as describe-hyper-parameter-tuning-job-request})

describe-image clj

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

describe-image-version clj

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

describe-labeling-job clj

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

describe-model clj

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

describe-model-bias-job-definition clj

(describe-model-bias-job-definition
  &
  {:keys [job-definition-name] :as describe-model-bias-job-definition-request})

describe-model-explainability-job-definition clj

(describe-model-explainability-job-definition
  &
  {:keys [job-definition-name]
   :as describe-model-explainability-job-definition-request})

describe-model-package clj

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

describe-model-package-group clj

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

describe-model-quality-job-definition clj

(describe-model-quality-job-definition
  &
  {:keys [job-definition-name]
   :as describe-model-quality-job-definition-request})

describe-monitoring-schedule clj

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

describe-notebook-instance clj

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

describe-notebook-instance-lifecycle-config clj

(describe-notebook-instance-lifecycle-config
  &
  {:keys [notebook-instance-lifecycle-config-name]
   :as describe-notebook-instance-lifecycle-config-request})

describe-pipeline clj

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

describe-pipeline-definition-for-execution clj

(describe-pipeline-definition-for-execution
  &
  {:keys [pipeline-execution-arn]
   :as describe-pipeline-definition-for-execution-request})

describe-pipeline-execution clj

(describe-pipeline-execution &
                             {:keys [pipeline-execution-arn]
                              :as describe-pipeline-execution-request})

describe-processing-job clj

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

describe-project clj

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

describe-subscribed-workteam clj

(describe-subscribed-workteam &
                              {:keys [workteam-arn]
                               :as describe-subscribed-workteam-request})

describe-training-job clj

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

describe-transform-job clj

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

describe-trial clj

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

describe-trial-component clj

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

describe-user-profile clj

(describe-user-profile &
                       {:keys [domain-id user-profile-name]
                        :as describe-user-profile-request})

describe-workforce clj

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

describe-workteam clj

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

disable-sagemaker-servicecatalog-portfolio clj

(disable-sagemaker-servicecatalog-portfolio
  &
  {:keys [] :as disable-sagemaker-servicecatalog-portfolio-request})

disassociate-trial-component clj

(disassociate-trial-component &
                              {:keys [trial-component-name trial-name]
                               :as disassociate-trial-component-request})

enable-sagemaker-servicecatalog-portfolio clj

(enable-sagemaker-servicecatalog-portfolio
  &
  {:keys [] :as enable-sagemaker-servicecatalog-portfolio-request})

get-cached-response-metadata clj

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

get-device-fleet-report clj

(get-device-fleet-report &
                         {:keys [device-fleet-name]
                          :as get-device-fleet-report-request})

get-model-package-group-policy clj

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

get-sagemaker-servicecatalog-portfolio-status clj

(get-sagemaker-servicecatalog-portfolio-status
  &
  {:keys [] :as get-sagemaker-servicecatalog-portfolio-status-request})

get-search-suggestions clj

(get-search-suggestions &
                        {:keys [resource suggestion-query]
                         :as get-search-suggestions-request})

list-actions clj

(list-actions &
              {:keys [action-type created-after created-before max-results
                      next-token sort-by sort-order source-uri]
               :as list-actions-request})

list-algorithms clj

(list-algorithms &
                 {:keys [creation-time-after creation-time-before max-results
                         name-contains next-token sort-by sort-order]
                  :as list-algorithms-request})

list-app-image-configs clj

(list-app-image-configs &
                        {:keys [creation-time-after creation-time-before
                                max-results modified-time-after
                                modified-time-before name-contains next-token
                                sort-by sort-order]
                         :as list-app-image-configs-request})

list-apps clj

(list-apps &
           {:keys [domain-id-equals max-results next-token sort-by sort-order
                   user-profile-name-equals]
            :as list-apps-request})

list-artifacts clj

(list-artifacts &
                {:keys [artifact-type created-after created-before max-results
                        next-token sort-by sort-order source-uri]
                 :as list-artifacts-request})

list-associations clj

(list-associations &
                   {:keys [association-type created-after created-before
                           destination-arn destination-type max-results
                           next-token sort-by sort-order source-arn source-type]
                    :as list-associations-request})

list-auto-ml-jobs clj

(list-auto-ml-jobs &
                   {:keys [creation-time-after creation-time-before
                           last-modified-time-after last-modified-time-before
                           max-results name-contains next-token sort-by
                           sort-order status-equals]
                    :as list-auto-mljobs-request})

list-auto-mljobs clj

(list-auto-mljobs &
                  {:keys [creation-time-after creation-time-before
                          last-modified-time-after last-modified-time-before
                          max-results name-contains next-token sort-by
                          sort-order status-equals]
                   :as list-auto-mljobs-request})

list-candidates-for-auto-ml-job clj

(list-candidates-for-auto-ml-job &
                                 {:keys [auto-ml-job-name candidate-name-equals
                                         max-results next-token sort-by
                                         sort-order status-equals]
                                  :as list-candidates-for-auto-mljob-request})

list-candidates-for-auto-mljob clj

(list-candidates-for-auto-mljob &
                                {:keys [auto-ml-job-name candidate-name-equals
                                        max-results next-token sort-by
                                        sort-order status-equals]
                                 :as list-candidates-for-auto-mljob-request})

list-code-repositories clj

(list-code-repositories &
                        {:keys [creation-time-after creation-time-before
                                last-modified-time-after
                                last-modified-time-before max-results
                                name-contains next-token sort-by sort-order]
                         :as list-code-repositories-request})

list-compilation-jobs clj

(list-compilation-jobs
  &
  {:keys [creation-time-after creation-time-before last-modified-time-after
          last-modified-time-before max-results name-contains next-token sort-by
          sort-order status-equals]
   :as list-compilation-jobs-request})

list-contexts clj

(list-contexts &
               {:keys [context-type created-after created-before max-results
                       next-token sort-by sort-order source-uri]
                :as list-contexts-request})

list-data-quality-job-definitions clj

(list-data-quality-job-definitions
  &
  {:keys [creation-time-after creation-time-before endpoint-name max-results
          name-contains next-token sort-by sort-order]
   :as list-data-quality-job-definitions-request})

list-device-fleets clj

(list-device-fleets &
                    {:keys [creation-time-after creation-time-before
                            last-modified-time-after last-modified-time-before
                            max-results name-contains next-token sort-by
                            sort-order]
                     :as list-device-fleets-request})

list-devices clj

(list-devices &
              {:keys [device-fleet-name latest-heartbeat-after max-results
                      model-name next-token]
               :as list-devices-request})

list-domains clj

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

list-edge-packaging-jobs clj

(list-edge-packaging-jobs
  &
  {:keys [creation-time-after creation-time-before last-modified-time-after
          last-modified-time-before max-results model-name-contains
          name-contains next-token sort-by sort-order status-equals]
   :as list-edge-packaging-jobs-request})

list-endpoint-configs clj

(list-endpoint-configs &
                       {:keys [creation-time-after creation-time-before
                               max-results name-contains next-token sort-by
                               sort-order]
                        :as list-endpoint-configs-request})

list-endpoints clj

(list-endpoints &
                {:keys [creation-time-after creation-time-before
                        last-modified-time-after last-modified-time-before
                        max-results name-contains next-token sort-by sort-order
                        status-equals]
                 :as list-endpoints-request})

list-experiments clj

(list-experiments &
                  {:keys [created-after created-before max-results next-token
                          sort-by sort-order]
                   :as list-experiments-request})

list-feature-groups clj

(list-feature-groups &
                     {:keys [creation-time-after creation-time-before
                             feature-group-status-equals max-results
                             name-contains next-token
                             offline-store-status-equals sort-by sort-order]
                      :as list-feature-groups-request})

list-flow-definitions clj

(list-flow-definitions &
                       {:keys [creation-time-after creation-time-before
                               max-results next-token sort-order]
                        :as list-flow-definitions-request})

list-human-task-uis clj

(list-human-task-uis &
                     {:keys [creation-time-after creation-time-before
                             max-results next-token sort-order]
                      :as list-human-task-uis-request})

list-hyper-parameter-tuning-jobs clj

(list-hyper-parameter-tuning-jobs
  &
  {:keys [creation-time-after creation-time-before last-modified-time-after
          last-modified-time-before max-results name-contains next-token sort-by
          sort-order status-equals]
   :as list-hyper-parameter-tuning-jobs-request})

list-image-versions clj

(list-image-versions &
                     {:keys [creation-time-after creation-time-before image-name
                             last-modified-time-after last-modified-time-before
                             max-results next-token sort-by sort-order]
                      :as list-image-versions-request})

list-images clj

(list-images &
             {:keys [creation-time-after creation-time-before
                     last-modified-time-after last-modified-time-before
                     max-results name-contains next-token sort-by sort-order]
              :as list-images-request})

list-labeling-jobs clj

(list-labeling-jobs &
                    {:keys [creation-time-after creation-time-before
                            last-modified-time-after last-modified-time-before
                            max-results name-contains next-token sort-by
                            sort-order status-equals]
                     :as list-labeling-jobs-request})

list-labeling-jobs-for-workteam clj

(list-labeling-jobs-for-workteam
  &
  {:keys [creation-time-after creation-time-before job-reference-code-contains
          max-results next-token sort-by sort-order workteam-arn]
   :as list-labeling-jobs-for-workteam-request})

list-model-bias-job-definitions clj

(list-model-bias-job-definitions
  &
  {:keys [creation-time-after creation-time-before endpoint-name max-results
          name-contains next-token sort-by sort-order]
   :as list-model-bias-job-definitions-request})

list-model-explainability-job-definitions clj

(list-model-explainability-job-definitions
  &
  {:keys [creation-time-after creation-time-before endpoint-name max-results
          name-contains next-token sort-by sort-order]
   :as list-model-explainability-job-definitions-request})

list-model-package-groups clj

(list-model-package-groups &
                           {:keys [creation-time-after creation-time-before
                                   max-results name-contains next-token sort-by
                                   sort-order]
                            :as list-model-package-groups-request})

list-model-packages clj

(list-model-packages &
                     {:keys [creation-time-after creation-time-before
                             max-results model-approval-status
                             model-package-group-name model-package-type
                             name-contains next-token sort-by sort-order]
                      :as list-model-packages-request})

list-model-quality-job-definitions clj

(list-model-quality-job-definitions
  &
  {:keys [creation-time-after creation-time-before endpoint-name max-results
          name-contains next-token sort-by sort-order]
   :as list-model-quality-job-definitions-request})

list-models clj

(list-models &
             {:keys [creation-time-after creation-time-before max-results
                     name-contains next-token sort-by sort-order]
              :as list-models-request})

list-monitoring-executions clj

(list-monitoring-executions
  &
  {:keys [creation-time-after creation-time-before endpoint-name
          last-modified-time-after last-modified-time-before max-results
          monitoring-job-definition-name monitoring-schedule-name
          monitoring-type-equals next-token scheduled-time-after
          scheduled-time-before sort-by sort-order status-equals]
   :as list-monitoring-executions-request})

list-monitoring-schedules clj

(list-monitoring-schedules
  &
  {:keys [creation-time-after creation-time-before endpoint-name
          last-modified-time-after last-modified-time-before max-results
          monitoring-job-definition-name monitoring-type-equals name-contains
          next-token sort-by sort-order status-equals]
   :as list-monitoring-schedules-request})

list-notebook-instance-lifecycle-configs clj

(list-notebook-instance-lifecycle-configs
  &
  {:keys [creation-time-after creation-time-before last-modified-time-after
          last-modified-time-before max-results name-contains next-token sort-by
          sort-order]
   :as list-notebook-instance-lifecycle-configs-request})

list-notebook-instances clj

(list-notebook-instances
  &
  {:keys [additional-code-repository-equals creation-time-after
          creation-time-before default-code-repository-contains
          last-modified-time-after last-modified-time-before max-results
          name-contains next-token
          notebook-instance-lifecycle-config-name-contains sort-by sort-order
          status-equals]
   :as list-notebook-instances-request})

list-pipeline-execution-steps clj

(list-pipeline-execution-steps &
                               {:keys [max-results next-token
                                       pipeline-execution-arn sort-order]
                                :as list-pipeline-execution-steps-request})

list-pipeline-executions clj

(list-pipeline-executions &
                          {:keys [created-after created-before max-results
                                  next-token pipeline-name sort-by sort-order]
                           :as list-pipeline-executions-request})

list-pipeline-parameters-for-execution clj

(list-pipeline-parameters-for-execution
  &
  {:keys [max-results next-token pipeline-execution-arn]
   :as list-pipeline-parameters-for-execution-request})

list-pipelines clj

(list-pipelines &
                {:keys [created-after created-before max-results next-token
                        pipeline-name-prefix sort-by sort-order]
                 :as list-pipelines-request})

list-processing-jobs clj

(list-processing-jobs &
                      {:keys [creation-time-after creation-time-before
                              last-modified-time-after last-modified-time-before
                              max-results name-contains next-token sort-by
                              sort-order status-equals]
                       :as list-processing-jobs-request})

list-projects clj

(list-projects &
               {:keys [creation-time-after creation-time-before max-results
                       name-contains next-token sort-by sort-order]
                :as list-projects-request})

list-subscribed-workteams clj

(list-subscribed-workteams &
                           {:keys [max-results name-contains next-token]
                            :as list-subscribed-workteams-request})

list-tags clj

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

list-training-jobs clj

(list-training-jobs &
                    {:keys [creation-time-after creation-time-before
                            last-modified-time-after last-modified-time-before
                            max-results name-contains next-token sort-by
                            sort-order status-equals]
                     :as list-training-jobs-request})

list-training-jobs-for-hyper-parameter-tuning-job clj

(list-training-jobs-for-hyper-parameter-tuning-job
  &
  {:keys [hyper-parameter-tuning-job-name max-results next-token sort-by
          sort-order status-equals]
   :as list-training-jobs-for-hyper-parameter-tuning-job-request})

list-transform-jobs clj

(list-transform-jobs &
                     {:keys [creation-time-after creation-time-before
                             last-modified-time-after last-modified-time-before
                             max-results name-contains next-token sort-by
                             sort-order status-equals]
                      :as list-transform-jobs-request})

list-trial-components clj

(list-trial-components &
                       {:keys [created-after created-before experiment-name
                               max-results next-token sort-by sort-order
                               source-arn trial-name]
                        :as list-trial-components-request})

list-trials clj

(list-trials &
             {:keys [created-after created-before experiment-name max-results
                     next-token sort-by sort-order trial-component-name]
              :as list-trials-request})

list-user-profiles clj

(list-user-profiles &
                    {:keys [domain-id-equals max-results next-token sort-by
                            sort-order user-profile-name-contains]
                     :as list-user-profiles-request})

list-workforces clj

(list-workforces &
                 {:keys [max-results name-contains next-token sort-by
                         sort-order]
                  :as list-workforces-request})

list-workteams clj

(list-workteams &
                {:keys [max-results name-contains next-token sort-by sort-order]
                 :as list-workteams-request})

put-model-package-group-policy clj

(put-model-package-group-policy &
                                {:keys [model-package-group-name
                                        resource-policy]
                                 :as put-model-package-group-policy-request})

register-devices clj

(register-devices &
                  {:keys [device-fleet-name devices tags]
                   :as register-devices-request})

render-ui-template clj

(render-ui-template &
                    {:keys [human-task-ui-arn role-arn task ui-template]
                     :as render-ui-template-request})

search clj

(search &
        {:keys [max-results next-token resource search-expression sort-by
                sort-order]
         :as search-request})

show-functions clj

shutdown clj

(shutdown)

start-monitoring-schedule clj

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

start-notebook-instance clj

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

start-pipeline-execution clj

(start-pipeline-execution
  &
  {:keys [client-request-token pipeline-execution-description
          pipeline-execution-display-name pipeline-name pipeline-parameters]
   :as start-pipeline-execution-request})

stop-auto-ml-job clj

(stop-auto-ml-job & {:keys [auto-ml-job-name] :as stop-auto-mljob-request})

stop-auto-mljob clj

(stop-auto-mljob & {:keys [auto-ml-job-name] :as stop-auto-mljob-request})

stop-compilation-job clj

(stop-compilation-job &
                      {:keys [compilation-job-name]
                       :as stop-compilation-job-request})

stop-edge-packaging-job clj

(stop-edge-packaging-job &
                         {:keys [edge-packaging-job-name]
                          :as stop-edge-packaging-job-request})

stop-hyper-parameter-tuning-job clj

(stop-hyper-parameter-tuning-job &
                                 {:keys [hyper-parameter-tuning-job-name]
                                  :as stop-hyper-parameter-tuning-job-request})

stop-labeling-job clj

(stop-labeling-job & {:keys [labeling-job-name] :as stop-labeling-job-request})

stop-monitoring-schedule clj

(stop-monitoring-schedule &
                          {:keys [monitoring-schedule-name]
                           :as stop-monitoring-schedule-request})

stop-notebook-instance clj

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

stop-pipeline-execution clj

(stop-pipeline-execution &
                         {:keys [client-request-token pipeline-execution-arn]
                          :as stop-pipeline-execution-request})

stop-processing-job clj

(stop-processing-job &
                     {:keys [processing-job-name]
                      :as stop-processing-job-request})

stop-training-job clj

(stop-training-job & {:keys [training-job-name] :as stop-training-job-request})

stop-transform-job clj

(stop-transform-job &
                    {:keys [transform-job-name] :as stop-transform-job-request})

update-action clj

(update-action &
               {:keys [action-name description properties properties-to-remove
                       status]
                :as update-action-request})

update-app-image-config clj

(update-app-image-config &
                         {:keys [app-image-config-name
                                 kernel-gateway-image-config]
                          :as update-app-image-config-request})

update-artifact clj

(update-artifact &
                 {:keys [artifact-arn artifact-name properties
                         properties-to-remove]
                  :as update-artifact-request})

update-code-repository clj

(update-code-repository &
                        {:keys [code-repository-name git-config]
                         :as update-code-repository-request})

update-context clj

(update-context &
                {:keys [context-name description properties
                        properties-to-remove]
                 :as update-context-request})

update-device-fleet clj

(update-device-fleet &
                     {:keys [description device-fleet-name output-config
                             role-arn]
                      :as update-device-fleet-request})

update-devices clj

(update-devices &
                {:keys [device-fleet-name devices] :as update-devices-request})

update-domain clj

(update-domain &
               {:keys [default-user-settings domain-id]
                :as update-domain-request})

update-endpoint clj

(update-endpoint &
                 {:keys [deployment-config endpoint-config-name endpoint-name
                         exclude-retained-variant-properties
                         retain-all-variant-properties]
                  :as update-endpoint-request})

update-endpoint-weights-and-capacities clj

(update-endpoint-weights-and-capacities
  &
  {:keys [desired-weights-and-capacities endpoint-name]
   :as update-endpoint-weights-and-capacities-request})

update-experiment clj

(update-experiment &
                   {:keys [description display-name experiment-name]
                    :as update-experiment-request})

update-image clj

(update-image &
              {:keys [delete-properties description display-name image-name
                      role-arn]
               :as update-image-request})

update-model-package clj

(update-model-package &
                      {:keys [approval-description model-approval-status
                              model-package-arn]
                       :as update-model-package-request})

update-monitoring-schedule clj

(update-monitoring-schedule &
                            {:keys [monitoring-schedule-config
                                    monitoring-schedule-name]
                             :as update-monitoring-schedule-request})

update-notebook-instance clj

(update-notebook-instance
  &
  {:keys [accelerator-types additional-code-repositories default-code-repository
          disassociate-accelerator-types
          disassociate-additional-code-repositories
          disassociate-default-code-repository disassociate-lifecycle-config
          instance-type lifecycle-config-name notebook-instance-name role-arn
          root-access volume-size-in-gb]
   :as update-notebook-instance-request})

update-notebook-instance-lifecycle-config clj

(update-notebook-instance-lifecycle-config
  &
  {:keys [notebook-instance-lifecycle-config-name on-create on-start]
   :as update-notebook-instance-lifecycle-config-request})

update-pipeline clj

(update-pipeline &
                 {:keys [pipeline-definition pipeline-description
                         pipeline-display-name pipeline-name role-arn]
                  :as update-pipeline-request})

update-pipeline-execution clj

(update-pipeline-execution &
                           {:keys [pipeline-execution-arn
                                   pipeline-execution-description
                                   pipeline-execution-display-name]
                            :as update-pipeline-execution-request})

update-training-job clj

(update-training-job &
                     {:keys [profiler-config profiler-rule-configurations
                             training-job-name]
                      :as update-training-job-request})

update-trial clj

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

update-trial-component clj

(update-trial-component
  &
  {:keys [display-name end-time input-artifacts input-artifacts-to-remove
          output-artifacts output-artifacts-to-remove parameters
          parameters-to-remove start-time status trial-component-name]
   :as update-trial-component-request})

update-user-profile clj

(update-user-profile &
                     {:keys [domain-id user-profile-name user-settings]
                      :as update-user-profile-request})

update-workforce clj

(update-workforce &
                  {:keys [oidc-config source-ip-config workforce-name]
                   :as update-workforce-request})

update-workteam clj

(update-workteam &
                 {:keys [description member-definitions
                         notification-configuration workteam-name]
                  :as update-workteam-request})

waiters clj

(waiters)