amazonica.aws.glue — amazonica 0.3.160

batch-create-partition clj

(batch-create-partition &
                        {:keys [catalog-id database-name partition-input-list
                                table-name]
                         :as batch-create-partition-request})

batch-delete-connection clj

(batch-delete-connection &
                         {:keys [catalog-id connection-name-list]
                          :as batch-delete-connection-request})

batch-delete-partition clj

(batch-delete-partition &
                        {:keys [catalog-id database-name partitions-to-delete
                                table-name]
                         :as batch-delete-partition-request})

batch-delete-table clj

(batch-delete-table &
                    {:keys [catalog-id database-name tables-to-delete
                            transaction-id]
                     :as batch-delete-table-request})

batch-delete-table-version clj

(batch-delete-table-version &
                            {:keys [catalog-id database-name table-name
                                    version-ids]
                             :as batch-delete-table-version-request})

batch-get-blueprints clj

(batch-get-blueprints &
                      {:keys [include-blueprint include-parameter-spec names]
                       :as batch-get-blueprints-request})

batch-get-crawlers clj

(batch-get-crawlers & {:keys [crawler-names] :as batch-get-crawlers-request})

batch-get-dev-endpoints clj

(batch-get-dev-endpoints &
                         {:keys [dev-endpoint-names]
                          :as batch-get-dev-endpoints-request})

batch-get-jobs clj

(batch-get-jobs & {:keys [job-names] :as batch-get-jobs-request})

batch-get-partition clj

(batch-get-partition &
                     {:keys [catalog-id database-name partitions-to-get
                             table-name]
                      :as batch-get-partition-request})

batch-get-triggers clj

(batch-get-triggers & {:keys [trigger-names] :as batch-get-triggers-request})

batch-get-workflows clj

(batch-get-workflows &
                     {:keys [include-graph names]
                      :as batch-get-workflows-request})

batch-stop-job-run clj

(batch-stop-job-run &
                    {:keys [job-name job-run-ids]
                     :as batch-stop-job-run-request})

batch-update-partition clj

(batch-update-partition &
                        {:keys [catalog-id database-name entries table-name]
                         :as batch-update-partition-request})

cancel-ml-task-run clj

(cancel-ml-task-run &
                    {:keys [task-run-id transform-id]
                     :as cancel-mltask-run-request})

cancel-mltask-run clj

(cancel-mltask-run &
                   {:keys [task-run-id transform-id]
                    :as cancel-mltask-run-request})

check-schema-version-validity clj

(check-schema-version-validity &
                               {:keys [data-format schema-definition]
                                :as check-schema-version-validity-request})

client-class clj

create-blueprint clj

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

create-classifier clj

(create-classifier &
                   {:keys [csv-classifier grok-classifier json-classifier
                           xml-classifier]
                    :as create-classifier-request})

create-connection clj

(create-connection &
                   {:keys [catalog-id connection-input tags]
                    :as create-connection-request})

create-crawler clj

(create-crawler &
                {:keys [classifiers configuration crawler-security-configuration
                        database-name description lineage-configuration name
                        recrawl-policy role schedule schema-change-policy
                        table-prefix tags targets]
                 :as create-crawler-request})

create-database clj

(create-database &
                 {:keys [catalog-id database-input]
                  :as create-database-request})

create-dev-endpoint clj

(create-dev-endpoint &
                     {:keys [arguments endpoint-name extra-jars-s3-path
                             extra-python-libs-s3-path glue-version
                             number-of-nodes number-of-workers public-key
                             public-keys role-arn security-configuration
                             security-group-ids subnet-id tags worker-type]
                      :as create-dev-endpoint-request})

create-job clj

(create-job &
            {:keys [allocated-capacity command connections default-arguments
                    description execution-property glue-version log-uri
                    max-capacity max-retries name non-overridable-arguments
                    notification-property number-of-workers role
                    security-configuration tags timeout worker-type]
             :as create-job-request})

create-ml-transform clj

(create-ml-transform &
                     {:keys [description glue-version input-record-tables
                             max-capacity max-retries name number-of-workers
                             parameters role tags timeout transform-encryption
                             worker-type]
                      :as create-mltransform-request})

create-mltransform clj

(create-mltransform &
                    {:keys [description glue-version input-record-tables
                            max-capacity max-retries name number-of-workers
                            parameters role tags timeout transform-encryption
                            worker-type]
                     :as create-mltransform-request})

create-partition clj

(create-partition &
                  {:keys [catalog-id database-name partition-input table-name]
                   :as create-partition-request})

create-partition-index clj

(create-partition-index &
                        {:keys [catalog-id database-name partition-index
                                table-name]
                         :as create-partition-index-request})

create-registry clj

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

create-schema clj

(create-schema &
               {:keys [compatibility data-format description registry-id
                       schema-definition schema-name tags]
                :as create-schema-request})

create-script clj

(create-script &
               {:keys [dag-edges dag-nodes language] :as create-script-request})

create-security-configuration clj

(create-security-configuration &
                               {:keys [encryption-configuration name]
                                :as create-security-configuration-request})

create-table clj

(create-table &
              {:keys [catalog-id database-name partition-indexes table-input
                      transaction-id]
               :as create-table-request})

create-trigger clj

(create-trigger &
                {:keys [actions description event-batching-condition name
                        predicate schedule start-on-creation tags type
                        workflow-name]
                 :as create-trigger-request})

create-user-defined-function clj

(create-user-defined-function &
                              {:keys [catalog-id database-name function-input]
                               :as create-user-defined-function-request})

create-workflow clj

(create-workflow &
                 {:keys [default-run-properties description max-concurrent-runs
                         name tags]
                  :as create-workflow-request})

delete-blueprint clj

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

delete-classifier clj

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

delete-column-statistics-for-partition clj

(delete-column-statistics-for-partition
  &
  {:keys [catalog-id column-name database-name partition-values table-name]
   :as delete-column-statistics-for-partition-request})

delete-column-statistics-for-table clj

(delete-column-statistics-for-table
  &
  {:keys [catalog-id column-name database-name table-name]
   :as delete-column-statistics-for-table-request})

delete-connection clj

(delete-connection &
                   {:keys [catalog-id connection-name]
                    :as delete-connection-request})

delete-crawler clj

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

delete-database clj

(delete-database & {:keys [catalog-id name] :as delete-database-request})

delete-dev-endpoint clj

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

delete-job clj

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

delete-ml-transform clj

(delete-ml-transform & {:keys [transform-id] :as delete-mltransform-request})

delete-mltransform clj

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

delete-partition clj

(delete-partition &
                  {:keys [catalog-id database-name partition-values table-name]
                   :as delete-partition-request})

delete-partition-index clj

(delete-partition-index &
                        {:keys [catalog-id database-name index-name table-name]
                         :as delete-partition-index-request})

delete-registry clj

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

delete-resource-policy clj

(delete-resource-policy &
                        {:keys [policy-hash-condition resource-arn]
                         :as delete-resource-policy-request})

delete-schema clj

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

delete-schema-versions clj

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

delete-security-configuration clj

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

delete-table clj

(delete-table &
              {:keys [catalog-id database-name name transaction-id]
               :as delete-table-request})

delete-table-version clj

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

delete-trigger clj

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

delete-user-defined-function clj

(delete-user-defined-function &
                              {:keys [catalog-id database-name function-name]
                               :as delete-user-defined-function-request})

delete-workflow clj

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

get-blueprint clj

(get-blueprint &
               {:keys [include-blueprint include-parameter-spec name]
                :as get-blueprint-request})

get-blueprint-run clj

(get-blueprint-run &
                   {:keys [blueprint-name run-id]
                    :as get-blueprint-run-request})

get-blueprint-runs clj

(get-blueprint-runs &
                    {:keys [blueprint-name max-results next-token]
                     :as get-blueprint-runs-request})

get-cached-response-metadata clj

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

get-catalog-import-status clj

(get-catalog-import-status &
                           {:keys [catalog-id]
                            :as get-catalog-import-status-request})

get-classifier clj

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

get-classifiers clj

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

get-column-statistics-for-partition clj

(get-column-statistics-for-partition
  &
  {:keys [catalog-id column-names database-name partition-values table-name]
   :as get-column-statistics-for-partition-request})

get-column-statistics-for-table clj

(get-column-statistics-for-table &
                                 {:keys [catalog-id column-names database-name
                                         table-name]
                                  :as get-column-statistics-for-table-request})

get-connection clj

(get-connection &
                {:keys [catalog-id hide-password name]
                 :as get-connection-request})

get-connections clj

(get-connections &
                 {:keys [catalog-id filter hide-password max-results next-token]
                  :as get-connections-request})

get-crawler clj

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

get-crawler-metrics clj

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

get-crawlers clj

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

get-data-catalog-encryption-settings clj

(get-data-catalog-encryption-settings
  &
  {:keys [catalog-id] :as get-data-catalog-encryption-settings-request})

get-database clj

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

get-databases clj

(get-databases &
               {:keys [catalog-id max-results next-token resource-share-type]
                :as get-databases-request})

get-dataflow-graph clj

(get-dataflow-graph & {:keys [python-script] :as get-dataflow-graph-request})

get-dev-endpoint clj

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

get-dev-endpoints clj

(get-dev-endpoints &
                   {:keys [max-results next-token]
                    :as get-dev-endpoints-request})

get-job clj

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

get-job-bookmark clj

(get-job-bookmark & {:keys [job-name run-id] :as get-job-bookmark-request})

get-job-run clj

(get-job-run &
             {:keys [job-name predecessors-included run-id]
              :as get-job-run-request})

get-job-runs clj

(get-job-runs &
              {:keys [job-name max-results next-token]
               :as get-job-runs-request})

get-jobs clj

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

get-mapping clj

(get-mapping & {:keys [location sinks source] :as get-mapping-request})

get-ml-task-run clj

(get-ml-task-run &
                 {:keys [task-run-id transform-id] :as get-mltask-run-request})

get-ml-task-runs clj

(get-ml-task-runs &
                  {:keys [filter max-results next-token sort transform-id]
                   :as get-mltask-runs-request})

get-ml-transform clj

(get-ml-transform & {:keys [transform-id] :as get-mltransform-request})

get-ml-transforms clj

(get-ml-transforms &
                   {:keys [filter max-results next-token sort]
                    :as get-mltransforms-request})

get-mltask-run clj

(get-mltask-run & {:keys [task-run-id transform-id] :as get-mltask-run-request})

get-mltask-runs clj

(get-mltask-runs &
                 {:keys [filter max-results next-token sort transform-id]
                  :as get-mltask-runs-request})

get-mltransform clj

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

get-mltransforms clj

(get-mltransforms &
                  {:keys [filter max-results next-token sort]
                   :as get-mltransforms-request})

get-partition clj

(get-partition &
               {:keys [catalog-id database-name partition-values table-name]
                :as get-partition-request})

get-partition-indexes clj

(get-partition-indexes &
                       {:keys [catalog-id database-name next-token table-name]
                        :as get-partition-indexes-request})

get-partitions clj

(get-partitions &
                {:keys [catalog-id database-name exclude-column-schema
                        expression max-results next-token query-as-of-time
                        segment table-name transaction-id]
                 :as get-partitions-request})

get-plan clj

(get-plan &
          {:keys [additional-plan-options-map language location mapping sinks
                  source]
           :as get-plan-request})

get-registry clj

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

get-resource-policies clj

(get-resource-policies &
                       {:keys [max-results next-token]
                        :as get-resource-policies-request})

get-resource-policy clj

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

get-schema clj

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

get-schema-by-definition clj

(get-schema-by-definition &
                          {:keys [schema-definition schema-id]
                           :as get-schema-by-definition-request})

get-schema-version clj

(get-schema-version &
                    {:keys [schema-id schema-version-id schema-version-number]
                     :as get-schema-version-request})

get-schema-versions-diff clj

(get-schema-versions-diff &
                          {:keys [first-schema-version-number schema-diff-type
                                  schema-id second-schema-version-number]
                           :as get-schema-versions-diff-request})

get-security-configuration clj

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

get-security-configurations clj

(get-security-configurations &
                             {:keys [max-results next-token]
                              :as get-security-configurations-request})

get-table clj

(get-table &
           {:keys [catalog-id database-name name query-as-of-time
                   transaction-id]
            :as get-table-request})

get-table-version clj

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

get-table-versions clj

(get-table-versions &
                    {:keys [catalog-id database-name max-results next-token
                            table-name]
                     :as get-table-versions-request})

get-tables clj

(get-tables &
            {:keys [catalog-id database-name expression max-results next-token
                    query-as-of-time transaction-id]
             :as get-tables-request})

get-tags clj

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

get-trigger clj

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

get-triggers clj

(get-triggers &
              {:keys [dependent-job-name max-results next-token]
               :as get-triggers-request})

get-user-defined-function clj

(get-user-defined-function &
                           {:keys [catalog-id database-name function-name]
                            :as get-user-defined-function-request})

get-user-defined-functions clj

(get-user-defined-functions &
                            {:keys [catalog-id database-name max-results
                                    next-token pattern]
                             :as get-user-defined-functions-request})

get-workflow clj

(get-workflow & {:keys [include-graph name] :as get-workflow-request})

get-workflow-run clj

(get-workflow-run &
                  {:keys [include-graph name run-id]
                   :as get-workflow-run-request})

get-workflow-run-properties clj

(get-workflow-run-properties &
                             {:keys [name run-id]
                              :as get-workflow-run-properties-request})

get-workflow-runs clj

(get-workflow-runs &
                   {:keys [include-graph max-results name next-token]
                    :as get-workflow-runs-request})

import-catalog-to-glue clj

(import-catalog-to-glue &
                        {:keys [catalog-id] :as import-catalog-to-glue-request})

list-blueprints clj

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

list-crawlers clj

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

list-dev-endpoints clj

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

list-jobs clj

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

list-ml-transforms clj

(list-ml-transforms &
                    {:keys [filter max-results next-token sort tags]
                     :as list-mltransforms-request})

list-mltransforms clj

(list-mltransforms &
                   {:keys [filter max-results next-token sort tags]
                    :as list-mltransforms-request})

list-registries clj

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

list-schema-versions clj

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

list-schemas clj

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

list-triggers clj

(list-triggers &
               {:keys [dependent-job-name max-results next-token tags]
                :as list-triggers-request})

list-workflows clj

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

put-data-catalog-encryption-settings clj

(put-data-catalog-encryption-settings
  &
  {:keys [catalog-id data-catalog-encryption-settings]
   :as put-data-catalog-encryption-settings-request})

put-resource-policy clj

(put-resource-policy &
                     {:keys [enable-hybrid policy-exists-condition
                             policy-hash-condition policy-in-json resource-arn]
                      :as put-resource-policy-request})

put-schema-version-metadata clj

(put-schema-version-metadata &
                             {:keys [metadata-key-value schema-id
                                     schema-version-id schema-version-number]
                              :as put-schema-version-metadata-request})

put-workflow-run-properties clj

(put-workflow-run-properties &
                             {:keys [name run-id run-properties]
                              :as put-workflow-run-properties-request})

query-schema-version-metadata clj

(query-schema-version-metadata &
                               {:keys [max-results metadata-list next-token
                                       schema-id schema-version-id
                                       schema-version-number]
                                :as query-schema-version-metadata-request})

register-schema-version clj

(register-schema-version &
                         {:keys [schema-definition schema-id]
                          :as register-schema-version-request})

remove-schema-version-metadata clj

(remove-schema-version-metadata &
                                {:keys [metadata-key-value schema-id
                                        schema-version-id schema-version-number]
                                 :as remove-schema-version-metadata-request})

reset-job-bookmark clj

(reset-job-bookmark & {:keys [job-name run-id] :as reset-job-bookmark-request})

resume-workflow-run clj

(resume-workflow-run &
                     {:keys [name node-ids run-id]
                      :as resume-workflow-run-request})

search-tables clj

(search-tables &
               {:keys [catalog-id filters max-results next-token
                       resource-share-type search-text sort-criteria]
                :as search-tables-request})

show-functions clj

shutdown clj

(shutdown)

start-blueprint-run clj

(start-blueprint-run &
                     {:keys [blueprint-name parameters role-arn]
                      :as start-blueprint-run-request})

start-crawler clj

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

start-crawler-schedule clj

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

start-export-labels-task-run clj

(start-export-labels-task-run &
                              {:keys [output-s3-path transform-id]
                               :as start-export-labels-task-run-request})

start-import-labels-task-run clj

(start-import-labels-task-run &
                              {:keys [input-s3-path replace-all-labels
                                      transform-id]
                               :as start-import-labels-task-run-request})

start-job-run clj

(start-job-run &
               {:keys [allocated-capacity arguments job-name job-run-id
                       max-capacity notification-property number-of-workers
                       security-configuration timeout worker-type]
                :as start-job-run-request})

start-ml-evaluation-task-run clj

(start-ml-evaluation-task-run &
                              {:keys [transform-id]
                               :as start-mlevaluation-task-run-request})

start-ml-labeling-set-generation-task-run clj

(start-ml-labeling-set-generation-task-run
  &
  {:keys [output-s3-path transform-id]
   :as start-mllabeling-set-generation-task-run-request})

start-mlevaluation-task-run clj

(start-mlevaluation-task-run &
                             {:keys [transform-id]
                              :as start-mlevaluation-task-run-request})

start-mllabeling-set-generation-task-run clj

(start-mllabeling-set-generation-task-run
  &
  {:keys [output-s3-path transform-id]
   :as start-mllabeling-set-generation-task-run-request})

start-trigger clj

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

start-workflow-run clj

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

stop-crawler clj

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

stop-crawler-schedule clj

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

stop-trigger clj

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

stop-workflow-run clj

(stop-workflow-run & {:keys [name run-id] :as stop-workflow-run-request})

tag-resource clj

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

untag-resource clj

(untag-resource &
                {:keys [resource-arn tags-to-remove]
                 :as untag-resource-request})

update-blueprint clj

(update-blueprint &
                  {:keys [blueprint-location description name]
                   :as update-blueprint-request})

update-classifier clj

(update-classifier &
                   {:keys [csv-classifier grok-classifier json-classifier
                           xml-classifier]
                    :as update-classifier-request})

update-column-statistics-for-partition clj

(update-column-statistics-for-partition
  &
  {:keys [catalog-id column-statistics-list database-name partition-values
          table-name]
   :as update-column-statistics-for-partition-request})

update-column-statistics-for-table clj

(update-column-statistics-for-table
  &
  {:keys [catalog-id column-statistics-list database-name table-name]
   :as update-column-statistics-for-table-request})

update-connection clj

(update-connection &
                   {:keys [catalog-id connection-input name]
                    :as update-connection-request})

update-crawler clj

(update-crawler &
                {:keys [classifiers configuration crawler-security-configuration
                        database-name description lineage-configuration name
                        recrawl-policy role schedule schema-change-policy
                        table-prefix targets]
                 :as update-crawler-request})

update-crawler-schedule clj

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

update-database clj

(update-database &
                 {:keys [catalog-id database-input name]
                  :as update-database-request})

update-dev-endpoint clj

(update-dev-endpoint &
                     {:keys [add-arguments add-public-keys custom-libraries
                             delete-arguments delete-public-keys endpoint-name
                             public-key update-etl-libraries]
                      :as update-dev-endpoint-request})

update-job clj

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

update-ml-transform clj

(update-ml-transform &
                     {:keys [description glue-version max-capacity max-retries
                             name number-of-workers parameters role timeout
                             transform-id worker-type]
                      :as update-mltransform-request})

update-mltransform clj

(update-mltransform &
                    {:keys [description glue-version max-capacity max-retries
                            name number-of-workers parameters role timeout
                            transform-id worker-type]
                     :as update-mltransform-request})

update-partition clj

(update-partition &
                  {:keys [catalog-id database-name partition-input
                          partition-value-list table-name]
                   :as update-partition-request})

update-registry clj

(update-registry &
                 {:keys [description registry-id] :as update-registry-request})

update-schema clj

(update-schema &
               {:keys [compatibility description schema-id
                       schema-version-number]
                :as update-schema-request})

update-table clj

(update-table &
              {:keys [catalog-id database-name skip-archive table-input
                      transaction-id]
               :as update-table-request})

update-trigger clj

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

update-user-defined-function clj

(update-user-defined-function &
                              {:keys [catalog-id database-name function-input
                                      function-name]
                               :as update-user-defined-function-request})

update-workflow clj

(update-workflow &
                 {:keys [default-run-properties description max-concurrent-runs
                         name]
                  :as update-workflow-request})