Liking cljdoc? Tell your friends :D
Clojure only.

amazonica.aws.apigateway


client-classclj


create-api-keyclj

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

create-authorizerclj

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

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

create-deploymentclj

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

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

create-documentation-versionclj

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

create-domain-nameclj

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

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

create-request-validatorclj

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

create-resourceclj

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

create-rest-apiclj

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

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

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

create-usage-plan-keyclj

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

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

delete-api-keyclj

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

delete-authorizerclj

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

delete-base-path-mappingclj

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

delete-client-certificateclj

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

delete-deploymentclj

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

delete-documentation-partclj

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

delete-documentation-versionclj

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

delete-domain-nameclj

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

delete-gateway-responseclj

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

delete-integrationclj

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

delete-integration-responseclj

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

delete-methodclj

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

delete-method-responseclj

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

delete-modelclj

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

delete-request-validatorclj

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

delete-resourceclj

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

delete-rest-apiclj

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

delete-stageclj

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

delete-usage-planclj

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

delete-usage-plan-keyclj

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

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

flush-stage-authorizers-cacheclj

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

flush-stage-cacheclj

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

generate-client-certificateclj

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

get-accountclj

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

get-api-keyclj

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

get-api-keysclj

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

get-authorizerclj

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

get-authorizersclj

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

get-base-path-mappingclj

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

get-base-path-mappingsclj

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

get-cached-response-metadataclj

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

get-client-certificateclj

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

get-client-certificatesclj

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

get-deploymentclj

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

get-deploymentsclj

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

get-documentation-partclj

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

get-documentation-partsclj

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

get-documentation-versionclj

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

get-documentation-versionsclj

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

get-domain-nameclj

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

get-domain-namesclj

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

get-exportclj

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

get-gateway-responseclj

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

get-gateway-responsesclj

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

get-integrationclj

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

get-integration-responseclj

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

get-methodclj

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

get-method-responseclj

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

get-modelclj

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

get-model-templateclj

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

get-modelsclj

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

get-request-validatorclj

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

get-request-validatorsclj

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

get-resourceclj

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

get-resourcesclj

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

get-rest-apiclj

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

get-rest-apisclj

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

get-sdkclj

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

get-sdk-typeclj

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

get-sdk-typesclj

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

get-stageclj

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

get-stagesclj

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

get-tagsclj

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

get-usageclj

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

get-usage-planclj

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

get-usage-plan-keyclj

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

get-usage-plan-keysclj

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

get-usage-plansclj

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

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

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

import-api-keysclj

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

import-documentation-partsclj

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

import-rest-apiclj

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

put-gateway-responseclj

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

put-integrationclj

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

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

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

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

put-rest-apiclj

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

show-functionsclj


shutdownclj

(shutdown)

tag-resourceclj

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

test-invoke-authorizerclj

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

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

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

update-accountclj

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

update-api-keyclj

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

update-authorizerclj

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

update-base-path-mappingclj

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

update-client-certificateclj

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

update-deploymentclj

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

update-documentation-partclj

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

update-documentation-versionclj

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

update-domain-nameclj

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

update-gateway-responseclj

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

update-integrationclj

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

update-integration-responseclj

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

update-methodclj

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

update-method-responseclj

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

update-modelclj

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

update-request-validatorclj

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

update-resourceclj

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

update-rest-apiclj

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

update-stageclj

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

update-usageclj

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

update-usage-planclj

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

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

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

× close