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

client-class clj

create-api-key clj

(create-api-key &
                {:keys [customer-id description enabled generate-distinct-id
                        name stage-keys tags value]
                 :as create-api-key-request})

create-authorizer clj

(create-authorizer &
                   {:keys [auth-type authorizer-credentials
                           authorizer-result-ttl-in-seconds authorizer-uri
                           identity-source identity-validation-expression name
                           provider-ar-ns rest-api-id type]
                    :as create-authorizer-request})

create-base-path-mapping clj

(create-base-path-mapping &
                          {:keys [base-path domain-name rest-api-id stage]
                           :as create-base-path-mapping-request})

create-deployment clj

(create-deployment
  &
  {:keys [cache-cluster-enabled cache-cluster-size canary-settings description
          rest-api-id stage-description stage-name tracing-enabled variables]
   :as create-deployment-request})

create-documentation-part clj

(create-documentation-part &
                           {:keys [location properties rest-api-id]
                            :as create-documentation-part-request})

create-documentation-version clj

(create-documentation-version &
                              {:keys [description documentation-version
                                      rest-api-id stage-name]
                               :as create-documentation-version-request})

create-domain-name clj

(create-domain-name &
                    {:keys [certificate-arn certificate-body certificate-chain
                            certificate-name certificate-private-key domain-name
                            endpoint-configuration mutual-tls-authentication
                            ownership-verification-certificate-arn
                            regional-certificate-arn regional-certificate-name
                            security-policy tags]
                     :as create-domain-name-request})

create-model clj

(create-model &
              {:keys [content-type description name rest-api-id schema]
               :as create-model-request})

create-request-validator clj

(create-request-validator &
                          {:keys [name rest-api-id validate-request-body
                                  validate-request-parameters]
                           :as create-request-validator-request})

create-resource clj

(create-resource &
                 {:keys [parent-id path-part rest-api-id]
                  :as create-resource-request})

create-rest-api clj

(create-rest-api &
                 {:keys [api-key-source binary-media-types clone-from
                         description disable-execute-api-endpoint
                         endpoint-configuration minimum-compression-size name
                         policy tags version]
                  :as create-rest-api-request})

create-stage clj

(create-stage &
              {:keys [cache-cluster-enabled cache-cluster-size canary-settings
                      deployment-id description documentation-version
                      rest-api-id stage-name tags tracing-enabled variables]
               :as create-stage-request})

create-usage-plan clj

(create-usage-plan &
                   {:keys [api-stages description name quota tags throttle]
                    :as create-usage-plan-request})

create-usage-plan-key clj

(create-usage-plan-key &
                       {:keys [key-id key-type usage-plan-id]
                        :as create-usage-plan-key-request})

create-vpc-link clj

(create-vpc-link &
                 {:keys [description name tags target-arns]
                  :as create-vpc-link-request})

delete-api-key clj

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

delete-authorizer clj

(delete-authorizer &
                   {:keys [authorizer-id rest-api-id]
                    :as delete-authorizer-request})

delete-base-path-mapping clj

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

delete-client-certificate clj

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

delete-deployment clj

(delete-deployment &
                   {:keys [deployment-id rest-api-id]
                    :as delete-deployment-request})

delete-documentation-part clj

(delete-documentation-part &
                           {:keys [documentation-part-id rest-api-id]
                            :as delete-documentation-part-request})

delete-documentation-version clj

(delete-documentation-version &
                              {:keys [documentation-version rest-api-id]
                               :as delete-documentation-version-request})

delete-domain-name clj

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

delete-gateway-response clj

(delete-gateway-response &
                         {:keys [response-type rest-api-id]
                          :as delete-gateway-response-request})

delete-integration clj

(delete-integration &
                    {:keys [http-method resource-id rest-api-id]
                     :as delete-integration-request})

delete-integration-response clj

(delete-integration-response &
                             {:keys [http-method resource-id rest-api-id
                                     status-code]
                              :as delete-integration-response-request})

delete-method clj

(delete-method &
               {:keys [http-method resource-id rest-api-id]
                :as delete-method-request})

delete-method-response clj

(delete-method-response &
                        {:keys [http-method resource-id rest-api-id status-code]
                         :as delete-method-response-request})

delete-model clj

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

delete-request-validator clj

(delete-request-validator &
                          {:keys [request-validator-id rest-api-id]
                           :as delete-request-validator-request})

delete-resource clj

(delete-resource &
                 {:keys [resource-id rest-api-id] :as delete-resource-request})

delete-rest-api clj

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

delete-stage clj

(delete-stage & {:keys [rest-api-id stage-name] :as delete-stage-request})

delete-usage-plan clj

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

delete-usage-plan-key clj

(delete-usage-plan-key &
                       {:keys [key-id usage-plan-id]
                        :as delete-usage-plan-key-request})

delete-vpc-link clj

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

flush-stage-authorizers-cache clj

(flush-stage-authorizers-cache &
                               {:keys [rest-api-id stage-name]
                                :as flush-stage-authorizers-cache-request})

flush-stage-cache clj

(flush-stage-cache &
                   {:keys [rest-api-id stage-name]
                    :as flush-stage-cache-request})

generate-client-certificate clj

(generate-client-certificate &
                             {:keys [description tags]
                              :as generate-client-certificate-request})

get-account clj

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

get-api-key clj

(get-api-key & {:keys [api-key include-value] :as get-api-key-request})

get-api-keys clj

(get-api-keys &
              {:keys [customer-id include-values limit name-query position]
               :as get-api-keys-request})

get-authorizer clj

(get-authorizer &
                {:keys [authorizer-id rest-api-id] :as get-authorizer-request})

get-authorizers clj

(get-authorizers &
                 {:keys [limit position rest-api-id]
                  :as get-authorizers-request})

get-base-path-mapping clj

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

get-base-path-mappings clj

(get-base-path-mappings &
                        {:keys [domain-name limit position]
                         :as get-base-path-mappings-request})

get-cached-response-metadata clj

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

get-client-certificate clj

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

get-client-certificates clj

(get-client-certificates &
                         {:keys [limit position]
                          :as get-client-certificates-request})

get-deployment clj

(get-deployment &
                {:keys [deployment-id embed rest-api-id]
                 :as get-deployment-request})

get-deployments clj

(get-deployments &
                 {:keys [limit position rest-api-id]
                  :as get-deployments-request})

get-documentation-part clj

(get-documentation-part &
                        {:keys [documentation-part-id rest-api-id]
                         :as get-documentation-part-request})

get-documentation-parts clj

(get-documentation-parts &
                         {:keys [limit location-status name-query path position
                                 rest-api-id type]
                          :as get-documentation-parts-request})

get-documentation-version clj

(get-documentation-version &
                           {:keys [documentation-version rest-api-id]
                            :as get-documentation-version-request})

get-documentation-versions clj

(get-documentation-versions &
                            {:keys [limit position rest-api-id]
                             :as get-documentation-versions-request})

get-domain-name clj

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

get-domain-names clj

(get-domain-names & {:keys [limit position] :as get-domain-names-request})

get-export clj

(get-export &
            {:keys [accepts export-type parameters rest-api-id stage-name]
             :as get-export-request})

get-gateway-response clj

(get-gateway-response &
                      {:keys [response-type rest-api-id]
                       :as get-gateway-response-request})

get-gateway-responses clj

(get-gateway-responses &
                       {:keys [limit position rest-api-id]
                        :as get-gateway-responses-request})

get-integration clj

(get-integration &
                 {:keys [http-method resource-id rest-api-id]
                  :as get-integration-request})

get-integration-response clj

(get-integration-response &
                          {:keys [http-method resource-id rest-api-id
                                  status-code]
                           :as get-integration-response-request})

get-method clj

(get-method &
            {:keys [http-method resource-id rest-api-id]
             :as get-method-request})

get-method-response clj

(get-method-response &
                     {:keys [http-method resource-id rest-api-id status-code]
                      :as get-method-response-request})

get-model clj

(get-model & {:keys [flatten model-name rest-api-id] :as get-model-request})

get-model-template clj

(get-model-template &
                    {:keys [model-name rest-api-id]
                     :as get-model-template-request})

get-models clj

(get-models & {:keys [limit position rest-api-id] :as get-models-request})

get-request-validator clj

(get-request-validator &
                       {:keys [request-validator-id rest-api-id]
                        :as get-request-validator-request})

get-request-validators clj

(get-request-validators &
                        {:keys [limit position rest-api-id]
                         :as get-request-validators-request})

get-resource clj

(get-resource &
              {:keys [embed resource-id rest-api-id] :as get-resource-request})

get-resources clj

(get-resources &
               {:keys [embed limit position rest-api-id]
                :as get-resources-request})

get-rest-api clj

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

get-rest-apis clj

(get-rest-apis & {:keys [limit position] :as get-rest-apis-request})

get-sdk clj

(get-sdk &
         {:keys [parameters rest-api-id sdk-type stage-name]
          :as get-sdk-request})

get-sdk-type clj

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

get-sdk-types clj

(get-sdk-types & {:keys [limit position] :as get-sdk-types-request})

get-stage clj

(get-stage & {:keys [rest-api-id stage-name] :as get-stage-request})

get-stages clj

(get-stages & {:keys [deployment-id rest-api-id] :as get-stages-request})

get-tags clj

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

get-usage clj

(get-usage &
           {:keys [end-date key-id limit position start-date usage-plan-id]
            :as get-usage-request})

get-usage-plan clj

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

get-usage-plan-key clj

(get-usage-plan-key &
                    {:keys [key-id usage-plan-id]
                     :as get-usage-plan-key-request})

get-usage-plan-keys clj

(get-usage-plan-keys &
                     {:keys [limit name-query position usage-plan-id]
                      :as get-usage-plan-keys-request})

get-usage-plans clj

(get-usage-plans & {:keys [key-id limit position] :as get-usage-plans-request})

get-vpc-link clj

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

get-vpc-links clj

(get-vpc-links & {:keys [limit position] :as get-vpc-links-request})

import-api-keys clj

(import-api-keys &
                 {:keys [body fail-on-warnings format]
                  :as import-api-keys-request})

import-documentation-parts clj

(import-documentation-parts &
                            {:keys [body fail-on-warnings mode rest-api-id]
                             :as import-documentation-parts-request})

import-rest-api clj

(import-rest-api &
                 {:keys [body fail-on-warnings parameters]
                  :as import-rest-api-request})

put-gateway-response clj

(put-gateway-response &
                      {:keys [response-parameters response-templates
                              response-type rest-api-id status-code]
                       :as put-gateway-response-request})

put-integration clj

(put-integration
  &
  {:keys [cache-key-parameters cache-namespace connection-id connection-type
          content-handling credentials http-method integration-http-method
          passthrough-behavior request-parameters request-templates resource-id
          rest-api-id timeout-in-millis tls-config type uri]
   :as put-integration-request})

put-integration-response clj

(put-integration-response &
                          {:keys [content-handling http-method resource-id
                                  response-parameters response-templates
                                  rest-api-id selection-pattern status-code]
                           :as put-integration-response-request})

put-method clj

(put-method &
            {:keys [api-key-required authorization-scopes authorization-type
                    authorizer-id http-method operation-name request-models
                    request-parameters request-validator-id resource-id
                    rest-api-id]
             :as put-method-request})

put-method-response clj

(put-method-response &
                     {:keys [http-method resource-id response-models
                             response-parameters rest-api-id status-code]
                      :as put-method-response-request})

put-rest-api clj

(put-rest-api &
              {:keys [body fail-on-warnings mode parameters rest-api-id]
               :as put-rest-api-request})

show-functions clj

shutdown clj

(shutdown)

tag-resource clj

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

test-invoke-authorizer clj

(test-invoke-authorizer &
                        {:keys [additional-context authorizer-id body headers
                                multi-value-headers path-with-query-string
                                rest-api-id stage-variables]
                         :as test-invoke-authorizer-request})

test-invoke-method clj

(test-invoke-method &
                    {:keys [body client-certificate-id headers http-method
                            multi-value-headers path-with-query-string
                            resource-id rest-api-id stage-variables]
                     :as test-invoke-method-request})

untag-resource clj

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

update-account clj

(update-account & {:keys [patch-operations] :as update-account-request})

update-api-key clj

(update-api-key & {:keys [api-key patch-operations] :as update-api-key-request})

update-authorizer clj

(update-authorizer &
                   {:keys [authorizer-id patch-operations rest-api-id]
                    :as update-authorizer-request})

update-base-path-mapping clj

(update-base-path-mapping &
                          {:keys [base-path domain-name patch-operations]
                           :as update-base-path-mapping-request})

update-client-certificate clj

(update-client-certificate &
                           {:keys [client-certificate-id patch-operations]
                            :as update-client-certificate-request})

update-deployment clj

(update-deployment &
                   {:keys [deployment-id patch-operations rest-api-id]
                    :as update-deployment-request})

update-documentation-part clj

(update-documentation-part &
                           {:keys [documentation-part-id patch-operations
                                   rest-api-id]
                            :as update-documentation-part-request})

update-documentation-version clj

(update-documentation-version &
                              {:keys [documentation-version patch-operations
                                      rest-api-id]
                               :as update-documentation-version-request})

update-domain-name clj

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

update-gateway-response clj

(update-gateway-response &
                         {:keys [patch-operations response-type rest-api-id]
                          :as update-gateway-response-request})

update-integration clj

(update-integration &
                    {:keys [http-method patch-operations resource-id
                            rest-api-id]
                     :as update-integration-request})

update-integration-response clj

(update-integration-response &
                             {:keys [http-method patch-operations resource-id
                                     rest-api-id status-code]
                              :as update-integration-response-request})

update-method clj

(update-method &
               {:keys [http-method patch-operations resource-id rest-api-id]
                :as update-method-request})

update-method-response clj

(update-method-response &
                        {:keys [http-method patch-operations resource-id
                                rest-api-id status-code]
                         :as update-method-response-request})

update-model clj

(update-model &
              {:keys [model-name patch-operations rest-api-id]
               :as update-model-request})

update-request-validator clj

(update-request-validator &
                          {:keys [patch-operations request-validator-id
                                  rest-api-id]
                           :as update-request-validator-request})

update-resource clj

(update-resource &
                 {:keys [patch-operations resource-id rest-api-id]
                  :as update-resource-request})

update-rest-api clj

(update-rest-api &
                 {:keys [patch-operations rest-api-id]
                  :as update-rest-api-request})

update-stage clj

(update-stage &
              {:keys [patch-operations rest-api-id stage-name]
               :as update-stage-request})

update-usage clj

(update-usage &
              {:keys [key-id patch-operations usage-plan-id]
               :as update-usage-request})

update-usage-plan clj

(update-usage-plan &
                   {:keys [patch-operations usage-plan-id]
                    :as update-usage-plan-request})

update-vpc-link clj

(update-vpc-link &
                 {:keys [patch-operations vpc-link-id]
                  :as update-vpc-link-request})